[KPM] Implement *ConfigurationDefinition and Kotlin*VariantConfig APIs

Those new APIs shall make it easier for external Variant authors
(Android) to reuse logic from KGP with more clear semantic.

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kpmTransientPluginOptions/build.gradle.kts

@@ -51,4 +51,4 @@ class GradleKpmPluginWithTransientPluginOptions : GradleKpmCompilerPlugin {
             transientOptionValue = project.property("test-plugin.transient") as String
         )
     }
-}
+}

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinJvmVariantFactoryTest.kt

@@ -86,11 +86,12 @@ class KotlinJvmVariantFactoryTest : AbstractKpmExtensionTest() {
     @Test
     fun `test custom configure compileDependenciesConfiguration`() {
         val variant = KotlinJvmVariantFactory(
-            KotlinJvmVariantInstantiator(kotlin.main),
+            kotlin.main, KotlinJvmVariantConfig(
-            KotlinJvmVariantConfigurator(compileDependenciesConfigurator = { fragment, configuration ->
+                compileDependencies = DefaultKotlinCompileDependenciesDefinition + FragmentAttributes { fragment ->
-                assertSame(fragment.compileDependenciesConfiguration, configuration)
+                    assertSame(fragment.compileDependenciesConfiguration.attributes, this)
-                configuration.attributes.attribute(testAttribute, "compileDependencies")
+                    attribute(testAttribute, "compileDependencies")
-            })
+                }
+            )
         ).create("jvm")
 
         assertEquals(
@@ -101,11 +102,12 @@ class KotlinJvmVariantFactoryTest : AbstractKpmExtensionTest() {
     @Test
     fun `test custom configure runtimeDependenciesConfiguration`() {
         val variant = KotlinJvmVariantFactory(
-            KotlinJvmVariantInstantiator(kotlin.main),
+            kotlin.main, KotlinJvmVariantConfig(
-            KotlinJvmVariantConfigurator(runtimeDependenciesConfigurator = { fragment, configuration ->
+                runtimeDependencies = DefaultKotlinRuntimeDependenciesDefinition + FragmentAttributes { fragment ->
-                assertSame(fragment.runtimeDependenciesConfiguration, configuration)
+                    assertSame(fragment.runtimeDependenciesConfiguration.attributes, this)
-                configuration.attributes.attribute(testAttribute, "runtimeDependencies")
+                    attribute(testAttribute, "runtimeDependencies")
-            })
+                }
+            )
         ).create("jvm")
 
         assertEquals(
@@ -116,10 +118,12 @@ class KotlinJvmVariantFactoryTest : AbstractKpmExtensionTest() {
     @Test
     fun `test custom configure apiElementsConfiguration`() {
         val variant = KotlinJvmVariantFactory(
-            KotlinJvmVariantInstantiator(kotlin.main), KotlinJvmVariantConfigurator(apiElementsConfigurator = { fragment, configuration ->
+            kotlin.main, KotlinJvmVariantConfig(
-                assertSame(fragment.apiElementsConfiguration, configuration)
+                apiElements = DefaultKotlinApiElementsDefinition + FragmentAttributes { fragment ->
-                configuration.attributes.attribute(testAttribute, "apiElements")
+                    assertSame(fragment.apiElementsConfiguration.attributes, this)
-            })
+                    attribute(testAttribute, "apiElements")
+                }
+            )
         ).create("jvm")
 
         assertEquals(
@@ -130,11 +134,12 @@ class KotlinJvmVariantFactoryTest : AbstractKpmExtensionTest() {
     @Test
     fun `test custom configure runtimeElementsConfiguration`() {
         val variant = KotlinJvmVariantFactory(
-            KotlinJvmVariantInstantiator(kotlin.main),
+            kotlin.main, KotlinJvmVariantConfig(
-            KotlinJvmVariantConfigurator(runtimeElementsConfigurator = { fragment, configuration ->
+                runtimeElements = DefaultKotlinRuntimeElementsDefinition + FragmentAttributes { fragment ->
-                assertSame(fragment.runtimeElementsConfiguration, configuration)
+                    assertSame(fragment.runtimeElementsConfiguration.attributes, this)
-                configuration.attributes.attribute(testAttribute, "runtimeElements")
+                    attribute(testAttribute, "runtimeElements")
-            })
+                }
+            )
         ).create("jvm")
 
         assertEquals(
@@ -145,12 +150,13 @@ class KotlinJvmVariantFactoryTest : AbstractKpmExtensionTest() {
     @Test
     fun `test custom sourceDirectories configuration`() {
         val variant = KotlinJvmVariantFactory(
-            KotlinJvmVariantInstantiator(kotlin.main),
+            kotlin.main, KotlinJvmVariantConfig(
-            KotlinJvmVariantConfigurator(sourceDirectoriesConfigurator = object : KotlinSourceDirectoriesConfigurator<KotlinJvmVariant> {
+                sourceDirectoriesConfigurator = object : KotlinSourceDirectoriesConfigurator<KotlinJvmVariant> {
-                override fun configure(fragment: KotlinJvmVariant) {
+                    override fun configure(fragment: KotlinJvmVariant) {
-                    fragment.kotlinSourceRoots.setSrcDirs(listOf(project.file("src/abc/kotlin")))
+                        fragment.kotlinSourceRoots.setSrcDirs(listOf(project.file("src/abc/kotlin")))
+                    }
                 }
-            })
+            )
         ).create("jvm")
 
         assertEquals(listOf(project.file("src/abc/kotlin")), variant.kotlinSourceRoots.srcDirs.toList())

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinNativeVariantFactoryTest.kt

@@ -29,9 +29,7 @@ class KotlinNativeVariantFactoryTest(
 
     @BeforeTest
     fun createVariant() {
-        variant = KotlinNativeVariantFactory(
+        variant = KotlinNativeVariantFactory(kotlin.main, variantConstructor).create("native")
-            KotlinNativeVariantInstantiator(kotlin.main, variantConstructor)
-        ).create("native")
     }
 
     @Test

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/DefaultKotlinFragmentAttributes.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2021 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.
+ */
+
+@file:Suppress("FunctionName")
+
+package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
+
+import org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
+import org.gradle.api.attributes.java.TargetJvmEnvironment
+import org.gradle.kotlin.dsl.named
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.consumerApiUsage
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.consumerRuntimeUsage
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.producerApiUsage
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.producerRuntimeUsage
+import org.jetbrains.kotlin.gradle.plugin.usageByName
+
+val KotlinFragmentPlatformAttributes = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    // TODO NOW! Maybe we want to provide API for Android target to hook into this?
+    if (fragment.platformType == KotlinPlatformType.jvm) {
+        attribute(
+            TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE,
+            fragment.project.objects.named(TargetJvmEnvironment.STANDARD_JVM)
+        )
+    }
+    attribute(KotlinPlatformType.attribute, fragment.platformType)
+}
+
+val KotlinFragmentConsumerApiUsageAttribute = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    attribute(USAGE_ATTRIBUTE, consumerApiUsage(fragment.project, fragment.platformType))
+}
+
+val KotlinFragmentProducerApiUsageAttribute = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    attribute(USAGE_ATTRIBUTE, producerApiUsage(fragment.project, fragment.platformType))
+}
+
+val KotlinFragmentConsumerRuntimeUsageAttribute = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    attribute(USAGE_ATTRIBUTE, consumerRuntimeUsage(fragment.project, fragment.platformType))
+}
+
+val KotlinFragmentProducerRuntimeUsageAttribute = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    attribute(USAGE_ATTRIBUTE, producerRuntimeUsage(fragment.project, fragment.platformType))
+}
+
+val KotlinFragmentMetadataUsageAttribute = FragmentAttributes<KotlinGradleVariant> { fragment ->
+    attribute(USAGE_ATTRIBUTE, fragment.project.usageByName(KotlinUsages.KOTLIN_METADATA))
+}
+
+val KotlinFragmentKonanTargetAttribute = FragmentAttributes<KotlinNativeVariantInternal> { fragment ->
+    attribute(KotlinNativeTarget.konanTargetAttribute, fragment.konanTarget.name)
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/DefaultKotlinFragmentConfigurations.kt

@@ -0,0 +1,85 @@
+/*
+ * 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.pm20
+
+import org.gradle.api.attributes.Bundling
+import org.gradle.api.attributes.Category
+
+
+val DefaultKotlinCompileDependenciesDefinition = KotlinGradleFragmentConfigurationDefinition(
+    provider = {
+        project.configurations.maybeCreate(disambiguateName("compileDependencies")).apply {
+            isCanBeConsumed = false
+            isCanBeResolved = true
+        }
+    },
+    relations = { configuration ->
+        configuration.extendsFrom(dependencies.transitiveApiConfiguration)
+        configuration.extendsFrom(dependencies.transitiveImplementationConfiguration)
+    },
+    attributes = KotlinFragmentPlatformAttributes + KotlinFragmentConsumerApiUsageAttribute
+)
+
+val DefaultKotlinRuntimeDependenciesDefinition = ConfigurationDefinition(
+    provider = {
+        project.configurations.maybeCreate(disambiguateName("runtimeDependencies")).apply {
+            isCanBeConsumed = false
+            isCanBeResolved = true
+        }
+    },
+    attributes = KotlinFragmentPlatformAttributes + KotlinFragmentConsumerRuntimeUsageAttribute,
+    relations = { configuration ->
+        configuration.extendsFrom(dependencies.transitiveApiConfiguration)
+        configuration.extendsFrom(dependencies.transitiveImplementationConfiguration)
+    }
+)
+
+val DefaultKotlinApiElementsDefinition = ConfigurationDefinition(
+    provider = {
+        module.project.configurations.maybeCreate(disambiguateName("apiElements")).apply {
+            isCanBeResolved = false
+            isCanBeConsumed = false
+            module.ifMadePublic { isCanBeConsumed = true }
+        }
+    },
+    relations = { configuration -> configuration.extendsFrom(dependencies.transitiveApiConfiguration) },
+    capabilities = KotlinFragmentModuleCapability,
+    attributes = KotlinFragmentPlatformAttributes + KotlinFragmentProducerApiUsageAttribute + { fragment ->
+        attribute(Category.CATEGORY_ATTRIBUTE, fragment.project.objects.named(Category::class.java, Category.LIBRARY))
+        attribute(Bundling.BUNDLING_ATTRIBUTE, fragment.project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
+    },
+)
+
+val DefaultKotlinRuntimeElementsDefinition = ConfigurationDefinition(
+    provider = {
+        module.project.configurations.maybeCreate(disambiguateName("runtimeElements")).apply {
+            isCanBeResolved = false
+            isCanBeConsumed = false
+            module.ifMadePublic { isCanBeConsumed = true }
+        }
+    },
+    relations = { configuration ->
+        configuration.extendsFrom(dependencies.transitiveApiConfiguration)
+        configuration.extendsFrom(dependencies.transitiveImplementationConfiguration)
+    },
+    attributes = KotlinFragmentPlatformAttributes + KotlinFragmentProducerRuntimeUsageAttribute + { fragment ->
+        attributes.attribute(Category.CATEGORY_ATTRIBUTE, fragment.project.objects.named(Category::class.java, Category.LIBRARY))
+        attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, fragment.project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
+    },
+    capabilities = KotlinFragmentModuleCapability.onlyIfMadePublic()
+)
+
+val DefaultKotlinHostSpecificMetadataElementsDefinition = ConfigurationDefinition(
+    provider = {
+        project.configurations.maybeCreate(disambiguateName("hostSpecificMetadataElements")).apply {
+            isCanBeResolved = false
+            isCanBeConsumed = false
+        }
+    },
+    attributes = KotlinFragmentPlatformAttributes + KotlinFragmentKonanTargetAttribute + KotlinFragmentMetadataUsageAttribute,
+    artifacts = KotlinFragmentHostSpecificMetadataArtifact
+)
+

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradlePlugin.kt

@@ -47,7 +47,7 @@ abstract class KotlinPm20GradlePlugin @Inject constructor(
             fun <T : KotlinNativeVariantInternal> registerNativeVariantFactory(
                 constructor: KotlinNativeVariantConstructor<T>
             ) = module.fragments.registerFactory(
-                constructor.variantClass, KotlinNativeVariantFactory(KotlinNativeVariantInstantiator(module, constructor))
+                constructor.variantClass, KotlinNativeVariantFactory(module, constructor)
             )
 
             listOf(

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentCompilationOutputsJarArtifact.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
-import org.gradle.api.artifacts.Configuration
 import org.gradle.jvm.tasks.Jar
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
@@ -14,12 +13,9 @@ import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
 /**
  * Registers a [Jar] task with the variant's compilation outputs and attaches this artifact to the given configuration.
  */
-object KotlinCompilationOutputsJarArtifactConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
+val KotlinFragmentCompilationOutputsJarArtifact = FragmentArtifacts<KotlinGradleVariant> { fragment ->
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
+    artifact(fragment.project.locateOrRegisterTask<Jar>(fragment.disambiguateName("jar")) {
-        val jarTask = fragment.project.locateOrRegisterTask<Jar>(fragment.disambiguateName("jar")) {
+        it.from(fragment.compilationOutputs.allOutputs)
-            it.from(fragment.compilationOutputs.allOutputs)
+        it.archiveClassifier.set(dashSeparatedName(fragment.name, fragment.containingModule.moduleClassifier))
-            it.archiveClassifier.set(dashSeparatedName(fragment.name, fragment.containingModule.moduleClassifier))
+    })
-        }
-        fragment.project.artifacts.add(configuration.name, jarTask)
-    }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentConfigurationDefinition.kt

@@ -0,0 +1,222 @@
+/*
+ * 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.pm20
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ConfigurationPublications
+import org.gradle.api.attributes.AttributeContainer
+import org.gradle.api.capabilities.Capability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
+
+/* Internal abbreviation */
+internal typealias ConfigurationDefinition<T> = KotlinGradleFragmentConfigurationDefinition<T>
+
+data class KotlinGradleFragmentConfigurationDefinition<in T : KotlinGradleFragment>(
+    val provider: KotlinGradleFragmentConfigurationProvider,
+    val attributes: KotlinGradleFragmentConfigurationAttributes<T> = KotlinGradleFragmentConfigurationAttributes.None,
+    val capabilities: KotlinGradleFragmentConfigurationCapabilities<T> = KotlinGradleFragmentConfigurationCapabilities.None,
+    val artifacts: KotlinGradleFragmentConfigurationArtifacts<T> = KotlinGradleFragmentConfigurationArtifacts.None,
+    val relations: KotlinGradleFragmentConfigurationRelation = KotlinGradleFragmentConfigurationRelation.None,
+)
+
+/* Internal abbreviation */
+internal typealias ConfigurationContext = KotlinGradleFragmentConfigurationContext
+
+interface KotlinGradleFragmentConfigurationContext : KotlinNameDisambiguation {
+    val project: Project get() = module.project
+    val module: KotlinGradleModule
+    val dependencies: KotlinFragmentDependencyConfigurations
+}
+
+internal class ConfigurationContextImpl(
+    override val module: KotlinGradleModule,
+    override val dependencies: KotlinFragmentDependencyConfigurations,
+    names: KotlinNameDisambiguation
+) : KotlinGradleFragmentConfigurationContext, KotlinNameDisambiguation by names
+
+/* Internal abbreviation */
+internal typealias FragmentConfigurationProvider = KotlinGradleFragmentConfigurationProvider
+
+fun interface KotlinGradleFragmentConfigurationProvider {
+    fun KotlinGradleFragmentConfigurationContext.getConfiguration(): Configuration
+}
+
+/* Internal abbreviation */
+internal typealias FragmentRelation = KotlinGradleFragmentConfigurationRelation
+
+fun interface KotlinGradleFragmentConfigurationRelation {
+    fun KotlinGradleFragmentConfigurationContext.setupExtendsFromRelations(configuration: Configuration)
+
+    object None : KotlinGradleFragmentConfigurationRelation {
+        override fun KotlinGradleFragmentConfigurationContext.setupExtendsFromRelations(configuration: Configuration) = Unit
+    }
+}
+
+/* Internal abbreviation */
+internal typealias FragmentAttributes<T> = KotlinGradleFragmentConfigurationAttributes<T>
+
+fun interface KotlinGradleFragmentConfigurationAttributes<in T : KotlinGradleFragment> {
+    fun AttributeContainer.setAttributes(fragment: T)
+
+    object None : KotlinGradleFragmentConfigurationAttributes<KotlinGradleFragment> {
+        override fun AttributeContainer.setAttributes(fragment: KotlinGradleFragment) = Unit
+    }
+}
+/* Internal abbreviation */
+internal typealias FragmentCapabilities<T> = KotlinGradleFragmentConfigurationCapabilities<T>
+
+fun interface KotlinGradleFragmentConfigurationCapabilities<in T : KotlinGradleFragment> {
+    interface Context {
+        fun capability(notation: Any)
+        val capabilities: List<Capability>
+    }
+
+    class ContextImpl internal constructor(
+        private val configuration: Configuration
+    ) : Context {
+        override fun capability(notation: Any) = configuration.outgoing.capability(notation)
+        override val capabilities: List<Capability> get() = configuration.outgoing.capabilities.orEmpty().toList()
+    }
+
+    fun Context.setCapabilities(fragment: T)
+
+    object None : KotlinGradleFragmentConfigurationCapabilities<KotlinGradleFragment> {
+        override fun Context.setCapabilities(fragment: KotlinGradleFragment) = Unit
+    }
+}
+
+/* Internal abbreviation */
+internal typealias FragmentArtifacts<T> = KotlinGradleFragmentConfigurationArtifacts<T>
+
+fun interface KotlinGradleFragmentConfigurationArtifacts<in T : KotlinGradleFragment> {
+    fun ConfigurationPublications.addArtifacts(fragment: T)
+
+    object None : KotlinGradleFragmentConfigurationArtifacts<KotlinGradleFragment> {
+        override fun ConfigurationPublications.addArtifacts(fragment: KotlinGradleFragment) = Unit
+    }
+}
+
+/*
+Definition Extensions
+ */
+
+operator fun <T : KotlinGradleFragment> KotlinGradleFragmentConfigurationDefinition<T>.plus(other: FragmentAttributes<T>):
+        KotlinGradleFragmentConfigurationDefinition<T> = copy(attributes = attributes + other)
+
+operator fun <T : KotlinGradleFragment> KotlinGradleFragmentConfigurationDefinition<T>.plus(other: FragmentArtifacts<T>):
+        KotlinGradleFragmentConfigurationDefinition<T> = copy(artifacts = artifacts + other)
+
+/*
+Provider Extensions
+ */
+
+fun <T : KotlinGradleFragment> KotlinGradleFragmentConfigurationDefinition<T>.withConfigurationProvider(
+    provider: KotlinGradleFragmentConfigurationContext.() -> Configuration
+) = copy(provider = provider)
+
+fun KotlinGradleFragmentConfigurationProvider.getConfiguration(context: KotlinGradleFragmentConfigurationContext): Configuration {
+    return with(context) { getConfiguration() }
+}
+
+/*
+FragmentArtifacts Extensions
+ */
+
+fun <T : KotlinGradleFragment> ConfigurationPublications.addArtifacts(artifacts: FragmentArtifacts<T>, fragment: T) = with(artifacts) {
+    addArtifacts(fragment)
+}
+
+operator fun <T : KotlinGradleFragment> FragmentArtifacts<T>.plus(other: FragmentArtifacts<T>): FragmentArtifacts<T> {
+    if (this is CompositeFragmentArtifacts && other is CompositeFragmentArtifacts) {
+        return CompositeFragmentArtifacts(this.children + other.children)
+    }
+
+    if (this is CompositeFragmentArtifacts) {
+        return CompositeFragmentArtifacts(this.children + other)
+    }
+
+    if (other is CompositeFragmentArtifacts) {
+        return CompositeFragmentArtifacts(listOf(this) + other.children)
+    }
+
+    return CompositeFragmentArtifacts(listOf(this, other))
+}
+
+internal class CompositeFragmentArtifacts<in T : KotlinGradleFragment>(val children: List<FragmentArtifacts<T>>) :
+    FragmentArtifacts<T> {
+    override fun ConfigurationPublications.addArtifacts(fragment: T) {
+        children.forEach { child -> addArtifacts(child, fragment) }
+    }
+}
+
+/*
+FragmentAttributes Extensions
+ */
+
+fun <T : KotlinGradleFragment> AttributeContainer.attribute(attributes: FragmentAttributes<T>, fragment: T) = with(attributes) {
+    setAttributes(fragment)
+}
+
+operator fun <T : KotlinGradleFragment> FragmentAttributes<T>.plus(other: FragmentAttributes<T>): FragmentAttributes<T> {
+    if (this is CompositeFragmentAttributes && other is CompositeFragmentAttributes) {
+        return CompositeFragmentAttributes(this.children + other.children)
+    }
+
+    if (this is CompositeFragmentAttributes) {
+        return CompositeFragmentAttributes(this.children + other)
+    }
+
+    if (other is CompositeFragmentAttributes) {
+        return CompositeFragmentAttributes(listOf(this) + other.children)
+    }
+
+    return CompositeFragmentAttributes(listOf(this, other))
+}
+
+internal class CompositeFragmentAttributes<in T : KotlinGradleFragment>(val children: List<FragmentAttributes<T>>) :
+    FragmentAttributes<T> {
+    override fun AttributeContainer.setAttributes(fragment: T) {
+        children.forEach { attribute -> attribute(attribute, fragment) }
+    }
+}
+
+/*
+FragmentCapabilities Extensions
+ */
+
+fun <T : KotlinGradleFragment> KotlinGradleFragmentConfigurationCapabilities<T>.onlyIfMadePublic(): KotlinGradleFragmentConfigurationCapabilities<T> {
+    return KotlinGradleFragmentConfigurationCapabilities { fragment ->
+        fragment.containingModule.ifMadePublic { setCapabilities(this@onlyIfMadePublic, fragment) }
+    }
+}
+
+fun <T : KotlinGradleFragment> KotlinGradleFragmentConfigurationCapabilities.Context.setCapabilities(
+    capabilities: KotlinGradleFragmentConfigurationCapabilities<T>, fragment: T
+) = with(capabilities) { setCapabilities(fragment) }
+
+operator fun <T : KotlinGradleFragment> FragmentCapabilities<T>.plus(other: FragmentCapabilities<T>): FragmentCapabilities<T> {
+    if (this is CompositeFragmentCapabilities && other is CompositeFragmentCapabilities) {
+        return CompositeFragmentCapabilities(this.children + other.children)
+    }
+
+    if (this is CompositeFragmentCapabilities) {
+        return CompositeFragmentCapabilities(this.children + other)
+    }
+
+    if (other is CompositeFragmentCapabilities) {
+        return CompositeFragmentCapabilities(listOf(this) + other.children)
+    }
+
+    return CompositeFragmentCapabilities(listOf(this, other))
+}
+
+internal class CompositeFragmentCapabilities<in T : KotlinGradleFragment>(val children: List<FragmentCapabilities<T>>) :
+    FragmentCapabilities<T> {
+    override fun KotlinGradleFragmentConfigurationCapabilities.Context.setCapabilities(fragment: T) {
+        children.forEach { capability -> setCapabilities(capability, fragment) }
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentConfigurationInstantiator.kt

@@ -1,17 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20
-
-import org.gradle.api.artifacts.Configuration
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-
-interface KotlinFragmentConfigurationInstantiator {
-    fun create(
-        module: KotlinGradleModule,
-        names: KotlinNameDisambiguation,
-        dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration
-}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentConfigurationsConfigurator.kt

@@ -1,119 +0,0 @@
-/*
- * Copyright 2010-2021 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.
- */
-
-@file:Suppress("FunctionName")
-
-package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
-
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
-import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.consumerApiUsage
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.consumerRuntimeUsage
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.producerApiUsage
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages.producerRuntimeUsage
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
-import org.jetbrains.kotlin.gradle.plugin.usageByName
-
-/**
- * Special 'Configurator' for Gradle configurations.
- * Such 'Configurator' depend on the concrete [KotlinGradleFragment] instance in order to run
- * This 'Configurator's can be composed using the [KotlinConfigurationsConfigurator] or [plus] function.
- */
-fun interface KotlinFragmentConfigurationsConfigurator<in T : KotlinGradleFragment> {
-    fun configure(fragment: T, configuration: Configuration)
-}
-
-fun <T : KotlinGradleFragment> KotlinConfigurationsConfigurator(
-    vararg configurators: KotlinFragmentConfigurationsConfigurator<T>
-): KotlinFragmentConfigurationsConfigurator<T> {
-    return CompositeKotlinFragmentConfigurationsConfigurator(configurators.toList())
-}
-
-//region Simple default implementations
-
-object KotlinFragmentPlatformAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(KotlinPlatformType.attribute, fragment.platformType)
-    }
-}
-
-object KotlinFragmentConsumerApiUsageAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(USAGE_ATTRIBUTE, consumerApiUsage(fragment.project, fragment.platformType))
-    }
-}
-
-object KotlinFragmentProducerApiUsageAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(USAGE_ATTRIBUTE, producerApiUsage(fragment.project, fragment.platformType))
-    }
-}
-
-object KotlinFragmentConsumerRuntimeUsageAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(USAGE_ATTRIBUTE, consumerRuntimeUsage(fragment.project, fragment.platformType))
-    }
-}
-
-object KotlinFragmentProducerRuntimeUsageAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(USAGE_ATTRIBUTE, producerRuntimeUsage(fragment.project, fragment.platformType))
-    }
-}
-
-object KotlinFragmentMetadataUsageAttributeConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        configuration.attributes.attribute(USAGE_ATTRIBUTE, fragment.project.usageByName(KotlinUsages.KOTLIN_METADATA))
-    }
-}
-
-object KonanTargetAttributesConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinNativeVariantInternal> {
-    override fun configure(fragment: KotlinNativeVariantInternal, configuration: Configuration) {
-        configuration.attributes.attribute(KotlinNativeTarget.konanTargetAttribute, fragment.konanTarget.name)
-    }
-}
-
-object KotlinFragmentModuleCapabilityConfigurator : KotlinFragmentConfigurationsConfigurator<KotlinGradleVariant> {
-    override fun configure(fragment: KotlinGradleVariant, configuration: Configuration) {
-        setModuleCapability(configuration, fragment.containingModule)
-    }
-
-    internal fun setModuleCapability(configuration: Configuration, module: KotlinGradleModule) {
-        if (module.moduleClassifier != null) {
-            configuration.outgoing.capability(ComputedCapability.fromModule(module))
-        }
-    }
-}
-
-//endregion
-
-operator fun <T : KotlinGradleFragment> KotlinFragmentConfigurationsConfigurator<T>.plus(
-    other: KotlinFragmentConfigurationsConfigurator<T>
-): KotlinFragmentConfigurationsConfigurator<T> {
-    if (this is CompositeKotlinFragmentConfigurationsConfigurator && other is CompositeKotlinFragmentConfigurationsConfigurator) {
-        return CompositeKotlinFragmentConfigurationsConfigurator(this.setups + other.setups)
-    }
-
-    if (this is CompositeKotlinFragmentConfigurationsConfigurator) {
-        return CompositeKotlinFragmentConfigurationsConfigurator(this.setups + other)
-    }
-
-    if (other is CompositeKotlinFragmentConfigurationsConfigurator) {
-        return CompositeKotlinFragmentConfigurationsConfigurator(listOf(this) + other.setups)
-    }
-
-    return CompositeKotlinFragmentConfigurationsConfigurator(listOf(this, other))
-}
-
-private class CompositeKotlinFragmentConfigurationsConfigurator<in T : KotlinGradleFragment>(
-    val setups: List<KotlinFragmentConfigurationsConfigurator<T>>
-) : KotlinFragmentConfigurationsConfigurator<T> {
-    override fun configure(fragment: T, configuration: Configuration) {
-        setups.forEach { setup -> setup.configure(fragment, configuration) }
-    }
-}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentHostSpecificMetadataArtifact.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2021 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.pm20
+
+import org.gradle.api.artifacts.Dependency
+import org.gradle.jvm.tasks.Jar
+import org.jetbrains.kotlin.gradle.dsl.pm20Extension
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
+import org.jetbrains.kotlin.gradle.targets.metadata.filesWithUnpackedArchives
+import org.jetbrains.kotlin.gradle.tasks.registerTask
+import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
+import org.jetbrains.kotlin.project.model.refinesClosure
+
+/**
+ * Will register a 'hostSpecificMetadataJar' [Jar] task containing compilation outputs of host specific metadata.
+ * Will add this jar artifact to the given configuration
+ */
+
+val KotlinFragmentHostSpecificMetadataArtifact = FragmentArtifacts<KotlinNativeVariantInternal> artifacts@{ fragment ->
+    val project = fragment.project
+    val hostSpecificMetadataElements = fragment.hostSpecificMetadataElementsConfiguration ?: return@artifacts
+
+    val hostSpecificMetadataJar = project.registerTask<Jar>(fragment.disambiguateName("hostSpecificMetadataJar")) { jar ->
+        jar.archiveClassifier.set("metadata")
+        jar.archiveAppendix.set(fragment.disambiguateName(""))
+        project.pm20Extension.metadataCompilationRegistryByModuleId.getValue(fragment.containingModule.moduleIdentifier)
+            .withAll { metadataCompilation ->
+                val metadataFragment = metadataCompilation.fragment
+                if (metadataCompilation is KotlinNativeFragmentMetadataCompilationData) {
+                    jar.from(project.files(project.provider {
+                        if (metadataFragment in fragment.refinesClosure && metadataFragment.isNativeHostSpecific())
+                            project.filesWithUnpackedArchives(metadataCompilation.output.allOutputs, setOf(KLIB_FILE_EXTENSION))
+                        else emptyList<Any>()
+                    })) { spec -> spec.into(metadataFragment.name) }
+                }
+            }
+    }
+
+    artifact(hostSpecificMetadataJar)
+    hostSpecificMetadataElements.dependencies.addAllLater(project.objects.listProperty(Dependency::class.java).apply {
+        set(project.provider { fragment.apiElementsConfiguration.allDependencies })
+    })
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinFragmentModuleCapability.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.pm20
+
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.capabilities.Capability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
+
+val KotlinFragmentModuleCapability = FragmentCapabilities<KotlinGradleFragment> { fragment ->
+    capability(fragment.containingModule.moduleCapability ?: return@FragmentCapabilities)
+}
+
+internal fun setModuleCapability(configuration: Configuration, module: KotlinGradleModule) {
+    configuration.outgoing.capability(module.moduleCapability ?: return)
+}
+
+internal val KotlinGradleModule.moduleCapability: Capability?
+    get() = if (moduleClassifier != null) ComputedCapability.fromModule(this) else null

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinGradleFragmentFactory.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
 import org.gradle.api.NamedDomainObjectFactory
+import org.gradle.api.artifacts.Configuration
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinGradleFragmentFactory.FragmentConfigurator
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinGradleFragmentFactory.FragmentInstantiator
 
@@ -48,3 +49,14 @@ class KotlinGradleFragmentFactory<T : KotlinGradleFragment>(
         return fragmentInstantiator.create(name).apply(fragmentConfigurator::configure)
     }
 }
+
+internal fun <T : KotlinGradleFragment> Configuration.configure(
+    definition: KotlinGradleFragmentConfigurationDefinition<T>,
+    fragment: T
+) {
+    attributes.attribute(definition.attributes, fragment)
+    outgoing.addArtifacts(definition.artifacts, fragment)
+
+    KotlinGradleFragmentConfigurationCapabilities.ContextImpl(this)
+        .setCapabilities(definition.capabilities, fragment)
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinHostSpecificMetadataArtifactConfigurator.kt

@@ -1,47 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20
-
-import org.gradle.api.artifacts.Dependency
-import org.gradle.jvm.tasks.Jar
-import org.jetbrains.kotlin.gradle.dsl.pm20Extension
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
-import org.jetbrains.kotlin.gradle.targets.metadata.filesWithUnpackedArchives
-import org.jetbrains.kotlin.gradle.tasks.registerTask
-import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
-import org.jetbrains.kotlin.project.model.refinesClosure
-
-/**
- * Will register a 'hostSpecificMetadataJar' [Jar] task containing compilation outputs of host specific metadata.
- * Will add this jar artifact to the given configuration
- */
-object KotlinHostSpecificMetadataArtifactConfigurator : KotlinGradleFragmentFactory.FragmentConfigurator<KotlinNativeVariantInternal> {
-    override fun configure(fragment: KotlinNativeVariantInternal) {
-        val project = fragment.project
-        val hostSpecificMetadataElements = fragment.hostSpecificMetadataElementsConfiguration ?: return
-
-        val hostSpecificMetadataJar = project.registerTask<Jar>(fragment.disambiguateName("hostSpecificMetadataJar")) { jar ->
-            jar.archiveClassifier.set("metadata")
-            jar.archiveAppendix.set(fragment.disambiguateName(""))
-            project.pm20Extension.metadataCompilationRegistryByModuleId.getValue(fragment.containingModule.moduleIdentifier)
-                .withAll { metadataCompilation ->
-                    val metadataFragment = metadataCompilation.fragment
-                    if (metadataCompilation is KotlinNativeFragmentMetadataCompilationData) {
-                        jar.from(project.files(project.provider {
-                            if (metadataFragment in fragment.refinesClosure && metadataFragment.isNativeHostSpecific())
-                                project.filesWithUnpackedArchives(metadataCompilation.output.allOutputs, setOf(KLIB_FILE_EXTENSION))
-                            else emptyList<Any>()
-                        })) { spec -> spec.into(metadataFragment.name) }
-                    }
-                }
-        }
-
-        project.artifacts.add(hostSpecificMetadataElements.name, hostSpecificMetadataJar)
-        hostSpecificMetadataElements.dependencies.addAllLater(project.objects.listProperty(Dependency::class.java).apply {
-            set(project.provider { fragment.apiElementsConfiguration.allDependencies })
-        })
-    }
-}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinJvmVariantFactory.kt

@@ -7,92 +7,88 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.configuration.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
 
 typealias KotlinJvmVariantFactory = KotlinGradleFragmentFactory<KotlinJvmVariant>
 
-fun KotlinJvmVariantFactory(module: KotlinGradleModule): KotlinJvmVariantFactory =
-    KotlinJvmVariantFactory(KotlinJvmVariantInstantiator(module))
-
 fun KotlinJvmVariantFactory(
-    jvmVariantInstantiator: KotlinJvmVariantInstantiator,
+    module: KotlinGradleModule, config: KotlinJvmVariantConfig = KotlinJvmVariantConfig()
-    jvmVariantConfigurator: KotlinJvmVariantConfigurator = KotlinJvmVariantConfigurator()
+): KotlinJvmVariantFactory = KotlinJvmVariantFactory(
-): KotlinJvmVariantFactory = KotlinGradleFragmentFactory(
+    KotlinJvmVariantInstantiator(module, config),
-    fragmentInstantiator = jvmVariantInstantiator,
+    KotlinJvmVariantConfigurator(config)
-    fragmentConfigurator = jvmVariantConfigurator
 )
 
-class KotlinJvmVariantInstantiator(
+data class KotlinJvmVariantConfig(
+    val dependenciesConfigurationFactory: KotlinFragmentDependencyConfigurationsFactory
+    = DefaultKotlinFragmentDependencyConfigurationsFactory,
+
+    val compileDependencies: KotlinGradleFragmentConfigurationDefinition<KotlinJvmVariant>
+    = DefaultKotlinCompileDependenciesDefinition,
+
+    val runtimeDependencies: KotlinGradleFragmentConfigurationDefinition<KotlinJvmVariant>
+    = DefaultKotlinRuntimeDependenciesDefinition,
+
+    val apiElements: KotlinGradleFragmentConfigurationDefinition<KotlinJvmVariant>
+    = DefaultKotlinApiElementsDefinition + KotlinFragmentCompilationOutputsJarArtifact,
+
+    val runtimeElements: KotlinGradleFragmentConfigurationDefinition<KotlinJvmVariant>
+    = DefaultKotlinRuntimeElementsDefinition,
+
+    val compileTaskConfigurator: KotlinCompileTaskConfigurator<KotlinJvmVariant>
+    = KotlinJvmCompileTaskConfigurator,
+
+    val sourceArchiveTaskConfigurator: KotlinSourceArchiveTaskConfigurator<KotlinJvmVariant>
+    = DefaultKotlinSourceArchiveTaskConfigurator,
+
+    val sourceDirectoriesConfigurator: KotlinSourceDirectoriesConfigurator<KotlinJvmVariant>
+    = DefaultKotlinSourceDirectoriesConfigurator,
+
+    val publicationConfigurator: KotlinPublicationConfigurator<KotlinJvmVariant>
+    = KotlinPublicationConfigurator.SingleVariantPublication
+)
+
+class KotlinJvmVariantInstantiator internal constructor(
     private val module: KotlinGradleModule,
-
+    private val config: KotlinJvmVariantConfig
-    private val dependenciesConfigurationFactory: KotlinFragmentDependencyConfigurationsFactory =
+) : KotlinGradleFragmentFactory.FragmentInstantiator<KotlinJvmVariant> {
-        DefaultKotlinFragmentDependencyConfigurationsFactory,
-
-    private val compileDependenciesConfigurationInstantiator: KotlinCompileDependenciesConfigurationInstantiator =
-        DefaultKotlinCompileDependenciesConfigurationInstantiator,
-
-    private val apiElementsConfigurationInstantiator: KotlinApiElementsConfigurationInstantiator =
-        DefaultKotlinApiElementsConfigurationInstantiator,
-
-    private val runtimeDependenciesConfigurationInstantiator: KotlinRuntimeDependenciesConfigurationInstantiator =
-        DefaultKotlinRuntimeDependenciesConfigurationInstantiator,
-
-    private val runtimeElementsConfigurationInstantiator: KotlinRuntimeElementsConfigurationFactory =
-        DefaultKotlinRuntimeElementsConfigurationInstantiator,
-
-    ) : KotlinGradleFragmentFactory.FragmentInstantiator<KotlinJvmVariant> {
 
     override fun create(name: String): KotlinJvmVariant {
         val names = FragmentNameDisambiguation(module, name)
-        val dependencies = dependenciesConfigurationFactory.create(module, names)
+        val context = ConfigurationContextImpl(module, config.dependenciesConfigurationFactory.create(module, names), names)
+
         return KotlinJvmVariant(
             containingModule = module,
             fragmentName = name,
-            dependencyConfigurations = dependencies,
+            dependencyConfigurations = context.dependencies,
-            compileDependenciesConfiguration = compileDependenciesConfigurationInstantiator.create(module, names, dependencies),
+            compileDependenciesConfiguration = config.compileDependencies.provider.getConfiguration(context).also { configuration ->
-            apiElementsConfiguration = apiElementsConfigurationInstantiator.create(module, names, dependencies),
+                config.compileDependencies.relations.run { context.setupExtendsFromRelations(configuration) }
-            runtimeDependenciesConfiguration = runtimeDependenciesConfigurationInstantiator.create(module, names, dependencies),
+            },
-            runtimeElementsConfiguration = runtimeElementsConfigurationInstantiator.create(module, names, dependencies)
+            runtimeDependenciesConfiguration = config.runtimeDependencies.provider.getConfiguration(context).also { configuration ->
+                config.runtimeDependencies.relations.run { context.setupExtendsFromRelations(configuration) }
+            },
+            apiElementsConfiguration = config.apiElements.provider.getConfiguration(context).also { configuration ->
+                config.apiElements.relations.run { context.setupExtendsFromRelations(configuration) }
+            },
+            runtimeElementsConfiguration = config.runtimeElements.provider.getConfiguration(context).also { configuration ->
+                config.runtimeElements.relations.run { context.setupExtendsFromRelations(configuration) }
+            }
         )
     }
 }
 
-class KotlinJvmVariantConfigurator(
+class KotlinJvmVariantConfigurator internal constructor(
-    private val compileTaskConfigurator: KotlinCompileTaskConfigurator<KotlinJvmVariant> =
+    private val config: KotlinJvmVariantConfig
-        KotlinJvmCompileTaskConfigurator,
-
-    private val sourceArchiveTaskConfigurator: KotlinSourceArchiveTaskConfigurator<KotlinJvmVariant> =
-        DefaultKotlinSourceArchiveTaskConfigurator,
-
-    private val sourceDirectoriesConfigurator: KotlinSourceDirectoriesConfigurator<KotlinJvmVariant> =
-        DefaultKotlinSourceDirectoriesConfigurator,
-
-    private val compileDependenciesConfigurator: KotlinFragmentConfigurationsConfigurator<KotlinJvmVariant> =
-        DefaultKotlinCompileDependenciesConfigurator,
-
-    private val runtimeDependenciesConfigurator: KotlinFragmentConfigurationsConfigurator<KotlinJvmVariant> =
-        DefaultKotlinRuntimeDependenciesConfigurator,
-
-    private val apiElementsConfigurator: KotlinFragmentConfigurationsConfigurator<KotlinJvmVariant> =
-        DefaultKotlinApiElementsConfigurator + KotlinCompilationOutputsJarArtifactConfigurator,
-
-    private val runtimeElementsConfigurator: KotlinFragmentConfigurationsConfigurator<KotlinJvmVariant> =
-        DefaultKotlinRuntimeElementsConfigurator,
-
-    private val publicationConfigurator: KotlinPublicationConfigurator<KotlinJvmVariant> =
-        KotlinPublicationConfigurator.SingleVariantPublication
-
 ) : KotlinGradleFragmentFactory.FragmentConfigurator<KotlinJvmVariant> {
 
     override fun configure(fragment: KotlinJvmVariant) {
-        compileDependenciesConfigurator.configure(fragment, fragment.compileDependenciesConfiguration)
+        fragment.compileDependenciesConfiguration.configure(config.compileDependencies, fragment)
-        runtimeDependenciesConfigurator.configure(fragment, fragment.runtimeDependenciesConfiguration)
+        fragment.runtimeDependenciesConfiguration.configure(config.runtimeDependencies, fragment)
-        apiElementsConfigurator.configure(fragment, fragment.apiElementsConfiguration)
+        fragment.apiElementsConfiguration.configure(config.apiElements, fragment)
-        runtimeElementsConfigurator.configure(fragment, fragment.runtimeElementsConfiguration)
+        fragment.runtimeElementsConfiguration.configure(config.runtimeElements, fragment)
-        sourceDirectoriesConfigurator.configure(fragment)
+
-        compileTaskConfigurator.registerCompileTasks(fragment)
+        config.sourceDirectoriesConfigurator.configure(fragment)
-        sourceArchiveTaskConfigurator.registerSourceArchiveTask(fragment)
+        config.compileTaskConfigurator.registerCompileTasks(fragment)
-        publicationConfigurator.configure(fragment)
+        config.sourceArchiveTaskConfigurator.registerSourceArchiveTask(fragment)
+        config.publicationConfigurator.configure(fragment)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinNativeVariantFactory.kt

@@ -7,88 +7,85 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.configuration.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
 
 fun <T : KotlinNativeVariantInternal> KotlinNativeVariantFactory(
-    nativeVariantInstantiator: KotlinNativeVariantInstantiator<T>,
+    module: KotlinGradleModule,
-    nativeVariantConfigurator: KotlinNativeVariantConfigurator<T> = KotlinNativeVariantConfigurator()
+    constructor: KotlinNativeVariantConstructor<T>,
+    config: KotlinNativeVariantConfig<T> = KotlinNativeVariantConfig()
 ) = KotlinGradleFragmentFactory(
-    fragmentInstantiator = nativeVariantInstantiator,
+    fragmentInstantiator = KotlinNativeVariantInstantiator(module, constructor, config),
-    fragmentConfigurator = nativeVariantConfigurator
+    fragmentConfigurator = KotlinNativeVariantConfigurator(config)
+)
+
+data class KotlinNativeVariantConfig<T : KotlinNativeVariantInternal>(
+    val dependenciesConfigurationFactory: KotlinFragmentDependencyConfigurationsFactory =
+        DefaultKotlinFragmentDependencyConfigurationsFactory,
+
+    val compileDependencies: ConfigurationDefinition<T> =
+        DefaultKotlinCompileDependenciesDefinition + KotlinFragmentKonanTargetAttribute,
+
+    val apiElements: ConfigurationDefinition<T> =
+        DefaultKotlinApiElementsDefinition + KotlinFragmentKonanTargetAttribute,
+
+    val hostSpecificMetadataElements: ConfigurationDefinition<T> =
+        DefaultKotlinHostSpecificMetadataElementsDefinition,
+
+    val compileTaskConfigurator: KotlinCompileTaskConfigurator<T> =
+        KotlinNativeCompileTaskConfigurator,
+
+    val sourceArchiveTaskConfigurator: KotlinSourceArchiveTaskConfigurator<T> =
+        DefaultKotlinSourceArchiveTaskConfigurator,
+
+    val sourceDirectoriesConfigurator: KotlinSourceDirectoriesConfigurator<T> =
+        DefaultKotlinSourceDirectoriesConfigurator,
+
+    val publicationConfigurator: KotlinPublicationConfigurator<KotlinNativeVariantInternal> =
+        KotlinPublicationConfigurator.NativeVariantPublication
 )
 
 class KotlinNativeVariantInstantiator<T : KotlinNativeVariantInternal>(
     private val module: KotlinGradleModule,
-
     private val kotlinNativeVariantConstructor: KotlinNativeVariantConstructor<T>,
-
+    private val config: KotlinNativeVariantConfig<T>
-    private val dependenciesConfigurationFactory: KotlinFragmentDependencyConfigurationsFactory =
-        DefaultKotlinFragmentDependencyConfigurationsFactory,
-
-    private val compileDependenciesConfigurationInstantiator: KotlinCompileDependenciesConfigurationInstantiator =
-        DefaultKotlinCompileDependenciesConfigurationInstantiator,
-
-    private val apiElementsConfigurationInstantiator: KotlinApiElementsConfigurationInstantiator =
-        DefaultKotlinApiElementsConfigurationInstantiator,
-
-    private val hostSpecificMetadataElementsConfigurationInstantiator: KotlinHostSpecificMetadataElementsConfigurationInstantiator? =
-        DefaultKotlinHostSpecificMetadataElementsConfigurationInstantiator(kotlinNativeVariantConstructor.konanTarget)
 
 ) : KotlinGradleFragmentFactory.FragmentInstantiator<T> {
 
     override fun create(name: String): T {
         val names = FragmentNameDisambiguation(module, name)
-        val dependencies = dependenciesConfigurationFactory.create(module, names)
+        val dependencies = config.dependenciesConfigurationFactory.create(module, names)
+        val context = ConfigurationContextImpl(module, dependencies, names)
+
         return kotlinNativeVariantConstructor.invoke(
             containingModule = module,
             fragmentName = name,
             dependencyConfigurations = dependencies,
-            compileDependencyConfiguration = compileDependenciesConfigurationInstantiator.create(module, names, dependencies),
+            compileDependencyConfiguration = config.compileDependencies.provider.getConfiguration(context).also { configuration ->
-            apiElementsConfiguration = apiElementsConfigurationInstantiator.create(module, names, dependencies),
+                config.compileDependencies.relations.run { context.setupExtendsFromRelations(configuration) }
+            },
+            apiElementsConfiguration = config.apiElements.provider.getConfiguration(context).also { configuration ->
+                config.apiElements.relations.run { context.setupExtendsFromRelations(configuration) }
+            },
             hostSpecificMetadataElementsConfiguration =
-            hostSpecificMetadataElementsConfigurationInstantiator?.create(module, names, dependencies)
+            config.hostSpecificMetadataElements.provider.getConfiguration(context).also { configuration ->
+                config.hostSpecificMetadataElements.relations.run { context.setupExtendsFromRelations(configuration) }
+            }
         )
     }
 }
 
 class KotlinNativeVariantConfigurator<T : KotlinNativeVariantInternal>(
-    private val compileTaskConfigurator: KotlinCompileTaskConfigurator<T> =
+    private val config: KotlinNativeVariantConfig<T>
-        KotlinNativeCompileTaskConfigurator,
-
-    private val sourceArchiveTaskConfigurator: KotlinSourceArchiveTaskConfigurator<T> =
-        DefaultKotlinSourceArchiveTaskConfigurator,
-
-    private val sourceDirectoriesConfigurator: KotlinSourceDirectoriesConfigurator<T> =
-        DefaultKotlinSourceDirectoriesConfigurator,
-
-    private val compileDependenciesConfigurator: KotlinFragmentConfigurationsConfigurator<T> =
-        DefaultKotlinCompileDependenciesConfigurator + KonanTargetAttributesConfigurator,
-
-    private val apiElementsConfigurator: KotlinFragmentConfigurationsConfigurator<T> =
-        DefaultKotlinApiElementsConfigurator + KonanTargetAttributesConfigurator,
-
-    private val hostSpecificMetadataElementsConfigurator: KotlinFragmentConfigurationsConfigurator<T> =
-        DefaultHostSpecificMetadataElementsConfigurator,
-
-    private val hostSpecificMetadataArtifactConfigurator: KotlinGradleFragmentFactory.FragmentConfigurator<T> =
-        KotlinHostSpecificMetadataArtifactConfigurator,
-
-    private val publicationConfigurator: KotlinPublicationConfigurator<KotlinNativeVariantInternal> =
-        KotlinPublicationConfigurator.NativeVariantPublication
 ) : KotlinGradleFragmentFactory.FragmentConfigurator<T> {
 
     override fun configure(fragment: T) {
-        compileDependenciesConfigurator.configure(fragment, fragment.compileDependenciesConfiguration)
+        fragment.compileDependenciesConfiguration.configure(config.compileDependencies, fragment)
-        apiElementsConfigurator.configure(fragment, fragment.apiElementsConfiguration)
+        fragment.apiElementsConfiguration.configure(config.apiElements, fragment)
-        fragment.hostSpecificMetadataElementsConfiguration?.let { configuration ->
+        fragment.hostSpecificMetadataElementsConfiguration?.configure(config.hostSpecificMetadataElements, fragment)
-            hostSpecificMetadataElementsConfigurator.configure(fragment, configuration)
+
-        }
+        config.sourceDirectoriesConfigurator.configure(fragment)
-        hostSpecificMetadataArtifactConfigurator.configure(fragment)
+        config.compileTaskConfigurator.registerCompileTasks(fragment)
-        sourceDirectoriesConfigurator.configure(fragment)
+        config.sourceArchiveTaskConfigurator.registerSourceArchiveTask(fragment)
-        compileTaskConfigurator.registerCompileTasks(fragment)
+        config.publicationConfigurator.configure(fragment)
-        sourceArchiveTaskConfigurator.registerSourceArchiveTask(fragment)
-        publicationConfigurator.configure(fragment)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/configuration/KotlinApiElements.kt

@@ -1,39 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20.configuration
-
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-
-interface KotlinApiElementsConfigurationInstantiator : KotlinFragmentConfigurationInstantiator
-
-object DefaultKotlinApiElementsConfigurationInstantiator : KotlinApiElementsConfigurationInstantiator {
-    override fun create(
-        module: KotlinGradleModule,
-        names: KotlinNameDisambiguation,
-        dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration {
-        return module.project.configurations.maybeCreate(names.disambiguateName("apiElements")).apply {
-            isCanBeResolved = false
-            isCanBeConsumed = false
-            extendsFrom(dependencies.transitiveApiConfiguration)
-            module.ifMadePublic { isCanBeConsumed = true }
-
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, module.project.objects.named(Category::class.java, Category.LIBRARY))
-            attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, module.project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
-        }
-    }
-}
-
-val DefaultKotlinApiElementsConfigurator = KotlinConfigurationsConfigurator(
-    KotlinFragmentPlatformAttributesConfigurator,
-    KotlinFragmentModuleCapabilityConfigurator,
-    KotlinFragmentProducerApiUsageAttributesConfigurator
-)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/configuration/KotlinCompileDependencies.kt

@@ -1,34 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20.configuration
-
-import org.gradle.api.artifacts.Configuration
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
-
-
-interface KotlinCompileDependenciesConfigurationInstantiator : KotlinFragmentConfigurationInstantiator
-
-object DefaultKotlinCompileDependenciesConfigurationInstantiator : KotlinCompileDependenciesConfigurationInstantiator {
-    override fun create(
-        module: KotlinGradleModule,
-        names: KotlinNameDisambiguation,
-        dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration {
-        return module.project.configurations.maybeCreate(names.disambiguateName("compileDependencies")).apply {
-            isCanBeConsumed = false
-            isCanBeResolved = true
-            module.project.addExtendsFromRelation(name, dependencies.transitiveApiConfiguration.name)
-            module.project.addExtendsFromRelation(name, dependencies.transitiveImplementationConfiguration.name)
-        }
-    }
-}
-
-val DefaultKotlinCompileDependenciesConfigurator = KotlinConfigurationsConfigurator(
-    KotlinFragmentPlatformAttributesConfigurator, KotlinFragmentConsumerApiUsageAttributesConfigurator
-)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/configuration/KotlinHostSpecificMetadataElements.kt

@@ -1,40 +0,0 @@
-/*
- * Copyright 2010-2021 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.
- */
-
-@file:Suppress("FunctionName")
-
-package org.jetbrains.kotlin.gradle.plugin.mpp.pm20.configuration
-
-import org.gradle.api.artifacts.Configuration
-import org.jetbrains.kotlin.gradle.plugin.mpp.isHostSpecificKonanTargetsSet
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-import org.jetbrains.kotlin.konan.target.KonanTarget
-
-interface KotlinHostSpecificMetadataElementsConfigurationInstantiator : KotlinFragmentConfigurationInstantiator
-
-fun DefaultKotlinHostSpecificMetadataElementsConfigurationInstantiator(
-    konanTarget: KonanTarget
-): KotlinHostSpecificMetadataElementsConfigurationInstantiator? = if (isHostSpecificKonanTargetsSet(setOf(konanTarget)))
-    DefaultKotlinHostSpecificMetadataElementsConfigurationInstantiator else null
-
-private object DefaultKotlinHostSpecificMetadataElementsConfigurationInstantiator :
-    KotlinHostSpecificMetadataElementsConfigurationInstantiator {
-    override fun create(
-        module: KotlinGradleModule, names: KotlinNameDisambiguation, dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration {
-        return module.project.configurations.maybeCreate(names.disambiguateName("hostSpecificMetadataElements")).apply {
-            isCanBeResolved = false
-            isCanBeConsumed = false
-        }
-    }
-}
-
-val DefaultHostSpecificMetadataElementsConfigurator = KotlinConfigurationsConfigurator(
-    KotlinFragmentPlatformAttributesConfigurator,
-    KonanTargetAttributesConfigurator,
-    KotlinFragmentMetadataUsageAttributeConfigurator
-)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/configuration/KotlinRuntimeDependencies.kt

@@ -1,34 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20.configuration
-
-import org.gradle.api.artifacts.Configuration
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
-
-interface KotlinRuntimeDependenciesConfigurationInstantiator : KotlinFragmentConfigurationInstantiator
-
-object DefaultKotlinRuntimeDependenciesConfigurationInstantiator : KotlinRuntimeDependenciesConfigurationInstantiator {
-    override fun create(
-        module: KotlinGradleModule,
-        names: KotlinNameDisambiguation,
-        dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration {
-        return module.project.configurations.maybeCreate(names.disambiguateName("runtimeDependencies")).apply {
-            isCanBeConsumed = false
-            isCanBeResolved = true
-            module.project.addExtendsFromRelation(name, dependencies.transitiveApiConfiguration.name)
-            module.project.addExtendsFromRelation(name, dependencies.transitiveImplementationConfiguration.name)
-        }
-    }
-}
-
-val DefaultKotlinRuntimeDependenciesConfigurator = KotlinConfigurationsConfigurator(
-    KotlinFragmentPlatformAttributesConfigurator,
-    KotlinFragmentConsumerRuntimeUsageAttributesConfigurator
-)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/configuration/KotlinRuntimeElements.kt

@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2021 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.pm20.configuration
-
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinFragmentModuleCapabilityConfigurator.setModuleCapability
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.KotlinNameDisambiguation
-
-interface KotlinRuntimeElementsConfigurationFactory : KotlinFragmentConfigurationInstantiator
-
-object DefaultKotlinRuntimeElementsConfigurationInstantiator : KotlinRuntimeElementsConfigurationFactory {
-    override fun create(
-        module: KotlinGradleModule,
-        names: KotlinNameDisambiguation,
-        dependencies: KotlinFragmentDependencyConfigurations
-    ): Configuration {
-        return module.project.configurations.maybeCreate(names.disambiguateName("runtimeElements")).apply {
-            isCanBeResolved = false
-            isCanBeConsumed = false
-
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, module.project.objects.named(Category::class.java, Category.LIBRARY))
-            attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, module.project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
-
-            extendsFrom(dependencies.transitiveApiConfiguration)
-            extendsFrom(dependencies.transitiveImplementationConfiguration)
-            module.ifMadePublic {
-                isCanBeConsumed = true
-                setModuleCapability(this, module)
-            }
-        }
-    }
-}
-
-val DefaultKotlinRuntimeElementsConfigurator = KotlinConfigurationsConfigurator(
-    KotlinFragmentPlatformAttributesConfigurator,
-    KotlinFragmentProducerRuntimeUsageAttributesConfigurator
-)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/fragmentsMetadataCompilation.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.gradle.dsl.pm20Extension
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinCommonSourceSetProcessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinFragmentModuleCapabilityConfigurator.setModuleCapability
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
 import org.jetbrains.kotlin.gradle.targets.metadata.createGenerateProjectStructureMetadataTask

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/UnsafeApi.kt

@@ -6,4 +6,5 @@
 package org.jetbrains.kotlin.gradle.utils
 
 @RequiresOptIn("Unsafe API. Please use safe counterpart", level = RequiresOptIn.Level.ERROR)
-internal annotation class UnsafeApi
+@Retention(AnnotationRetention.BINARY)
+internal annotation class UnsafeApi(val message: String = "")