[Gradle] Move deprecated configurations into KotlinCompilationConfigurationsContainer

^KT-54312 Verification Pending
2022-10-14 13:01:15 +02:00
parent b7e2923103
commit 8e8a8f7b8e
7 changed files with 45 additions and 111 deletions
@@ -251,7 +251,6 @@ internal abstract class AbstractKotlinPlugin(
            buildSourceSetProcessor: (KotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
        ) {
            kotlinTarget.compilations.all { compilation ->
-                AbstractKotlinTargetConfigurator.defineConfigurationsForCompilation(compilation)
                buildSourceSetProcessor(compilation).run()
            }
        }
@@ -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 testRuntimeConfiguration = configurations.findByName(testCompilation.deprecatedRuntimeConfigurationName)
+                val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
+                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)
@@ -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,
@@ -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,
@@ -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)
@@ -61,8 +61,6 @@ open class KotlinJsTargetConfigurator :
        val project = target.project

        target.compilations.all { compilation ->
-            defineConfigurationsForCompilation(compilation)
-
            compilation.source(compilation.defaultSourceSet)

            configureResourceProcessing(
@@ -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)
        }