From f4afb901f792e37ccecfb08a4034526a0585dc58 Mon Sep 17 00:00:00 2001 From: Katarzyna Mielnik Date: Fri, 25 Aug 2023 15:50:57 +0200 Subject: [PATCH] change java_target_info to jvm_target_info --- aspects/rules/java/java_info.bzl | 146 +---------------- aspects/rules/jvm/jvm_info.bzl | 153 ++++++++++++++++++ aspects/rules/scala/scala_info.bzl | 6 +- aspects/utils/java_utils.bzl | 8 - .../bazel/install/EnvironmentCreatorTest.kt | 2 +- .../managers/BazelBspEnvironmentManager.kt | 11 +- .../bazel/server/sync/BazelProjectMapper.kt | 10 +- .../bsp/bazel/server/sync/TargetInfoReader.kt | 12 +- .../sync/languages/java/JavaLanguagePlugin.kt | 16 +- .../languages/thrift/ThriftLanguagePlugin.kt | 8 +- .../server/sync/proto/bsp_target_info.proto | 4 +- .../BazelBspEnvironmentManagerTest.kt | 26 ++- 12 files changed, 198 insertions(+), 204 deletions(-) create mode 100644 aspects/rules/jvm/jvm_info.bzl delete mode 100644 aspects/utils/java_utils.bzl diff --git a/aspects/rules/java/java_info.bzl b/aspects/rules/java/java_info.bzl index 556d2acae..a342ed600 100644 --- a/aspects/rules/java/java_info.bzl +++ b/aspects/rules/java/java_info.bzl @@ -1,148 +1,4 @@ -load("//aspects:utils/java_utils.bzl", "get_java_provider") -load("//aspects:utils/utils.bzl", "create_proto", "create_struct", "file_location", "is_external", "map", "to_file_location", "update_sync_output_groups") - -def map_with_resolve_files(f, xs): - results = [] - resolve_files = [] - - for x in xs: - if x != None: - res = f(x) - if res != None: - a, b = res - if a != None: - results.append(a) - if b != None: - resolve_files += b - - return results, resolve_files - -def get_interface_jars(output): - if hasattr(output, "compile_jar") and output.compile_jar: - return [output.compile_jar] - elif hasattr(output, "ijar") and output.ijar: - return [output.ijar] - else: - return [] - -def get_source_jars(output): - if hasattr(output, "source_jars"): - return output.source_jars - if hasattr(output, "source_jar"): - return [output.source_jar] - return [] - -def get_generated_jars(provider): - if hasattr(provider, "java_outputs"): - return map_with_resolve_files(to_generated_jvm_outputs, provider.java_outputs) - - if hasattr(provider, "annotation_processing") and provider.annotation_processing and provider.annotation_processing.enabled: - class_jar = provider.annotation_processing.class_jar - source_jar = provider.annotation_processing.source_jar - output = struct( - binary_jars = [file_location(class_jar)], - source_jars = [file_location(source_jar)], - ) - resolve_files = [class_jar, source_jar] - return [output], resolve_files - - return [], [] - -def to_generated_jvm_outputs(output): - if output == None or output.generated_class_jar == None: - return None - - class_jar = output.generated_class_jar - source_jar = output.generated_source_jar - - output = struct( - binary_jars = [file_location(class_jar)], - source_jars = [file_location(source_jar)], - ) - resolve_files = [class_jar, source_jar] - return output, resolve_files - -def to_jvm_outputs(output): - if output == None or output.class_jar == None: - return None - - binary_jars = [output.class_jar] - interface_jars = get_interface_jars(output) - source_jars = get_source_jars(output) - output = struct( - binary_jars = map(file_location, binary_jars), - interface_jars = map(file_location, interface_jars), - source_jars = map(file_location, source_jars), - ) - resolve_files = binary_jars + interface_jars + source_jars - return output, resolve_files - -def extract_runtime_jars(target, provider): - compilation_info = getattr(provider, "compilation_info", None) - - if compilation_info: - return compilation_info.runtime_classpath - - return getattr(provider, "transitive_runtime_jars", target[JavaInfo].transitive_runtime_jars) - -def extract_compile_jars(provider): - compilation_info = getattr(provider, "compilation_info", None) - transitive_compile_time_jars = getattr(provider, "transitive_compile_time_jars", depset()) - - return compilation_info.compilation_classpath if compilation_info else transitive_compile_time_jars - -def extract_java_info(target, ctx, output_groups, **kwargs): - provider = get_java_provider(target) - if not provider: - return None, None - - if hasattr(provider, "java_outputs") and provider.java_outputs: - java_outputs = provider.java_outputs - elif hasattr(provider, "outputs") and provider.outputs: - java_outputs = provider.outputs.jars - else: - return None, None - - resolve_files = [] - - jars, resolve_files_jars = map_with_resolve_files(to_jvm_outputs, java_outputs) - resolve_files += resolve_files_jars - - generated_jars, resolve_files_generated_jars = get_generated_jars(provider) - resolve_files += resolve_files_generated_jars - - runtime_jars = extract_runtime_jars(target, provider).to_list() - compile_jars = extract_compile_jars(provider).to_list() - source_jars = getattr(provider, "transitive_source_jars", depset()).to_list() - resolve_files += runtime_jars - resolve_files += compile_jars - resolve_files += source_jars - - runtime_classpath = map(file_location, runtime_jars) - compile_classpath = map(file_location, compile_jars) - source_classpath = map(file_location, source_jars) - - javac_opts = getattr(ctx.rule.attr, "javacopts", []) - jvm_flags = getattr(ctx.rule.attr, "jvm_flags", []) - args = getattr(ctx.rule.attr, "args", []) - main_class = getattr(ctx.rule.attr, "main_class", None) - - if (is_external(target)): - update_sync_output_groups(output_groups, "external-deps-resolve", depset(resolve_files)) - - info = create_struct( - jars = jars, - generated_jars = generated_jars, - runtime_classpath = runtime_classpath, - compile_classpath = compile_classpath, - source_classpath = source_classpath, - javac_opts = javac_opts, - jvm_flags = jvm_flags, - main_class = main_class, - args = args, - ) - - return create_proto(target, ctx, info, "java_target_info"), None +load("//aspects:utils/utils.bzl", "create_proto", "create_struct", "to_file_location") def extract_java_toolchain(target, ctx, dep_targets, **kwargs): toolchain = None diff --git a/aspects/rules/jvm/jvm_info.bzl b/aspects/rules/jvm/jvm_info.bzl new file mode 100644 index 000000000..0b0cf51d3 --- /dev/null +++ b/aspects/rules/jvm/jvm_info.bzl @@ -0,0 +1,153 @@ +load("//aspects:utils/utils.bzl", "create_proto", "create_struct", "file_location", "is_external", "map", "update_sync_output_groups") + +def map_with_resolve_files(f, xs): + results = [] + resolve_files = [] + + for x in xs: + if x != None: + res = f(x) + if res != None: + a, b = res + if a != None: + results.append(a) + if b != None: + resolve_files += b + + return results, resolve_files + +def get_interface_jars(output): + if hasattr(output, "compile_jar") and output.compile_jar: + return [output.compile_jar] + elif hasattr(output, "ijar") and output.ijar: + return [output.ijar] + else: + return [] + +def get_source_jars(output): + if hasattr(output, "source_jars"): + return output.source_jars + if hasattr(output, "source_jar"): + return [output.source_jar] + return [] + +def to_generated_jvm_outputs(output): + if output == None or output.generated_class_jar == None: + return None + + class_jar = output.generated_class_jar + source_jar = output.generated_source_jar + + output = struct( + binary_jars = [file_location(class_jar)], + source_jars = [file_location(source_jar)], + ) + resolve_files = [class_jar, source_jar] + return output, resolve_files + +def get_generated_jars(provider): + if hasattr(provider, "java_outputs"): + return map_with_resolve_files(to_generated_jvm_outputs, provider.java_outputs) + + if hasattr(provider, "annotation_processing") and provider.annotation_processing and provider.annotation_processing.enabled: + class_jar = provider.annotation_processing.class_jar + source_jar = provider.annotation_processing.source_jar + output = struct( + binary_jars = [file_location(class_jar)], + source_jars = [file_location(source_jar)], + ) + resolve_files = [class_jar, source_jar] + return [output], resolve_files + + return [], [] + +def to_jvm_outputs(output): + if output == None or output.class_jar == None: + return None + + binary_jars = [output.class_jar] + interface_jars = get_interface_jars(output) + source_jars = get_source_jars(output) + output = struct( + binary_jars = map(file_location, binary_jars), + interface_jars = map(file_location, interface_jars), + source_jars = map(file_location, source_jars), + ) + resolve_files = binary_jars + interface_jars + source_jars + return output, resolve_files + +def extract_runtime_jars(target, provider): + compilation_info = getattr(provider, "compilation_info", None) + + if compilation_info: + return compilation_info.runtime_classpath + + return getattr(provider, "transitive_runtime_jars", target[JavaInfo].transitive_runtime_jars) + +def extract_compile_jars(provider): + compilation_info = getattr(provider, "compilation_info", None) + transitive_compile_time_jars = getattr(provider, "transitive_compile_time_jars", depset()) + + return compilation_info.compilation_classpath if compilation_info else transitive_compile_time_jars + +def get_jvm_provider(target): + if hasattr(target, "scala"): + return target.scala + if hasattr(target, "kt") and hasattr(target.kt, "outputs"): + return target.kt + if JavaInfo in target: + return target[JavaInfo] + return None + +def extract_jvm_info(target, ctx, output_groups, **kwargs): + provider = get_jvm_provider(target) + if not provider: + return None, None + + if hasattr(provider, "java_outputs") and provider.java_outputs: + java_outputs = provider.java_outputs + elif hasattr(provider, "outputs") and provider.outputs: + java_outputs = provider.outputs.jars + else: + return None, None + + resolve_files = [] + + jars, resolve_files_jars = map_with_resolve_files(to_jvm_outputs, java_outputs) + resolve_files += resolve_files_jars + + generated_jars, resolve_files_generated_jars = get_generated_jars(provider) + resolve_files += resolve_files_generated_jars + + runtime_jars = extract_runtime_jars(target, provider).to_list() + compile_jars = extract_compile_jars(provider).to_list() + source_jars = getattr(provider, "transitive_source_jars", depset()).to_list() + resolve_files += runtime_jars + resolve_files += compile_jars + resolve_files += source_jars + + runtime_classpath = map(file_location, runtime_jars) + compile_classpath = map(file_location, compile_jars) + source_classpath = map(file_location, source_jars) + + javac_opts = getattr(ctx.rule.attr, "javacopts", []) + jvm_flags = getattr(ctx.rule.attr, "jvm_flags", []) + args = getattr(ctx.rule.attr, "args", []) + main_class = getattr(ctx.rule.attr, "main_class", None) + + if (is_external(target)): + update_sync_output_groups(output_groups, "external-deps-resolve", depset(resolve_files)) + + info = create_struct( + jars = jars, + generated_jars = generated_jars, + runtime_classpath = runtime_classpath, + compile_classpath = compile_classpath, + source_classpath = source_classpath, + javac_opts = javac_opts, + jvm_flags = jvm_flags, + main_class = main_class, + args = args, + ) + + return create_proto(target, ctx, info, "jvm_target_info"), None diff --git a/aspects/rules/scala/scala_info.bzl b/aspects/rules/scala/scala_info.bzl index b682e85c8..bc2a0ec6a 100644 --- a/aspects/rules/scala/scala_info.bzl +++ b/aspects/rules/scala/scala_info.bzl @@ -1,4 +1,3 @@ -load("//aspects:utils/java_utils.bzl", "get_java_provider") load("//aspects:utils/utils.bzl", "create_proto", "file_location", "is_external", "map", "update_sync_output_groups") def find_scalac_classpath(runfiles): @@ -32,10 +31,11 @@ def extract_scala_toolchain_info(target, ctx, output_groups, **kwargs): return create_proto(target, ctx, scala_toolchain_info, "scala_toolchain_info"), None def extract_scala_info(target, ctx, output_groups, **kwargs): - provider = get_java_provider(target) - if not provider: + if not hasattr(target, "scala"): return None, None + provider = target.scala + SCALA_TOOLCHAIN = "@io_bazel_rules_scala//scala:toolchain_type" # check of _scala_toolchain is necessary, because SCALA_TOOLCHAIN will always be present diff --git a/aspects/utils/java_utils.bzl b/aspects/utils/java_utils.bzl deleted file mode 100644 index 74c962b6e..000000000 --- a/aspects/utils/java_utils.bzl +++ /dev/null @@ -1,8 +0,0 @@ -def get_java_provider(target): - if hasattr(target, "scala"): - return target.scala - if hasattr(target, "kt") and hasattr(target.kt, "outputs"): - return target.kt - if JavaInfo in target: - return target[JavaInfo] - return None diff --git a/install/src/test/java/org/jetbrains/bsp/bazel/install/EnvironmentCreatorTest.kt b/install/src/test/java/org/jetbrains/bsp/bazel/install/EnvironmentCreatorTest.kt index 6f0e004ab..c397fd0b2 100644 --- a/install/src/test/java/org/jetbrains/bsp/bazel/install/EnvironmentCreatorTest.kt +++ b/install/src/test/java/org/jetbrains/bsp/bazel/install/EnvironmentCreatorTest.kt @@ -45,8 +45,8 @@ class EnvironmentCreatorTest { dotBazelBsp.resolve("aspects/rules").isDirectory() shouldBeEqual true dotBazelBsp.resolve("aspects/utils").isDirectory() shouldBeEqual true dotBazelBsp.resolve("aspects/utils/utils.bzl").exists() shouldBeEqual true - dotBazelBsp.resolve("aspects/utils/java_utils.bzl").exists() shouldBeEqual true dotBazelBsp.resolve("aspects/rules/java/java_info.bzl").exists() shouldBeEqual true + dotBazelBsp.resolve("aspects/rules/jvm/jvm_info.bzl").exists() shouldBeEqual true dotBazelBsp.resolve("aspects/rules/kt/kt_info.bzl").exists() shouldBeEqual true dotBazelBsp.resolve("aspects/rules/python/python_info.bzl").exists() shouldBeEqual true dotBazelBsp.resolve("aspects/rules/scala/scala_info.bzl").exists() shouldBeEqual true diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManager.kt b/server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManager.kt index b7ba0c87f..02cdc1bf1 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManager.kt +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManager.kt @@ -7,10 +7,8 @@ import java.nio.file.Paths import kotlin.io.path.writeText enum class Language(private val fileName: String, val functions: List) { - Java( - "//aspects:rules/java/java_info.bzl", - listOf("extract_java_info", "extract_java_toolchain", "extract_java_runtime") - ), + Java("//aspects:rules/java/java_info.bzl", listOf("extract_java_toolchain", "extract_java_runtime")), + Jvm("//aspects:rules/jvm/jvm_info.bzl", listOf("extract_jvm_info")), Scala("//aspects:rules/scala/scala_info.bzl", listOf("extract_scala_info", "extract_scala_toolchain_info")), Cpp("//aspects:rules/cpp/cpp_info.bzl", listOf("extract_cpp_info")), Kotlin("//aspects:rules/kt/kt_info.bzl", listOf("extract_kotlin_info")), @@ -46,7 +44,8 @@ class BazelBspEnvironmentManager( checkForLanguage(listOf("rules_cc"), Language.Cpp), checkForLanguage(listOf("io_bazel_rules_kotlin"), Language.Kotlin), checkForLanguage(listOf("io_bazel_rules_scala"), Language.Scala), - checkForLanguage(listOf("rules_java"), Language.Java) + checkForLanguage(listOf("rules_java"), Language.Java), + checkForLanguage(listOf("rules_java", "io_bazel_rules_kotlin", "io_bazel_rules_scala"), Language.Jvm) ) } @@ -83,8 +82,8 @@ class BazelBspEnvironmentManager( private fun createToolchainListString(languages: List): String = languages.mapNotNull { when (it) { - Language.Java -> """"@bazel_tools//tools/jdk:runtime_toolchain_type",""" Language.Scala -> """"@io_bazel_rules_scala//scala:toolchain_type"""" + Language.Java -> """"@bazel_tools//tools/jdk:runtime_toolchain_type"""" else -> null } } diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/BazelProjectMapper.kt b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/BazelProjectMapper.kt index 0e6a17abc..3d738ed79 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/BazelProjectMapper.kt +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/BazelProjectMapper.kt @@ -58,12 +58,12 @@ class BazelProjectMapper( private fun annotationProcessorLibraries(targetsToImport: Sequence): Map> { return targetsToImport - .filter { it.javaTargetInfo.generatedJarsList.isNotEmpty() } + .filter { it.jvmTargetInfo.generatedJarsList.isNotEmpty() } .associate { targetInfo -> targetInfo.id to Library( targetInfo.id + "_generated", - targetInfo.javaTargetInfo.generatedJarsList + targetInfo.jvmTargetInfo.generatedJarsList .flatMap { it.binaryJarsList } .map { bazelPathsResolver.resolveUri(it) } .toSet(), @@ -77,7 +77,7 @@ class BazelProjectMapper( private fun calculateKotlinStdlibsMapper(targetsToImport: Sequence): Map> { val projectLevelKotlinStdlibs = calculateProjectLevelKotlinStdlibs(targetsToImport) val rulesKotlinTargets = targetsToImport - .filter { targetInfo -> targetInfo.javaTargetInfo.compileClasspathList.any { it.isKotlinStdlibPath() } } + .filter { targetInfo -> targetInfo.jvmTargetInfo.compileClasspathList.any { it.isKotlinStdlibPath() } } .map { it.id } .toSet() return rulesKotlinTargets.associateWith { listOf(projectLevelKotlinStdlibs) } @@ -87,7 +87,7 @@ class BazelProjectMapper( Library( label = "rules_kotlin_kotlin-stdlibs", outputs = targets - .flatMap { it.javaTargetInfo.compileClasspathList } + .flatMap { it.jvmTargetInfo.compileClasspathList } .filter { it.isKotlinStdlibPath() } .map { bazelPathsResolver.resolveUri(it) } .toSet(), @@ -112,7 +112,7 @@ class BazelProjectMapper( } private fun getTargetJarUris(targetInfo: TargetInfo) = - targetInfo.javaTargetInfo.jarsList + targetInfo.jvmTargetInfo.jarsList .flatMap { it.binaryJarsList } .map { bazelPathsResolver.resolve(it).toUri() } .toSet() diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/TargetInfoReader.kt b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/TargetInfoReader.kt index 248acc519..aab000c6d 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/TargetInfoReader.kt +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/TargetInfoReader.kt @@ -7,7 +7,7 @@ import kotlinx.coroutines.flow.asFlow import kotlinx.coroutines.runBlocking import org.jetbrains.bsp.bazel.info.BspTargetInfo.CppTargetInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.JavaRuntimeInfo -import org.jetbrains.bsp.bazel.info.BspTargetInfo.JavaTargetInfo +import org.jetbrains.bsp.bazel.info.BspTargetInfo.JvmTargetInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.JavaToolchainInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.KotlinTargetInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.PythonTargetInfo @@ -45,8 +45,8 @@ class TargetInfoReader { // is run. In order to correctly address this issue, we would have to provide separate // entities (TargetInfos) for each target and each ruleset (or language) instead of just // entity-per-label. As long as we don't have it, in case of a conflict we just take the entity - // that contains JavaTargetInfo as currently it's the most important one for us. - .mapValues { it.value.find(TargetInfo::hasJavaTargetInfo) ?: it.value.first() } + // that contains JvmTargetInfo as currently it's the most important one for us. + .mapValues { it.value.find(TargetInfo::hasJvmTargetInfo) ?: it.value.first() } } private fun addExtensionInfo(uri: URI, builderMap: ConcurrentHashMap) { @@ -62,10 +62,10 @@ class TargetInfoReader { private fun addExtensionInfoToTarget( extensionName: String, uri: URI, targetInfoBuilder: TargetInfo.Builder ): TargetInfo.Builder = when (extensionName) { - "java_target_info" -> { - val builder = readFromFile(uri, JavaTargetInfo.newBuilder()) + "jvm_target_info" -> { + val builder = readFromFile(uri, JvmTargetInfo.newBuilder()) val info = builder.build() - targetInfoBuilder.setJavaTargetInfo(info) + targetInfoBuilder.setJvmTargetInfo(info) } "scala_target_info" -> { diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/java/JavaLanguagePlugin.kt b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/java/JavaLanguagePlugin.kt index 87700315d..a1ddc0896 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/java/JavaLanguagePlugin.kt +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/java/JavaLanguagePlugin.kt @@ -8,7 +8,7 @@ import ch.epfl.scala.bsp4j.JvmEnvironmentItem import ch.epfl.scala.bsp4j.JvmMainClass import org.jetbrains.bsp.bazel.bazelrunner.BazelInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.FileLocation -import org.jetbrains.bsp.bazel.info.BspTargetInfo.JavaTargetInfo +import org.jetbrains.bsp.bazel.info.BspTargetInfo.JvmTargetInfo import org.jetbrains.bsp.bazel.info.BspTargetInfo.JvmOutputsOrBuilder import org.jetbrains.bsp.bazel.info.BspTargetInfo.TargetInfo import org.jetbrains.bsp.bazel.server.sync.BazelPathsResolver @@ -33,7 +33,7 @@ class JavaLanguagePlugin( } override fun resolveModule(targetInfo: TargetInfo): JavaModule? = - targetInfo.takeIf(TargetInfo::hasJavaTargetInfo)?.javaTargetInfo?.run { + targetInfo.takeIf(TargetInfo::hasJvmTargetInfo)?.jvmTargetInfo?.run { val mainOutput = bazelPathsResolver.resolveUri(getJars(0).getBinaryJars(0)) val allOutputs = jarsList.flatMap { it.interfaceJarsList + it.binaryJarsList @@ -68,8 +68,8 @@ class JavaLanguagePlugin( override fun calculateSourceRoot(source: Path): Path = JVMLanguagePluginParser.calculateJVMSourceRoot(source) - private fun getMainClass(javaTargetInfo: JavaTargetInfo): String? = - javaTargetInfo.mainClass.takeUnless { javaTargetInfo.mainClass.isBlank() } + private fun getMainClass(jvmTargetInfo: JvmTargetInfo): String? = + jvmTargetInfo.mainClass.takeUnless { jvmTargetInfo.mainClass.isBlank() } private fun getJdk(): Jdk = jdk ?: throw RuntimeException("Failed to resolve JDK for project") @@ -81,7 +81,7 @@ class JavaLanguagePlugin( override fun dependencySources( targetInfo: TargetInfo, dependencyTree: DependencyTree ): Set = - targetInfo.getJavaTargetInfoOrNull()?.run { + targetInfo.getJvmTargetInfoOrNull()?.run { dependencyTree.transitiveDependenciesWithoutRootTargets(targetInfo.id) .flatMap(::getSourceJars) .map(bazelPathsResolver::resolveUri) @@ -89,13 +89,13 @@ class JavaLanguagePlugin( }.orEmpty() private fun getSourceJars(targetInfo: TargetInfo): List = - targetInfo.getJavaTargetInfoOrNull() + targetInfo.getJvmTargetInfoOrNull() ?.run { jarsOrBuilderList + generatedJarsList } ?.flatMap(JvmOutputsOrBuilder::getSourceJarsList) .orEmpty() - private fun TargetInfo.getJavaTargetInfoOrNull(): JavaTargetInfo? = - this.takeIf(TargetInfo::hasJavaTargetInfo)?.javaTargetInfo + private fun TargetInfo.getJvmTargetInfoOrNull(): JvmTargetInfo? = + this.takeIf(TargetInfo::hasJvmTargetInfo)?.jvmTargetInfo override fun applyModuleData(moduleData: JavaModule, buildTarget: BuildTarget) { val jvmBuildTarget = toJvmBuildTarget(moduleData) diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/thrift/ThriftLanguagePlugin.kt b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/thrift/ThriftLanguagePlugin.kt index a1f388e7e..3b846a075 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/thrift/ThriftLanguagePlugin.kt +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/languages/thrift/ThriftLanguagePlugin.kt @@ -22,15 +22,15 @@ class ThriftLanguagePlugin(private val bazelPathsResolver: BazelPathsResolver) : .map(bazelPathsResolver::resolveUri) .toHashSet() - val directSourceDeps = sourcesFromJavaTargetInfo(targetInfo) + val directSourceDeps = sourcesFromJvmTargetInfo(targetInfo) return transitiveSourceDeps + directSourceDeps } - private fun sourcesFromJavaTargetInfo(targetInfo: BspTargetInfo.TargetInfo): HashSet = - if (targetInfo.hasJavaTargetInfo()) { + private fun sourcesFromJvmTargetInfo(targetInfo: BspTargetInfo.TargetInfo): HashSet = + if (targetInfo.hasJvmTargetInfo()) { targetInfo - .javaTargetInfo + .jvmTargetInfo .jarsList .flatMap { it.sourceJarsList } .map(bazelPathsResolver::resolveUri) diff --git a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/proto/bsp_target_info.proto b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/proto/bsp_target_info.proto index 3ee294db7..2130d8571 100644 --- a/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/proto/bsp_target_info.proto +++ b/server/src/main/java/org/jetbrains/bsp/bazel/server/sync/proto/bsp_target_info.proto @@ -27,7 +27,7 @@ message JvmOutputs { repeated FileLocation source_jars = 3; } -message JavaTargetInfo { +message JvmTargetInfo { repeated JvmOutputs jars = 1; repeated JvmOutputs generated_jars = 2; repeated FileLocation runtime_classpath = 3; @@ -112,7 +112,7 @@ message TargetInfo { repeated FileLocation resources = 60; map env = 70; repeated string env_inherit = 80; - JavaTargetInfo java_target_info = 1000; + JvmTargetInfo jvm_target_info = 1000; JavaToolchainInfo java_toolchain_info = 2000; JavaRuntimeInfo java_runtime_info = 3000; ScalaTargetInfo scala_target_info = 4000; diff --git a/server/src/test/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManagerTest.kt b/server/src/test/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManagerTest.kt index cb2cd30ce..1e41c1106 100644 --- a/server/src/test/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManagerTest.kt +++ b/server/src/test/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspEnvironmentManagerTest.kt @@ -1,22 +1,14 @@ package org.jetbrains.bsp.bazel.server.bsp.managers import io.kotest.matchers.equals.shouldBeEqual -import io.kotest.matchers.shouldBe import org.eclipse.lsp4j.jsonrpc.CancelChecker -import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner -import org.jetbrains.bsp.bazel.logger.BspClientLogger import org.jetbrains.bsp.bazel.server.bsp.info.BspInfo import org.jetbrains.bsp.bazel.server.bsp.utils.InternalAspectsResolver -import org.jetbrains.bsp.bazel.workspacecontext.DefaultWorkspaceContextProvider import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test -import java.io.File import java.nio.file.Path -import java.nio.file.Paths import kotlin.io.path.createDirectory import kotlin.io.path.createTempDirectory -import kotlin.io.path.createTempFile -import kotlin.io.path.readLines class BazelBspEnvironmentManagerTest { @@ -34,10 +26,11 @@ class BazelBspEnvironmentManagerTest { private val emptyFileContent = "EXTENSIONS=[]TOOLCHAINS=[]" private val javaFileContent = - """load("//aspects:rules/java/java_info.bzl","extract_java_info","extract_java_toolchain","extract_java_runtime")""" + - """EXTENSIONS=[extract_java_info,extract_java_toolchain,extract_java_runtime]""" + + """load("//aspects:rules/java/java_info.bzl","extract_java_toolchain","extract_java_runtime")""" + + """load("//aspects:rules/jvm/jvm_info.bzl","extract_jvm_info")""" + + """EXTENSIONS=[extract_java_toolchain,extract_java_runtime,extract_jvm_info]""" + """TOOLCHAINS=["@bazel_tools//tools/jdk:runtime_toolchain_type"]""" - private val someExtensionsFileContent = + private val nonJvmExtensionsFileContent = """load("//aspects:rules/python/python_info.bzl","extract_python_info")""" + """load("//aspects:rules/cpp/cpp_info.bzl","extract_cpp_info")""" + """EXTENSIONS=[extract_python_info,extract_cpp_info]""" + @@ -47,10 +40,11 @@ class BazelBspEnvironmentManagerTest { """load("//aspects:rules/cpp/cpp_info.bzl","extract_cpp_info")""" + """load("//aspects:rules/kt/kt_info.bzl","extract_kotlin_info")""" + """load("//aspects:rules/scala/scala_info.bzl","extract_scala_info","extract_scala_toolchain_info")""" + - """load("//aspects:rules/java/java_info.bzl","extract_java_info","extract_java_toolchain","extract_java_runtime")""" + + """load("//aspects:rules/java/java_info.bzl","extract_java_toolchain","extract_java_runtime")""" + + """load("//aspects:rules/jvm/jvm_info.bzl","extract_jvm_info")""" + """EXTENSIONS=[extract_python_info,extract_cpp_info,extract_kotlin_info,extract_scala_info,extract_scala_toolchain_info,""" + - """extract_java_info,extract_java_toolchain,extract_java_runtime]""" + - """TOOLCHAINS=["@bazel_tools//tools/jdk:runtime_toolchain_type", "@io_bazel_rules_scala//scala:toolchain_type"]""" + """extract_java_toolchain,extract_java_runtime,extract_jvm_info]""" + + """TOOLCHAINS=["@io_bazel_rules_scala//scala:toolchain_type","@bazel_tools//tools/jdk:runtime_toolchain_type"]""" private lateinit var dotBazelBspAspectsPath: Path private lateinit var internalAspectsResolverMock: InternalAspectsResolver @@ -99,7 +93,7 @@ class BazelBspEnvironmentManagerTest { } @Test - fun `should create the extensions dot bzl file with cc and python imports and without any toolchains`() { + fun `should create the extensions dot bzl file with non-jvm imports and without any toolchains`() { // given val bazelExternalRulesQuery = BazelExternalRulesQueryMock( listOf( @@ -115,7 +109,7 @@ class BazelBspEnvironmentManagerTest { // then val fileContent = getExtensionsFileContent() - fileContent shouldBeEqual someExtensionsFileContent + fileContent shouldBeEqual nonJvmExtensionsFileContent } @Test