From edcfd4b95ff0f7a3843a7161a99299afcec3c04f Mon Sep 17 00:00:00 2001 From: Katarzyna Mielnik Date: Wed, 30 Aug 2023 10:56:11 +0000 Subject: [PATCH] [maintenance] change kotlin and scala providers, rename `JavaTargetInfo` to `JvmTargetInfo` checking rule kind add checking for JavaInfo in target Revert "add that comma back" This reverts commit 0695724acd647fd3f1bb505db1b1f34dee9a3236. add that comma back change java_target_info to jvm_target_info remove that scala thing change kotlin and scala providers, add toolchains to extensions.bzl file Merge-request: BAZEL-MR-473 Merged-by: Katarzyna Mielnik --- aspects/core.bzl | 5 +- aspects/extensions.bzl | 3 +- aspects/rules/java/java_info.bzl | 146 +---------------- aspects/rules/jvm/jvm_info.bzl | 153 ++++++++++++++++++ aspects/rules/kt/kt_info.bzl | 17 +- aspects/rules/scala/scala_info.bzl | 39 ++--- aspects/utils/java_utils.bzl | 8 - .../bazel/install/EnvironmentCreatorTest.kt | 2 +- .../managers/BazelBspEnvironmentManager.kt | 23 ++- .../bazel/server/sync/BazelProjectMapper.kt | 12 +- .../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 | 37 ++--- 15 files changed, 235 insertions(+), 250 deletions(-) create mode 100644 aspects/rules/jvm/jvm_info.bzl delete mode 100644 aspects/utils/java_utils.bzl diff --git a/aspects/core.bzl b/aspects/core.bzl index 535416446..e36cc4d80 100644 --- a/aspects/core.bzl +++ b/aspects/core.bzl @@ -1,6 +1,5 @@ load("//aspects:utils/utils.bzl", "abs", "create_struct", "file_location", "get_aspect_ids", "update_sync_output_groups") -load("//aspects:rules/java/java_info.bzl", "JAVA_RUNTIME_TOOLCHAIN_TYPE") -load("//aspects:extensions.bzl", "EXTENSIONS") +load("//aspects:extensions.bzl", "EXTENSIONS", "TOOLCHAINS") def create_all_extension_info(target, ctx, output_groups, dep_targets): info = [create_extension_info(target = target, ctx = ctx, output_groups = output_groups, dep_targets = dep_targets) for create_extension_info in EXTENSIONS] @@ -186,5 +185,5 @@ bsp_target_info_aspect = aspect( implementation = _bsp_target_info_aspect_impl, required_aspect_providers = [[JavaInfo]], attr_aspects = ALL_DEPS, - toolchains = [JAVA_RUNTIME_TOOLCHAIN_TYPE], + toolchains = TOOLCHAINS, ) diff --git a/aspects/extensions.bzl b/aspects/extensions.bzl index e5209e955..0c9d1ca73 100644 --- a/aspects/extensions.bzl +++ b/aspects/extensions.bzl @@ -1,2 +1,3 @@ -# This file is supposed to be overwritten with extensions relevant to the project. +# This file is supposed to be overwritten with extensions and toolchains relevant to the project. EXTENSIONS = [] +TOOLCHAINS = [] 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/kt/kt_info.bzl b/aspects/rules/kt/kt_info.bzl index 66066aeac..9736f0d7f 100644 --- a/aspects/rules/kt/kt_info.bzl +++ b/aspects/rules/kt/kt_info.bzl @@ -1,15 +1,12 @@ +load("@io_bazel_rules_kotlin//kotlin/internal:defs.bzl", "KtJvmInfo") +load("@io_bazel_rules_kotlin//kotlin/internal:opts.bzl", "KotlincOptions") load("//aspects:utils/utils.bzl", "create_proto", "create_struct") def extract_kotlin_info(target, ctx, **kwargs): - # if KtJvmInfo not in target: - # return None, None - - # provider = target[KtJvmInfo] - - if not hasattr(target, "kt"): + if KtJvmInfo not in target: return None, None - provider = target.kt + provider = target[KtJvmInfo] # Only supports JVM platform now if not hasattr(provider, "language_version"): @@ -20,10 +17,10 @@ def extract_kotlin_info(target, ctx, **kwargs): associates = getattr(ctx.rule.attr, "associates", []) associates_labels = [str(associate.label) for associate in associates] - # kotlinc_opts_target = getattr(ctx.rule.attr, "kotlinc_opts", None) + kotlinc_opts_target = getattr(ctx.rule.attr, "kotlinc_opts", None) kotlinc_opts = None - # if kotlinc_opts_target != None and KotlincOptions in kotlinc_opts_target: - # kotlinc_opts = kotlinc_opts_target[KotlincOptions] + if kotlinc_opts_target != None and KotlincOptions in kotlinc_opts_target: + kotlinc_opts = kotlinc_opts_target[KotlincOptions] kotlin_info = dict( language_version = language_version, diff --git a/aspects/rules/scala/scala_info.bzl b/aspects/rules/scala/scala_info.bzl index 2e7f46ed6..d9aa5f925 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,39 +31,19 @@ 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: + kind = ctx.rule.kind + if not kind.startswith("scala_") and not kind.startswith("thrift_"): return None, None - # proper solution, but it requires adding scala_toolchain to the aspect - # SCALA_TOOLCHAIN = "@io_bazel_rules_scala//scala:toolchain_type" - # check of _scala_toolchain is necessary, because SCALA_TOOLCHAIN will always be present - # if hasattr(ctx.rule.attr, "_scala_toolchain"): - # common_scalac_opts = ctx.toolchains[SCALA_TOOLCHAIN].scalacopts - # else: - # common_scalac_opts = [] - # scalac_opts = common_scalac_opts + getattr(ctx.rule.attr, "scalacopts", []) - - scalac_opts = [] + SCALA_TOOLCHAIN = "@io_bazel_rules_scala//scala:toolchain_type" - # don't bother inspecting non-scala targets + # check of _scala_toolchain is necessary, because SCALA_TOOLCHAIN will always be present if hasattr(ctx.rule.attr, "_scala_toolchain"): - for action in target.actions: - if action.mnemonic == "Scalac": - found_scalac_opts = False - for arg in action.argv: - if arg == "--ScalacOpts": - found_scalac_opts = True - elif found_scalac_opts: - # Next worker option appeared. - # Currently --ScalacOpts is the last one, but just in case - if arg.startswith("--"): - break - scalac_opts.append(arg) - break + common_scalac_opts = ctx.toolchains[SCALA_TOOLCHAIN].scalacopts + else: + common_scalac_opts = [] + scalac_opts = common_scalac_opts + getattr(ctx.rule.attr, "scalacopts", []) - scala_info = struct( - scalac_opts = scalac_opts, - ) + scala_info = struct(scalac_opts = scalac_opts) return create_proto(target, ctx, scala_info, "scala_target_info"), None 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 22762b535..936c44ba1 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 @@ -42,8 +42,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 2f34e0e8f..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) ) } @@ -63,7 +62,8 @@ class BazelBspEnvironmentManager( listOf( "# This is a generated file, do not edit it", createLoadStatementsString(languages), - createExtensionListString(languages) + createExtensionListString(languages), + createToolchainListString(languages) ).joinToString( separator = "\n", postfix = "\n" @@ -79,6 +79,17 @@ class BazelBspEnvironmentManager( return functionNames.joinToString(prefix = "EXTENSIONS = [\n", postfix = "\n]", separator = ",\n ") { "\t$it" } } + private fun createToolchainListString(languages: List): String = + languages.mapNotNull { + when (it) { + Language.Scala -> """"@io_bazel_rules_scala//scala:toolchain_type"""" + Language.Java -> """"@bazel_tools//tools/jdk:runtime_toolchain_type"""" + else -> null + } + } + .joinToString(prefix = "TOOLCHAINS = [\n", postfix = "\n]", separator = ",\n ") { "\t$it" } + + private fun createNewExtensionsFile(fileContent: String) { val aspectsPath = Paths.get(internalAspectsResolver.bazelBspRoot, Constants.ASPECTS_ROOT) val file = aspectsPath.resolve("extensions.bzl") 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 e37d48e34..99b69c1d1 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( label = targetInfo.id + "_generated", - outputs = targetInfo.javaTargetInfo.generatedJarsList + outputs = targetInfo.jvmTargetInfo.generatedJarsList .flatMap { it.binaryJarsList } .map { bazelPathsResolver.resolveUri(it) } .toSet(), @@ -78,7 +78,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) } @@ -88,7 +88,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(), @@ -118,12 +118,12 @@ class BazelProjectMapper( map { bazelPathsResolver.resolve(it).toUri() }.toSet() private fun getTargetJarUris(targetInfo: TargetInfo) = - targetInfo.javaTargetInfo.jarsList + targetInfo.jvmTargetInfo.jarsList .flatMap { it.binaryJarsList } .resolveUris() private fun getSourceJarUris(targetInfo: TargetInfo) = - targetInfo.javaTargetInfo.jarsList + targetInfo.jvmTargetInfo.jarsList .flatMap { it.sourceJarsList } .resolveUris() 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 73a848686..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 { @@ -32,22 +24,27 @@ class BazelBspEnvironmentManagerTest { override fun checkCanceled() {} } - private val emptyFileContent = "EXTENSIONS=[]" + 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]""" - private val someExtensionsFileContent = + """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 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]""" + """EXTENSIONS=[extract_python_info,extract_cpp_info]""" + + """TOOLCHAINS=[]""" private val allExtensionsFileContent = """load("//aspects:rules/python/python_info.bzl","extract_python_info")""" + """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]""" + """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 @@ -66,7 +63,7 @@ class BazelBspEnvironmentManagerTest { } @Test - fun `should create the extensions dot bzl file with no imports`() { + fun `should create the extensions dot bzl file with no imports and no toolchains`() { // given val bazelExternalRulesQuery = BazelExternalRulesQueryMock(emptyList()) val bazelBspEnvironmentManager = @@ -81,7 +78,7 @@ class BazelBspEnvironmentManagerTest { } @Test - fun `should create the extensions dot bzl file with one import (java)`() { + fun `should create the extensions dot bzl file with one import and one toolchain (java)`() { // given val bazelExternalRulesQuery = BazelExternalRulesQueryMock(listOf("rules_java")) val bazelBspEnvironmentManager = @@ -96,7 +93,7 @@ class BazelBspEnvironmentManagerTest { } @Test - fun `should create the extensions dot bzl file with some imports`() { + fun `should create the extensions dot bzl file with non-jvm imports and without any toolchains`() { // given val bazelExternalRulesQuery = BazelExternalRulesQueryMock( listOf( @@ -112,11 +109,11 @@ class BazelBspEnvironmentManagerTest { // then val fileContent = getExtensionsFileContent() - fileContent shouldBeEqual someExtensionsFileContent + fileContent shouldBeEqual nonJvmExtensionsFileContent } @Test - fun `should create the extensions dot bzl file with all possible imports`() { + fun `should create the extensions dot bzl file with all possible imports and toolchains`() { // given val bazelExternalRulesQuery = BazelExternalRulesQueryMock( listOf(