[Gradle] Move deprecated configurations into KotlinCompilationConfigurationsContainer

^KT-54312 Verification Pending

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

@@ -251,7 +251,6 @@ internal abstract class AbstractKotlinPlugin(
             buildSourceSetProcessor: (KotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
         ) {
             kotlinTarget.compilations.all { compilation ->
-                AbstractKotlinTargetConfigurator.defineConfigurationsForCompilation(compilation)
                 buildSourceSetProcessor(compilation).run()
             }
         }

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

@@ -105,8 +105,6 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
         val project = target.project
 
         target.compilations.all { compilation ->
-            defineConfigurationsForCompilation(compilation)
-
             compilation.internal.processResourcesTaskName?.let { processResourcesTaskName ->
                 configureResourceProcessing(
                     compilation, processResourcesTaskName, project.files(Callable { compilation.allKotlinSourceSets.map { it.resources } })
@@ -161,7 +159,7 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
 
         val mainCompilation = target.compilations.maybeCreate(KotlinCompilation.MAIN_COMPILATION_NAME)
 
-        val compileConfiguration = configurations.findByName(mainCompilation.deprecatedCompileConfigurationName)
+        val compileConfiguration = mainCompilation.internal.configurations.deprecatedCompileConfiguration
         val implementationConfiguration = configurations.maybeCreate(mainCompilation.implementationConfigurationName)
 
         val runtimeOnlyConfiguration = when (mainCompilation) {
@@ -178,7 +176,7 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
             attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
             extendsFrom(configurations.maybeCreate(mainCompilation.apiConfigurationName))
             if (mainCompilation is KotlinCompilationToRunnableFiles) {
-                val runtimeConfiguration = configurations.findByName(mainCompilation.deprecatedRuntimeConfigurationName)
+                val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
                 runtimeConfiguration?.let { extendsFrom(it) }
             }
             usesPlatformOf(target)
@@ -192,7 +190,7 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
                 isCanBeResolved = false
                 attributes.attribute(USAGE_ATTRIBUTE, KotlinUsages.producerRuntimeUsage(target))
                 attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
-                val runtimeConfiguration = configurations.findByName(mainCompilation.deprecatedRuntimeConfigurationName)
+                val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
                 extendsFrom(implementationConfiguration)
                 if (runtimeOnlyConfiguration != null)
                     extendsFrom(runtimeOnlyConfiguration)
@@ -203,7 +201,7 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
 
         if (createTestCompilation) {
             val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME)
-            val compileTestsConfiguration = configurations.findByName(testCompilation.deprecatedCompileConfigurationName)
+            val compileTestsConfiguration = testCompilation.internal.configurations.deprecatedCompileConfiguration
             val testImplementationConfiguration = configurations.maybeCreate(testCompilation.implementationConfigurationName)
             val testRuntimeOnlyConfiguration = when (testCompilation) {
                 is KotlinCompilationToRunnableFiles<*> -> configurations.maybeCreate(testCompilation.runtimeOnlyConfigurationName)
@@ -215,8 +213,8 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
             testRuntimeOnlyConfiguration?.extendsFrom(runtimeOnlyConfiguration)
 
             if (mainCompilation is KotlinCompilationToRunnableFiles && testCompilation is KotlinCompilationToRunnableFiles) {
-                val runtimeConfiguration = configurations.findByName(mainCompilation.deprecatedRuntimeConfigurationName)
+                val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
-                val testRuntimeConfiguration = configurations.findByName(testCompilation.deprecatedRuntimeConfigurationName)
+                val testRuntimeConfiguration = testCompilation.internal.configurations.deprecatedRuntimeConfiguration
                 runtimeConfiguration?.let { testRuntimeConfiguration?.extendsFrom(it) }
             }
         }
@@ -265,104 +263,9 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
     companion object {
         const val testTaskNameSuffix = "test"
         const val runTaskNameSuffix = "run"
-
-        fun defineConfigurationsForCompilation(
-            compilation: KotlinCompilation<*>
-        ) {
-            val project = compilation.target.project
-            val target = compilation.target
-            val configurations = target.project.configurations
-
-            val compileConfiguration = configurations.findByName(compilation.deprecatedCompileConfigurationName)?.apply {
-                isCanBeConsumed = false
-                setupAsLocalTargetSpecificConfigurationIfSupported(target)
-                isVisible = false
-                isCanBeResolved = false
-                description = "Dependencies for $compilation (deprecated, use '${compilation.implementationConfigurationName} ' instead)."
-            }
-
-            val apiConfiguration = configurations.maybeCreate(compilation.apiConfigurationName).apply {
-                compileConfiguration?.let { extendsFrom(it) }
-
-                // TODP NOW: Remove duplicate
-                isVisible = false
-                isCanBeConsumed = false
-                isCanBeResolved = false
-                description = "API dependencies for $compilation."
-            }
-
-            val implementationConfiguration = configurations.maybeCreate(compilation.implementationConfigurationName).apply {
-                extendsFrom(apiConfiguration)
-                compileConfiguration?.let { extendsFrom(it) }
-                isVisible = false
-                isCanBeConsumed = false
-                isCanBeResolved = false
-                description = "Implementation only dependencies for $compilation."
-            }
-
-            val compileOnlyConfiguration = configurations.maybeCreate(compilation.compileOnlyConfigurationName).apply {
-                isCanBeConsumed = false
-                setupAsLocalTargetSpecificConfigurationIfSupported(target)
-                attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
-                isVisible = false
-                isCanBeResolved = false
-                description = "Compile only dependencies for $compilation."
-            }
-
-            configurations.maybeCreate(compilation.compileDependencyConfigurationName).apply {
-                extendsFrom(compileOnlyConfiguration, implementationConfiguration)
-                usesPlatformOf(target)
-                isVisible = false
-                isCanBeConsumed = false
-                attributes.attribute(USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(compilation.target))
-                if (compilation.platformType != KotlinPlatformType.androidJvm) {
-                    attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
-                }
-                description = "Compile classpath for $compilation."
-            }
-
-            if (compilation is KotlinCompilationToRunnableFiles) {
-                val runtimeConfiguration = configurations.findByName(compilation.deprecatedRuntimeConfigurationName)?.apply {
-                    isCanBeConsumed = false
-                    setupAsLocalTargetSpecificConfigurationIfSupported(target)
-                    compileConfiguration?.let { extendsFrom(it) }
-                    isVisible = false
-                    isCanBeResolved = false
-                    description =
-                        "Runtime dependencies for $compilation (deprecated, use '${compilation.runtimeOnlyConfigurationName} ' instead)."
-                }
-
-                val runtimeOnlyConfiguration = configurations.maybeCreate(compilation.runtimeOnlyConfigurationName).apply {
-                    isVisible = false
-                    isCanBeConsumed = false
-                    isCanBeResolved = false
-                    description = "Runtime only dependencies for $compilation."
-                }
-
-                configurations.maybeCreate(compilation.runtimeDependencyConfigurationName).apply {
-                    extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
-                    runtimeConfiguration?.let { extendsFrom(it) }
-                    usesPlatformOf(target)
-                    isVisible = false
-                    isCanBeConsumed = false
-                    isCanBeResolved = true
-                    attributes.attribute(USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(compilation.target))
-                    if (compilation.platformType != KotlinPlatformType.androidJvm) {
-                        attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
-                    }
-                    description = "Runtime classpath of $compilation."
-                }
-            }
-        }
     }
 }
 
-internal val KotlinCompilation<*>.deprecatedCompileConfigurationName: String
-    get() = disambiguateName(COMPILE)
-
-internal val KotlinCompilationToRunnableFiles<*>.deprecatedRuntimeConfigurationName: String
-    get() = disambiguateName(RUNTIME)
-
 internal val KotlinTarget.testTaskName: String
     get() = lowerCamelCaseName(targetName, AbstractKotlinTargetConfigurator.testTaskNameSuffix)
 
@@ -421,7 +324,7 @@ abstract class KotlinOnlyTargetConfigurator<KotlinCompilationType : KotlinCompil
                 addJarIfNoArtifactsPresent(apiElementsConfiguration, jarArtifact)
 
                 if (mainCompilation is KotlinCompilationToRunnableFiles<*>) {
-                    val runtimeConfiguration = project.configurations.findByName(mainCompilation.deprecatedRuntimeConfigurationName)
+                    val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
                     val runtimeElementsConfiguration = project.configurations.getByName(target.runtimeElementsConfigurationName)
                     runtimeConfiguration?.let { addJarIfNoArtifactsPresent(runtimeConfiguration, jarArtifact) }
                     addJarIfNoArtifactsPresent(runtimeElementsConfiguration, jarArtifact)

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

@@ -13,6 +13,8 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.mpp.DefaultKotlinDependencyHandler
 
 internal interface KotlinCompilationConfigurationsContainer {
+    val deprecatedCompileConfiguration: Configuration?
+    val deprecatedRuntimeConfiguration: Configuration?
     val apiConfiguration: Configuration
     val implementationConfiguration: Configuration
     val compileOnlyConfiguration: Configuration
@@ -23,6 +25,8 @@ internal interface KotlinCompilationConfigurationsContainer {
 }
 
 internal class DefaultKotlinCompilationConfigurationsContainer(
+    override val deprecatedCompileConfiguration: Configuration?,
+    override val deprecatedRuntimeConfiguration: Configuration?,
     override val apiConfiguration: Configuration,
     override val implementationConfiguration: Configuration,
     override val compileOnlyConfiguration: Configuration,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/factory/DefaultKotlinCompilationDependencyConfigurationsFactory.kt

@@ -129,7 +129,34 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
 ): KotlinCompilationConfigurationsContainer {
     val compilationCoordinates = "${target.disambiguationClassifier}/$compilationName"
 
+    /* Support deprecated configurations */
+    val deprecatedCompileConfiguration = target.project.configurations.findByName(
+        ConfigurationNaming.Default(target, compilationName).name(COMPILE)
+    )?.apply {
+        isCanBeConsumed = false
+        setupAsLocalTargetSpecificConfigurationIfSupported(target)
+        isVisible = false
+        isCanBeResolved = false
+        description = "Dependencies for $compilation (deprecated, use '${implementationConfigurationName} ' instead)."
+    }
+
+    val deprecatedRuntimeConfiguration = if (withRuntime) target.project.configurations.findByName(
+        ConfigurationNaming.Default(target, compilationName).name(RUNTIME)
+    )?.apply {
+        isCanBeConsumed = false
+        setupAsLocalTargetSpecificConfigurationIfSupported(target)
+        deprecatedCompileConfiguration?.let { extendsFrom(it) }
+        isVisible = false
+        isCanBeResolved = false
+        description =
+            "Runtime dependencies for $compilation (deprecated, use '${runtimeOnlyConfigurationName} ' instead)."
+    } else null
+
+    /* Actual configurations */
+
     val apiConfiguration = target.project.configurations.maybeCreate(apiConfigurationName).apply {
+        deprecatedCompileConfiguration?.let { extendsFrom(it) }
+
         isVisible = false
         isCanBeConsumed = false
         isCanBeResolved = false
@@ -138,6 +165,7 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
 
     val implementationConfiguration = target.project.configurations.maybeCreate(implementationConfigurationName).apply {
         extendsFrom(apiConfiguration)
+        deprecatedCompileConfiguration?.let { extendsFrom(it) }
         isVisible = false
         isCanBeConsumed = false
         isCanBeResolved = false
@@ -175,6 +203,7 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
     val runtimeDependencyConfiguration =
         if (withRuntime) target.project.configurations.maybeCreate(runtimeClasspathConfigurationName).apply {
             extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
+            deprecatedRuntimeConfiguration?.let { extendsFrom(it) }
             usesPlatformOf(target)
             isVisible = false
             isCanBeConsumed = false
@@ -202,6 +231,8 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
     }
 
     return DefaultKotlinCompilationConfigurationsContainer(
+        deprecatedCompileConfiguration = deprecatedCompileConfiguration,
+        deprecatedRuntimeConfiguration = deprecatedRuntimeConfiguration,
         apiConfiguration = apiConfiguration,
         implementationConfiguration = implementationConfiguration,
         compileOnlyConfiguration = compileOnlyConfiguration,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/AndroidProjectHandler.kt

@@ -341,8 +341,6 @@ internal class AndroidProjectHandler(
     fun setUpDependencyResolution(variant: BaseVariant, compilation: KotlinJvmAndroidCompilation) {
         val project = compilation.target.project
 
-        AbstractKotlinTargetConfigurator.defineConfigurationsForCompilation(compilation)
-
         compilation.compileDependencyFiles = variant.compileConfiguration.apply {
             usesPlatformOf(compilation.target)
             project.addExtendsFromRelation(name, compilation.compileDependencyConfigurationName)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/KotlinJsTargetConfigurator.kt

@@ -61,8 +61,6 @@ open class KotlinJsTargetConfigurator :
         val project = target.project
 
         target.compilations.all { compilation ->
-            defineConfigurationsForCompilation(compilation)
-
             compilation.source(compilation.defaultSourceSet)
 
             configureResourceProcessing(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmTarget.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.copyAttributes
 import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
@@ -160,7 +161,7 @@ abstract class KotlinJvmTarget @Inject constructor(
             compilation.apiConfigurationName,
             compilation.implementationConfigurationName,
             compilation.compileOnlyConfigurationName,
-            compilation.deprecatedCompileConfigurationName.takeIf { project.configurations.findByName(it) != null }
+            compilation.internal.configurations.deprecatedCompileConfiguration?.name,
         ).forEach { configurationName ->
             project.addExtendsFromRelation(javaSourceSet.compileClasspathConfigurationName, configurationName)
         }
@@ -169,7 +170,7 @@ abstract class KotlinJvmTarget @Inject constructor(
             compilation.apiConfigurationName,
             compilation.implementationConfigurationName,
             compilation.runtimeOnlyConfigurationName,
-            compilation.deprecatedRuntimeConfigurationName.takeIf { project.configurations.findByName(it) != null }
+            compilation.internal.configurations.deprecatedRuntimeConfiguration?.name,
         ).forEach { configurationName ->
             project.addExtendsFromRelation(javaSourceSet.runtimeClasspathConfigurationName, configurationName)
         }