From 8a1627dec7eb03c37e31fc3b7113fad688005ae2 Mon Sep 17 00:00:00 2001 From: Leonid Shalupov Date: Thu, 21 Aug 2025 23:12:21 +0200 Subject: [PATCH] bazel: separate ultimate & community provided maven libraries if a library is used as provided in the ultimate part, do not define it in community as provided, do that in the ultimate this removes differences upon running generator in ultimate and community GitOrigin-RevId: a5be6d95f27d40a2b3ec8d398f48c8d101c697da --- .../build/bazel/BazelBuildFileGenerator.kt | 62 +++++++++++++---- .../intellij/build/bazel/dependency.kt | 12 +++- .../org/jetbrains/intellij/build/bazel/lib.kt | 68 ++++++++++++------- 3 files changed, 103 insertions(+), 39 deletions(-) diff --git a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/BazelBuildFileGenerator.kt b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/BazelBuildFileGenerator.kt index af08d8f9f4ab..06632212328e 100644 --- a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/BazelBuildFileGenerator.kt +++ b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/BazelBuildFileGenerator.kt @@ -4,6 +4,7 @@ package org.jetbrains.intellij.build.bazel import com.intellij.openapi.util.NlsSafe +import com.intellij.util.containers.MultiMap import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap import org.jetbrains.jps.model.JpsProject import org.jetbrains.jps.model.java.JavaResourceRootProperties @@ -25,10 +26,8 @@ import org.jetbrains.kotlin.jps.model.JpsKotlinFacetModuleExtension import java.nio.file.Path import java.util.IdentityHashMap import java.util.TreeMap -import kotlin.io.path.extension import kotlin.io.path.invariantSeparatorsPathString import kotlin.io.path.relativeTo -import kotlin.io.path.walk import kotlin.reflect.KProperty1 import kotlin.reflect.full.memberProperties import kotlin.reflect.jvm.javaField @@ -162,9 +161,9 @@ internal class BazelBuildFileGenerator( private val providedLibraries: ProvidedLibraries = ProvidedLibraries() class ProvidedLibraries() { - private val providedLibraries: MutableSet = mutableSetOf() - fun isProvided(library: Library): Boolean = providedLibraries.contains(library) - fun markAsProvided(library: Library) { providedLibraries.add(library) } + private val providedLibraries: MultiMap = MultiMap() + fun getProvidedContexts(library: Library): Collection = providedLibraries[library] + fun markAsProvided(library: Library, container: LibraryContainer) { providedLibraries.putValue(library, container) } } private val generated = IdentityHashMap() @@ -201,7 +200,7 @@ internal class BazelBuildFileGenerator( ) { val fileToLabelTracker = LinkedHashMap>() val fileToUpdater = LinkedHashMap() - for ((owner, list) in mavenLibraries + for ((libraryContainer, list) in mavenLibraries .values .groupByTo( destination = TreeMap( @@ -212,7 +211,7 @@ internal class BazelBuildFileGenerator( ), keySelector = { it.target.container }, )) { - val bazelFileUpdater = fileToUpdater.computeIfAbsent(owner.buildFile) { + val bazelFileUpdater = fileToUpdater.computeIfAbsent(libraryContainer.buildFile) { val updater = BazelFileUpdater(it) updater.removeSections("maven-libs") updater.removeSections("maven libs") @@ -223,8 +222,8 @@ internal class BazelBuildFileGenerator( val groupedByTargetName = sortedList.groupBy { it.target.targetName } - val labelTracker = fileToLabelTracker.computeIfAbsent(owner.moduleFile) { HashSet() } - buildFile(out = bazelFileUpdater, sectionName = owner.sectionName) { + val labelTracker = fileToLabelTracker.computeIfAbsent(libraryContainer.moduleFile) { HashSet() } + buildFile(out = bazelFileUpdater, sectionName = libraryContainer.sectionName) { load("@rules_jvm//:jvm.bzl", "jvm_import") for (entry in groupedByTargetName) { @@ -232,13 +231,38 @@ internal class BazelBuildFileGenerator( if (libs.size > 1) { throw IllegalStateException("More than one versions: $entry") } - generateMavenLib(lib = libs.single(), labelTracker = labelTracker, isLibraryProvided = providedLibraries::isProvided, libVisibility = owner.visibility) + generateMavenLib( + lib = libs.single(), + labelTracker = labelTracker, + isLibraryProvided = { providedLibraries.getProvidedContexts(it).contains(libraryContainer) }, + libVisibility = libraryContainer.visibility, + ) + } + + // provided libraries which are defined in community + // but used as provided libraries in the ultimate part + if (libraryContainer == ultimateLibraries) { + val communityLibrariesWithProvidedUsagesInUltimate = mavenLibraries + .values + .filter { + it.target.container == communityLibraries && + providedLibraries.getProvidedContexts(it).contains(ultimateLibraries) + } + .sortedBy { it.target.targetName } + + for (lib in communityLibrariesWithProvidedUsagesInUltimate) { + generateProvidedMavenLib( + lib = lib, + libVisibility = libraryContainer.visibility, + targetContainer = communityLibraries, + ) + } } } generateBazelModuleSectionsForLibs( list = sortedList, - owner = owner, + owner = libraryContainer, jarRepositories = jarRepositories, m2Repo = m2Repo, urlCache = urlCache, @@ -247,7 +271,15 @@ internal class BazelBuildFileGenerator( ) } - generateLocalLibs(libs = localLibraries.values, isLibraryProvided = providedLibraries::isProvided, fileToUpdater = fileToUpdater) + generateLocalLibs( + libs = localLibraries.values, + isLibraryProvided = { lib -> + providedLibraries + .getProvidedContexts(lib) + .contains(lib.target.container) + }, + fileToUpdater = fileToUpdater, + ) for (updater in fileToUpdater.values) { updater.save() @@ -259,7 +291,7 @@ internal class BazelBuildFileGenerator( val communityLibrary = mavenLibraries[LibraryKey(communityLibraries, lib.target.targetName)] if (communityLibrary != null) { if (isProvided) { - providedLibraries.markAsProvided(communityLibrary) + providedLibraries.markAsProvided(communityLibrary, ultimateLibraries) } return communityLibrary } @@ -267,7 +299,7 @@ internal class BazelBuildFileGenerator( val internedLib = mavenLibraries.computeIfAbsent(LibraryKey(lib.target.container, lib.target.targetName)) { lib } if (isProvided) { - providedLibraries.markAsProvided(internedLib) + providedLibraries.markAsProvided(internedLib, internedLib.target.container) } return internedLib } @@ -275,7 +307,7 @@ internal class BazelBuildFileGenerator( fun addLocalLibrary(lib: LocalLibrary, isProvided: Boolean): LocalLibrary { val internedLib = localLibraries.computeIfAbsent(LibraryKey(lib.target.container, lib.target.targetName)) { lib } if (isProvided) { - providedLibraries.markAsProvided(internedLib) + providedLibraries.markAsProvided(internedLib, internedLib.target.container) } return internedLib } diff --git a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/dependency.kt b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/dependency.kt index b696b14356b8..2d869878b285 100644 --- a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/dependency.kt +++ b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/dependency.kt @@ -239,7 +239,17 @@ internal fun generateDeps( isProvided = isProvided, ).target.container - val libLabel = BazelLabel("${libraryContainer.repoLabel}//:$targetName$targetNameSuffix", module = null) + val containerForLabel = if (isProvided) { + // provided libraries for ultimate are defined in ultimate + // provided libraries for community are defined in community + context.getLibraryContainer(module.isCommunity) + } + else { + // libraries (not provided) used both in ultimate & community are defined in community + libraryContainer + } + + val libLabel = BazelLabel("${containerForLabel.repoLabel}//:$targetName$targetNameSuffix", module = null) addDep( isTest = isTest, diff --git a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/lib.kt b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/lib.kt index 82df5703ac32..3c4117f70930 100644 --- a/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/lib.kt +++ b/platform/build-scripts/bazel/src/org/jetbrains/intellij/build/bazel/lib.kt @@ -84,12 +84,9 @@ internal fun BuildFile.generateMavenLib( return } - var exportedCompilerPlugins = emptyList() if (lib.jars.size == 1) { val jar = lib.jars.single() - @Suppress("UnnecessaryVariable") - val libName = targetName - if (!labelTracker.add(libName)) { + if (!labelTracker.add(targetName)) { return } @@ -102,8 +99,7 @@ internal fun BuildFile.generateMavenLib( option("source_jar", "@${fileToHttpRuleFile(sourceJar.path)}") } if (targetName == "kotlinx-serialization-core") { - exportedCompilerPlugins = listOf("@lib//:kotlin-serialization-plugin") - option("exported_compiler_plugins", exportedCompilerPlugins) + option("exported_compiler_plugins", listOf("@lib//:kotlin-serialization-plugin")) } libVisibility?.let { @@ -140,25 +136,51 @@ internal fun BuildFile.generateMavenLib( } if (isLibraryProvided(lib)) { - if (exportedCompilerPlugins.isEmpty()) { - target("java_library") { - option("name", targetName + PROVIDED_SUFFIX) - option("exports", listOf(":$targetName")) - option("neverlink", true) - libVisibility?.let { - visibility(arrayOf(it)) - } + generateProvidedMavenLib(lib = lib, libVisibility = libVisibility) + } +} + +internal fun BuildFile.generateProvidedMavenLib( + lib: MavenLibrary, + libVisibility: String?, + targetContainer: LibraryContainer? = null, +) { + val targetName = lib.target.targetName + @Suppress("SpellCheckingInspection") + if (targetName == "bifurcan" || targetName == "kotlinx-collections-immutable-jvm") { + return + } + + val exportedCompilerPlugins = when (targetName) { + "kotlinx-serialization-core" -> listOf("@lib//:kotlin-serialization-plugin") + else -> emptyList() + } + + val exportsLabel = if (targetContainer == null) { + ":$targetName" + } + else { + "${targetContainer.repoLabel}//:$targetName" + } + + if (exportedCompilerPlugins.isEmpty()) { + target("java_library") { + option("name", targetName + PROVIDED_SUFFIX) + option("exports", listOf(exportsLabel)) + option("neverlink", true) + libVisibility?.let { + visibility(arrayOf(it)) } } - else { - target("kt_jvm_library") { - option("name", targetName + PROVIDED_SUFFIX) - option("exports", listOf(":$targetName")) - option("neverlink", true) - option("exported_compiler_plugins", exportedCompilerPlugins) - libVisibility?.let { - visibility(arrayOf(it)) - } + } + else { + target("kt_jvm_library") { + option("name", targetName + PROVIDED_SUFFIX) + option("exports", listOf(exportsLabel)) + option("neverlink", true) + option("exported_compiler_plugins", exportedCompilerPlugins) + libVisibility?.let { + visibility(arrayOf(it)) } } }