[Gradle] Implement and re-use resolvableMetadataConfiguration for Source Sets

^KT-55289 Verification Pending

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeOriginalMetadataDependencyResolver.kt

@@ -12,12 +12,12 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.ide.IdeDependencyResolver
 import org.jetbrains.kotlin.gradle.plugin.ide.IdeaKotlinBinaryCoordinates
 import org.jetbrains.kotlin.gradle.plugin.mpp.MetadataDependencyResolution
-import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfigurationForSourceSets
-import org.jetbrains.kotlin.gradle.plugin.sources.project
+import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
 
 object IdeOriginalMetadataDependencyResolver : IdeDependencyResolver {
     override fun resolve(sourceSet: KotlinSourceSet): Set<IdeaKotlinDependency> {
-        val metadataDependenciesConfiguration = resolvableMetadataConfigurationForSourceSets(sourceSet.project, listOf(sourceSet))
+        val metadataDependenciesConfiguration = sourceSet.internal.resolvableMetadataConfiguration
 
         val keptOriginalDependencyResolutionIds = sourceSet.resolveMetadata<MetadataDependencyResolution.KeepOriginalDependency>()
             .map { it.dependency.id }.toSet()

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdePlatformDependencyResolver.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.gradle.plugin.ide.dependencyResolvers
 
 import org.gradle.api.artifacts.ArtifactView
-import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.component.LibraryBinaryIdentifier
 import org.gradle.api.artifacts.component.ModuleComponentIdentifier
 import org.gradle.api.artifacts.component.ModuleComponentSelector
@@ -28,9 +27,11 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMetadataCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmFragment
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmVariant
-import org.jetbrains.kotlin.gradle.plugin.sources.*
-import org.jetbrains.kotlin.gradle.targets.metadata.ALL_COMPILE_METADATA_CONFIGURATION_NAME
-import org.jetbrains.kotlin.tooling.core.extrasReadWriteProperty
+import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
+import org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.sources.InternalKotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
+import org.jetbrains.kotlin.gradle.plugin.sources.project
 import org.jetbrains.kotlin.tooling.core.mutableExtrasOf
 
 internal class IdePlatformDependencyResolver(
@@ -157,34 +158,11 @@ internal class IdePlatformDependencyResolver(
 
     private fun ArtifactResolutionStrategy.PlatformLikeSourceSet.createArtifactView(sourceSet: InternalKotlinSourceSet): ArtifactView? {
         if (sourceSet !is DefaultKotlinSourceSet) return null
+        val project = sourceSet.project
 
-        val platformLikeCompileDependenciesConfiguration = sourceSet.platformLikeCompileDependenciesConfiguration ?: run {
-            /* Create new 'platform like compileDependencies configuration */
-            val configuration = sourceSet.project.configurations.detachedConfiguration()
-            configuration.attributes.setupPlatformResolutionAttributes(sourceSet)
-
-            ((sourceSet.getAdditionalVisibleSourceSets() + sourceSet).withDependsOnClosure).forEach { visibleSourceSet ->
-                configuration.dependencies.addAll(
-                    sourceSet.project.configurations.getByName(visibleSourceSet.apiConfigurationName).allDependencies
-                )
-
-                configuration.dependencies.addAll(
-                    sourceSet.project.configurations.getByName(visibleSourceSet.implementationConfigurationName).allDependencies
-                )
-
-                configuration.dependencies.addAll(
-                    sourceSet.project.configurations.getByName(visibleSourceSet.compileOnlyConfigurationName).allDependencies
-                )
-            }
-
-            /* Ensure consistent dependency resolution result within the whole module */
-            configuration.shouldResolveConsistentlyWith(
-                sourceSet.project.configurations.getByName(ALL_COMPILE_METADATA_CONFIGURATION_NAME)
-            )
-
-            sourceSet.platformLikeCompileDependenciesConfiguration = configuration
-            configuration
-        }
+        val platformLikeCompileDependenciesConfiguration = project.configurations.detachedConfiguration()
+        platformLikeCompileDependenciesConfiguration.attributes.setupPlatformResolutionAttributes(sourceSet)
+        platformLikeCompileDependenciesConfiguration.dependencies.addAll(sourceSet.resolvableMetadataConfiguration.allDependencies)
 
         return platformLikeCompileDependenciesConfiguration.incoming.artifactView { view ->
             view.isLenient = true
@@ -194,9 +172,5 @@ internal class IdePlatformDependencyResolver(
 
     private companion object {
         val logger: Logger = Logging.getLogger(IdePlatformDependencyResolver::class.java)
-
-        /* This special 'platform like compileDependency configurations' can be attached to the SourceSet and re-used */
-        var InternalKotlinSourceSet.platformLikeCompileDependenciesConfiguration: Configuration?
-                by extrasReadWriteProperty("platformLikeCompileDependenciesConfiguration")
     }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeSlowSourcesAndDocumentationResolver.kt

@@ -17,13 +17,14 @@ import org.jetbrains.kotlin.gradle.idea.tcs.IdeaKotlinResolvedBinaryDependency
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.ide.IdeDependencyResolver
 import org.jetbrains.kotlin.gradle.plugin.ide.IdeaKotlinBinaryCoordinates
-import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfigurationForSourceSets
+import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
 import org.jetbrains.kotlin.gradle.plugin.sources.project
 
 internal object IdeSlowSourcesAndDocumentationResolver : IdeDependencyResolver {
     override fun resolve(sourceSet: KotlinSourceSet): Set<IdeaKotlinDependency> {
         val project = sourceSet.project
-        val configuration = resolvableMetadataConfigurationForSourceSets(sourceSet.project, listOf(sourceSet))
+        val configuration = sourceSet.internal.resolvableMetadataConfiguration
         val resolutionResult = project.dependencies.createArtifactResolutionQuery()
             .forComponents(configuration.incoming.resolutionResult.allComponents.map { it.id })
             .withArtifacts(JvmLibrary::class.java, SourcesArtifact::class.java, JavadocArtifact::class.java)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/GranularMetadataTransformation.kt

@@ -307,13 +307,6 @@ internal fun ResolvedComponentResult.toProjectOrNull(currentProject: Project): P
     }
 }
 
-internal fun resolvableMetadataConfigurationForSourceSets(
-    project: Project,
-    sourceSets: Iterable<KotlinSourceSet>,
-): Configuration = resolvableMetadataConfigurationForDependencies(
-    project,
-    sourceSets.flatMapTo(mutableListOf()) { requestedDependencies(project, it, KotlinDependencyScope.compileScopes) }
-)
 
 /** If a source set is not a published source set, its dependencies are not included in [allSourceSetsConfiguration].
  * In that case, to resolve the dependencies of the source set in a way that is consistent with the published source sets,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradleKpmComponentResultCachingResolver.kt

@@ -17,7 +17,7 @@ open class GradleKpmComponentResultCachingResolver {
     private val cachedResultsByRequestingModule = mutableMapOf<GradleKpmModule, Map<KpmModuleIdentifier, ResolvedComponentResult>>()
 
     protected open fun configurationToResolve(requestingModule: GradleKpmModule): Configuration =
-        configurationToResolveMetadataDependencies(requestingModule.project, requestingModule)
+        configurationToResolveMetadataDependencies(requestingModule)
 
     protected open fun resolveDependencies(module: GradleKpmModule): Map<KpmModuleIdentifier, ResolvedComponentResult> {
         val allComponents = configurationToResolve(module).incoming.resolutionResult.allComponents

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradleKpmDependencyGraphResolver.kt

@@ -5,35 +5,24 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
-import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.result.ResolvedComponentResult
 import org.gradle.api.artifacts.result.ResolvedDependencyResult
-import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
-import org.jetbrains.kotlin.gradle.dsl.pm20ExtensionOrNull
-import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfigurationForSourceSets
 import org.jetbrains.kotlin.project.model.*
 
 internal fun resolvableMetadataConfiguration(
     module: GradleKpmModule
 ) = module.project.configurations.getByName(module.resolvableMetadataConfigurationName)
 
-internal fun configurationToResolveMetadataDependencies(project: Project, requestingModule: KpmModule): Configuration =
-    when {
-        project.pm20ExtensionOrNull != null -> resolvableMetadataConfiguration(requestingModule as GradleKpmModule)
-        else -> resolvableMetadataConfigurationForSourceSets(
-            project,
-            project.kotlinExtension.sourceSets, // take dependencies from all source sets; TODO introduce consistency scopes?
-        )
-    }
-
+internal fun configurationToResolveMetadataDependencies(requestingModule: KpmModule): Configuration =
+    resolvableMetadataConfiguration(requestingModule as GradleKpmModule)
 
 class GradleKpmDependencyGraphResolver(
     private val moduleResolver: KpmModuleDependencyResolver
 ) : KpmDependencyGraphResolver {
 
     private fun configurationToResolve(requestingModule: GradleKpmModule): Configuration =
-        configurationToResolveMetadataDependencies(requestingModule.project, requestingModule)
+        configurationToResolveMetadataDependencies(requestingModule)
 
     override fun resolveDependencyGraph(requestingModule: KpmModule): KpmDependencyGraphResolution {
         if (requestingModule !is GradleKpmModule)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradleKpmFragmentGranularMetadataResolver.kt

@@ -35,7 +35,7 @@ internal class GradleKpmFragmentGranularMetadataResolver(
     private val dependencyGraphResolver = GradleKpmDependencyGraphResolver(moduleResolver)
 
     private fun doResolveMetadataDependencies(): Iterable<MetadataDependencyResolution> {
-        val configurationToResolve = configurationToResolveMetadataDependencies(project, requestingFragment.containingModule)
+        val configurationToResolve = configurationToResolveMetadataDependencies(requestingFragment.containingModule)
         val resolvedComponentsByModuleId =
             configurationToResolve.incoming.resolutionResult.allComponents.associateBy { it.toSingleKpmModuleIdentifier() }
         val resolvedDependenciesByModuleId =

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradleKpmModuleDependencyResolver.kt

@@ -42,7 +42,7 @@ class GradleKpmModuleDependencyResolver(
                     project,
                     component,
                     // TODO: consistent choice of configurations across multiple resolvers?
-                    configurationToResolveMetadataDependencies(requestingModule.project, requestingModule),
+                    configurationToResolveMetadataDependencies(requestingModule),
                     moduleDependency.moduleIdentifier
                 ) ?: return null
                 val result = projectStructureMetadataModuleBuilder.getModule(component, metadata)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/resolvableMetadataConfiguration.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.plugin.mpp
+
+import org.gradle.api.artifacts.Configuration
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.copyAttributes
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.markResolvable
+import org.jetbrains.kotlin.gradle.plugin.sources.*
+import org.jetbrains.kotlin.gradle.targets.metadata.ALL_COMPILE_METADATA_CONFIGURATION_NAME
+import org.jetbrains.kotlin.tooling.core.extrasLazyProperty
+
+/**
+ * Represents a 'resolvable' configuration containing all dependencies in compile scope.
+ * These dependencies are set up to resolve Kotlin Metadata (without transformation) and will resolve
+ * consistently across the whole project.
+ *
+ * Creating this configuration will resolve dependency scope configurations on the given SourceSet.
+ */
+internal val InternalKotlinSourceSet.resolvableMetadataConfiguration: Configuration by extrasLazyProperty(
+    "resolvableMetadataConfiguration"
+) {
+    /* Create new 'platform like compileDependencies configuration */
+    val configuration = project.configurations.maybeCreate(disambiguateName("resolvable$METADATA_CONFIGURATION_NAME_SUFFIX"))
+    configuration.markResolvable()
+
+    ((getVisibleSourceSetsFromAssociateCompilations(this) + this).withDependsOnClosure).forEach { visibleSourceSet ->
+        configuration.dependencies.addAll(
+            project.configurations.getByName(visibleSourceSet.apiConfigurationName).incoming.dependencies
+        )
+
+        configuration.dependencies.addAll(
+            project.configurations.getByName(visibleSourceSet.implementationConfigurationName).incoming.dependencies
+        )
+
+        configuration.dependencies.addAll(
+            project.configurations.getByName(visibleSourceSet.compileOnlyConfigurationName).incoming.dependencies
+        )
+    }
+
+    val allCompileMetadataConfiguration = project.configurations.getByName(ALL_COMPILE_METADATA_CONFIGURATION_NAME)
+
+    /* Ensure consistent dependency resolution result within the whole module */
+    configuration.shouldResolveConsistentlyWith(allCompileMetadataConfiguration)
+    copyAttributes(allCompileMetadataConfiguration.attributes, configuration.attributes)
+
+    configuration
+}