Remove deprecated ConfigureUtil usages in HasKotlinDependencies

^KT-46019 In Progress
2022-06-28 12:50:18 +02:00
parent 4b0ba493b7
commit f0cfe60734
37 changed files with 684 additions and 215 deletions
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.gradle.plugin

 import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.ExternalModuleDependency
@@ -164,7 +165,7 @@ interface KotlinDependencyHandler {

 interface HasKotlinDependencies {
    fun dependencies(configure: KotlinDependencyHandler.() -> Unit)
-    fun dependencies(configureClosure: Closure<Any?>)
+    fun dependencies(configure: Action<KotlinDependencyHandler>)

    val apiConfigurationName: String
    val implementationConfigurationName: String
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Named
 import org.gradle.api.attributes.AttributeContainer
 import org.gradle.api.attributes.HasAttributes
@@ -38,7 +38,7 @@ interface KotlinCompilation<out T : KotlinCommonOptions> : Named, HasAttributes,
    val defaultSourceSet: KotlinSourceSet

    fun defaultSourceSet(configure: KotlinSourceSet.() -> Unit)
-    fun defaultSourceSet(configure: Closure<*>) = defaultSourceSet { target.project.configure(this, configure) }
+    fun defaultSourceSet(configure: Action<KotlinSourceSet>) = defaultSourceSet { configure.execute(this) }

    val compileDependencyConfigurationName: String

@@ -57,10 +57,10 @@ interface KotlinCompilation<out T : KotlinCommonOptions> : Named, HasAttributes,
    val kotlinOptions: T

    fun kotlinOptions(configure: T.() -> Unit)
-    fun kotlinOptions(configure: Closure<*>) = kotlinOptions { target.project.configure(this, configure) }
+    fun kotlinOptions(configure: Action<@UnsafeVariance T>) = kotlinOptions { configure.execute(this) }

    fun attributes(configure: AttributeContainer.() -> Unit) = attributes.configure()
-    fun attributes(configure: Closure<*>) = attributes { target.project.configure(this, configure) }
+    fun attributes(configure: Action<AttributeContainer>) = attributes { configure.execute(this) }

    val compileAllTaskName: String

@@ -5,19 +5,22 @@

 package org.jetbrains.kotlin.gradle.plugin

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Named
 import org.gradle.api.file.SourceDirectorySet

 interface KotlinSourceSet : Named, HasKotlinDependencies {
    val kotlin: SourceDirectorySet
-    fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet
+
+    fun kotlin(configure: SourceDirectorySet.() -> Unit): SourceDirectorySet
+
+    fun kotlin(configure: Action<SourceDirectorySet>): SourceDirectorySet

    val resources: SourceDirectorySet

    val languageSettings: LanguageSettingsBuilder
    fun languageSettings(configure: LanguageSettingsBuilder.() -> Unit): LanguageSettingsBuilder
-    fun languageSettings(configureClosure: Closure<Any?>): LanguageSettingsBuilder
+    fun languageSettings(configure: Action<LanguageSettingsBuilder>): LanguageSettingsBuilder

    fun dependsOn(other: KotlinSourceSet)
    val dependsOn: Set<KotlinSourceSet>
@@ -5,12 +5,13 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Named
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.file.SourceDirectorySet
 import org.jetbrains.kotlin.gradle.plugin.HasKotlinDependencies
+import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import org.jetbrains.kotlin.project.model.KpmFragment
 import org.jetbrains.kotlin.project.model.utils.variantsContainingFragment
@@ -44,8 +45,8 @@ interface GradleKpmFragment : KpmFragment, HasKotlinDependencies, GradleKpmFragm
    override val withRefinesClosure: Set<GradleKpmFragment>
        get() = this.withClosure { it.declaredRefinesDependencies }

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        dependencies f@{ project.configure(this@f, configureClosure) }
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        dependencies { configure.execute(this) }

    companion object {
        const val COMMON_FRAGMENT_NAME = "common"
@@ -5,11 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20

-import groovy.lang.Closure
-import org.gradle.api.ExtensiblePolymorphicDomainObjectContainer
-import org.gradle.api.Named
-import org.gradle.api.NamedDomainObjectSet
-import org.gradle.api.Project
+import org.gradle.api.*
 import org.jetbrains.kotlin.gradle.plugin.HasKotlinDependencies
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.project.model.KpmModule
@@ -56,8 +52,8 @@ interface GradleKpmModule : KpmModule, Named, HasKotlinDependencies {
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit) =
        common.dependencies(configure)

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        common.dependencies(configureClosure)
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        dependencies { configure.execute(this) }

    override val apiConfigurationName: String
        get() = common.apiConfigurationName
@@ -3,14 +3,10 @@
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

-@file:OptIn(ExperimentalPathApi::class)
-
 package org.jetbrains.kotlin.generators.gradle.dsl

 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.konan.target.presetName
-import java.util.*
-import kotlin.io.path.ExperimentalPathApi
 import kotlin.io.path.Path
 import kotlin.io.path.writeText

@@ -52,7 +48,7 @@ private fun variantClasses() = allKonanTargets()
    .joinToString("\n\n")

 private fun variantClass(konanTarget: KonanTarget) = """
-    open class ${konanTarget.variantClassName} @Inject constructor(
+    abstract class ${konanTarget.variantClassName} @Inject constructor(
        containingModule: GradleKpmModule,
        fragmentName: String,
        dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -70,14 +66,30 @@ private fun variantClass(konanTarget: KonanTarget) = """
    ) {
        companion object {
            val constructor = GradleKpmNativeVariantConstructor(
-                KonanTarget.${konanTarget.className}, ${konanTarget.variantClassName}::class.java, ::${konanTarget.variantClassName}
-            )
+                KonanTarget.${konanTarget.className},
+                ${konanTarget.variantClassName}::class.java
+            ) { containingModule: GradleKpmModule,
+                fragmentName: String,
+                dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+                compileDependencyConfiguration: Configuration,
+                apiElementsConfiguration: Configuration,
+                hostSpecificMetadataElementsConfiguration: Configuration? ->
+                containingModule.project.objects.newInstance(
+                    ${konanTarget.variantClassName}::class.java,
+                    containingModule,
+                    fragmentName,
+                    dependencyConfigurations,
+                    compileDependencyConfiguration,
+                    apiElementsConfiguration,
+                    hostSpecificMetadataElementsConfiguration
+                )
+            }
        }
    }
 """.trimIndent()

 private fun kpmVariantClassFunction(): String {
-    val konanTargetToVariant  = allKonanTargets()
+    val konanTargetToVariant = allKonanTargets()
        .joinToString("\n") { "KonanTarget.${it.className} -> ${it.variantClassName}::class.java" }

    return """
@@ -5,20 +5,18 @@

 package org.jetbrains.kotlin.gradle.dsl

-import groovy.lang.Closure
 import org.gradle.api.Action
 import org.gradle.api.InvalidUserCodeException
 import org.gradle.api.NamedDomainObjectCollection
 import org.gradle.api.Project
 import org.gradle.api.internal.plugins.DslObject
 import org.gradle.api.logging.Logger
-import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import javax.inject.Inject

-open class KotlinMultiplatformExtension(project: Project) :
+abstract class KotlinMultiplatformExtension(project: Project) :
    KotlinProjectExtension(project),
    KotlinTargetContainerWithPresetFunctions,
    KotlinTargetContainerWithJsPresetFunctions,
@@ -63,7 +61,7 @@ open class KotlinMultiplatformExtension(project: Project) :
        @Suppress("UNCHECKED_CAST")
        (targets.getByName(KotlinMultiplatformPlugin.METADATA_TARGET_NAME) as KotlinOnlyTarget<AbstractKotlinCompilation<*>>).also(configure)

-    fun metadata(configure: Closure<*>) = metadata { ConfigureUtil.configure(configure, this) }
+    fun metadata(configure: Action<KotlinOnlyTarget<AbstractKotlinCompilation<*>>>) = metadata { configure.execute(this) }

    fun <T : KotlinTarget> targetFromPreset(
        preset: KotlinTargetPreset<T>,
@@ -71,12 +69,16 @@ open class KotlinMultiplatformExtension(project: Project) :
        configure: T.() -> Unit = { }
    ): T = configureOrCreate(name, preset, configure)

-    fun targetFromPreset(preset: KotlinTargetPreset<*>, name: String, configure: Closure<*>) =
-        targetFromPreset(preset, name) { ConfigureUtil.configure(configure, this) }
+    fun <T : KotlinTarget> targetFromPreset(
+        preset: KotlinTargetPreset<T>,
+        name: String,
+        configure: Action<T>
+    ) = targetFromPreset(preset, name) { configure.execute(this) }

-    fun targetFromPreset(preset: KotlinTargetPreset<*>) = targetFromPreset(preset, preset.name) { }
-    fun targetFromPreset(preset: KotlinTargetPreset<*>, name: String) = targetFromPreset(preset, name) { }
-    fun targetFromPreset(preset: KotlinTargetPreset<*>, configure: Closure<*>) = targetFromPreset(preset, preset.name, configure)
+    fun <T : KotlinTarget> targetFromPreset(preset: KotlinTargetPreset<T>) = targetFromPreset(preset, preset.name) { }
+    fun <T : KotlinTarget> targetFromPreset(preset: KotlinTargetPreset<T>, name: String) = targetFromPreset(preset, name) { }
+    fun <T : KotlinTarget> targetFromPreset(preset: KotlinTargetPreset<T>, configure: Action<T>) =
+        targetFromPreset(preset, preset.name, configure)

    internal val rootSoftwareComponent: KotlinSoftwareComponent by lazy {
        KotlinSoftwareComponentWithCoordinatesAndPublication(project, "kotlin", targets)
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.UnknownTaskException
 import org.gradle.api.artifacts.Dependency
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.project.model.LanguageSettings
 import org.jetbrains.kotlin.tooling.core.closure
 import java.util.*
 import java.util.concurrent.Callable
+import javax.inject.Inject

 interface CompilationDetails<T : KotlinCommonOptions> {
    val target: KotlinTarget
@@ -89,7 +90,8 @@ open class DefaultCompilationDetails<T : KotlinCommonOptions>(
        get() = this

    override val kotlinDependenciesHolder: HasKotlinDependencies
-        get() = KotlinDependencyConfigurationsHolder(
+        get() = project.objects.newInstance(
+            KotlinDependencyConfigurationsHolder::class.java,
            project,
            lowerCamelCaseName(
                target.disambiguationClassifier,
@@ -563,7 +565,7 @@ internal open class JsCompilationDetails(
    compilationPurpose: String,
 ) : DefaultCompilationDetailsWithRuntime<KotlinJsOptions>(target, compilationPurpose, { KotlinJsOptionsImpl() }) {

-    protected open class JsCompilationDependenciesHolder(
+    internal abstract class JsCompilationDependenciesHolder @Inject constructor(
        val target: KotlinTarget,
        val compilationPurpose: String
    ) : HasKotlinDependencies {
@@ -597,12 +599,12 @@ internal open class JsCompilationDetails(
        override fun dependencies(configure: KotlinDependencyHandler.() -> Unit): Unit =
            DefaultKotlinDependencyHandler(this, target.project).run(configure)

-        override fun dependencies(configureClosure: Closure<Any?>) =
-            dependencies f@{ project.configure(this@f, configureClosure) }
+        override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+            dependencies { configure.execute(this) }
    }

    override val kotlinDependenciesHolder: HasKotlinDependencies
-        get() = JsCompilationDependenciesHolder(target, compilationPurpose)
+        get() = target.project.objects.newInstance(JsCompilationDependenciesHolder::class.java, target, compilationPurpose)

    override val defaultSourceSetName: String
        get() {
@@ -637,17 +639,17 @@ internal class JsIrCompilationDetails(target: KotlinTarget, compilationPurpose:
            )
        }

-    private class JsIrCompilationDependencyHolder(target: KotlinTarget, compilationPurpose: String) :
+    internal abstract class JsIrCompilationDependencyHolder @Inject constructor(target: KotlinTarget, compilationPurpose: String) :
        JsCompilationDependenciesHolder(target, compilationPurpose) {
        override val disambiguationClassifierInPlatform: String?
            get() = (target as KotlinJsIrTarget).disambiguationClassifierInPlatform
    }

    override val kotlinDependenciesHolder: HasKotlinDependencies
-        get() = JsIrCompilationDependencyHolder(target, compilationPurpose)
+        get() = target.project.objects.newInstance(JsIrCompilationDependencyHolder::class.java, target, compilationPurpose)
 }

-internal class KotlinDependencyConfigurationsHolder(
+internal abstract class KotlinDependencyConfigurationsHolder @Inject constructor(
    val project: Project,
    private val configurationNamesPrefix: String?,
 ) : HasKotlinDependencies {
@@ -667,6 +669,6 @@ internal class KotlinDependencyConfigurationsHolder(
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit): Unit =
        DefaultKotlinDependencyHandler(this, project).run(configure)

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        dependencies f@{ project.configure(this@f, configureClosure) }
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        dependencies { configure.execute(this) }
 }
@@ -5,20 +5,16 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.gradle.api.file.FileCollection
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonOptions
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonOptionsImpl
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
-import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
-import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon
+import javax.inject.Inject

-interface KotlinMetadataCompilation<T : KotlinCommonOptions> : KotlinCompilation<T>
+ interface KotlinMetadataCompilation<T : KotlinCommonOptions> : KotlinCompilation<T>

-class KotlinCommonCompilation(
+abstract class KotlinCommonCompilation @Inject constructor(
    compilationDetails: CompilationDetails<KotlinMultiplatformCommonOptions>
 ) : AbstractKotlinCompilation<KotlinMultiplatformCommonOptions>(compilationDetails),
    KotlinMetadataCompilation<KotlinMultiplatformCommonOptions> {
@@ -20,5 +20,5 @@ class KotlinCommonCompilationFactory(
        get() = KotlinCommonCompilation::class.java

    override fun create(name: String): KotlinCommonCompilation =
-        KotlinCommonCompilation(MetadataCompilationDetails(target, name))
+        target.project.objects.newInstance(KotlinCommonCompilation::class.java, MetadataCompilationDetails(target, name))
 }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -62,7 +62,7 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(
    override val compileOnlyConfigurationName: String get() = kotlinDependenciesHolder.compileOnlyConfigurationName
    override val runtimeOnlyConfigurationName: String get() = kotlinDependenciesHolder.runtimeOnlyConfigurationName
    final override fun dependencies(configure: KotlinDependencyHandler.() -> Unit) = kotlinDependenciesHolder.dependencies(configure)
-    final override fun dependencies(configureClosure: Closure<Any?>) = kotlinDependenciesHolder.dependencies(configureClosure)
+    final override fun dependencies(configure: Action<KotlinDependencyHandler>) = dependencies { configure.execute(this) }
    //endregion

    //region KotlinCompilationData delegation: delegate members manually for better control and prevention of accidental overrides
@@ -29,7 +29,12 @@ class GradleKpmCommonFragmentInstantiator(
 ) : GradleKpmFragmentFactory.FragmentInstantiator<GradleKpmFragmentInternal> {
    override fun create(name: String): GradleKpmFragmentInternal {
        val names = FragmentNameDisambiguation(module, name)
-        return GradleKpmFragmentInternal(module, name, dependencyConfigurationsFactory.create(module, names))
+        return module.project.objects.newInstance(
+            GradleKpmFragmentInternal::class.java,
+            module,
+            name,
+            dependencyConfigurationsFactory.create(module, names)
+        )
    }
 }

@@ -5,12 +5,11 @@

 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.provider.Provider
-import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import org.jetbrains.kotlin.gradle.plugin.mpp.DefaultKotlinDependencyHandler
@@ -25,7 +24,7 @@ import org.jetbrains.kotlin.tooling.core.MutableExtras
 import org.jetbrains.kotlin.tooling.core.mutableExtrasOf
 import javax.inject.Inject

-open class GradleKpmFragmentInternal @Inject constructor(
+abstract class GradleKpmFragmentInternal @Inject constructor(
    final override val containingModule: GradleKpmModule,
    final override val fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations
@@ -79,8 +78,8 @@ open class GradleKpmFragmentInternal @Inject constructor(
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit): Unit =
        DefaultKotlinDependencyHandler(this, project).run(configure)

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        dependencies f@{ ConfigureUtil.configure(configureClosure, this@f) }
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        dependencies { configure.execute(this) }

    private val _declaredRefinesDependencies = mutableSetOf<Provider<GradleKpmFragment>>()

@@ -13,8 +13,9 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.filterModuleName
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.archivesName
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import javax.inject.Inject

-open class GradleKpmJvmVariant(
+abstract class GradleKpmJvmVariant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -59,8 +60,9 @@ internal class KotlinMappedJvmCompilationFactory(
        val module = target.project.kpmModules.maybeCreate(name)
        val variant = module.fragments.create(target.name, GradleKpmJvmVariant::class.java)

-        return KotlinJvmCompilation(
-            VariantMappedCompilationDetailsWithRuntime(variant, target),
+        return target.project.objects.newInstance(
+            KotlinJvmCompilation::class.java,
+            VariantMappedCompilationDetailsWithRuntime<KotlinJvmOptions>(variant, target)
        )
    }
 }
@@ -58,20 +58,21 @@ class GradleKpmJvmVariantInstantiator internal constructor(
            module, config.dependenciesConfigurationFactory.create(module, names), names
        )

-        return GradleKpmJvmVariant(
-            containingModule = module,
-            fragmentName = name,
-            dependencyConfigurations = context.dependencies,
-            compileDependenciesConfiguration = config.compileDependencies.provider.getConfiguration(context).also { configuration ->
+        return module.project.objects.newInstance(
+            GradleKpmJvmVariant::class.java,
+            module,
+            name,
+            context.dependencies,
+            config.compileDependencies.provider.getConfiguration(context).also { configuration ->
                config.compileDependencies.relations.setupExtendsFromRelations(configuration, context)
            },
-            runtimeDependenciesConfiguration = config.runtimeDependencies.provider.getConfiguration(context).also { configuration ->
-                config.runtimeElements.relations.setupExtendsFromRelations(configuration, context)
-            },
-            apiElementsConfiguration = config.apiElements.provider.getConfiguration(context).also { configuration ->
+            config.apiElements.provider.getConfiguration(context).also { configuration ->
                config.apiElements.relations.setupExtendsFromRelations(configuration, context)
            },
-            runtimeElementsConfiguration = config.runtimeElements.provider.getConfiguration(context).also { configuration ->
+            config.runtimeDependencies.provider.getConfiguration(context).also { configuration ->
+                config.runtimeElements.relations.setupExtendsFromRelations(configuration, context)
+            },
+            config.runtimeElements.provider.getConfiguration(context).also { configuration ->
                config.runtimeElements.relations.setupExtendsFromRelations(configuration, context)
            }
        )
@@ -28,8 +28,9 @@ import org.jetbrains.kotlin.project.model.KotlinAttributeKey
 import org.jetbrains.kotlin.project.model.KpmModuleDependency
 import org.jetbrains.kotlin.tooling.core.MutableExtras
 import org.jetbrains.kotlin.tooling.core.mutableExtrasOf
+import javax.inject.Inject

-internal open class GradleKpmLegacyMappedVariant(
+internal abstract class GradleKpmLegacyMappedVariant @Inject constructor(
    internal val compilation: KotlinCompilation<*>,
 ) : GradleKpmVariant {
    override fun toString(): String = "variant mapped to $compilation"
@@ -148,7 +149,7 @@ internal open class GradleKpmLegacyMappedVariant(
        }
 }

-internal class GradleKpmLegacyMappedVariantWithRuntime(private val compilationWithRuntime: KotlinCompilationToRunnableFiles<*>) :
+internal abstract class GradleKpmLegacyMappedVariantWithRuntime @Inject constructor(private val compilationWithRuntime: KotlinCompilationToRunnableFiles<*>) :
    GradleKpmLegacyMappedVariant(compilationWithRuntime),
    GradleKpmVariantWithRuntime {

@@ -177,8 +178,14 @@ internal enum class PublicationRegistrationMode {
 internal fun mapTargetCompilationsToKpmVariants(target: AbstractKotlinTarget, publicationRegistration: PublicationRegistrationMode) {
    target.compilations.all { compilation ->
        val variant = if (compilation is KotlinCompilationToRunnableFiles)
-            GradleKpmLegacyMappedVariantWithRuntime(compilation)
-        else GradleKpmLegacyMappedVariant(compilation)
+            target.project.objects.newInstance(
+                GradleKpmLegacyMappedVariantWithRuntime::class.java,
+                compilation
+            )
+        else target.project.objects.newInstance(
+            GradleKpmLegacyMappedVariant::class.java,
+            compilation
+        )

        val defaultSourceSetFragment = (compilation.defaultSourceSet as FragmentMappedKotlinSourceSet).underlyingFragment
        variant.refines(defaultSourceSetFragment)
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.project.model.*
 import org.jetbrains.kotlin.project.model.utils.variantsContainingFragment
 import javax.inject.Inject

-open class GradleKpmModuleInternal(
+abstract class GradleKpmModuleInternal(
    final override val project: Project,
    final override val moduleClassifier: String?
 ) : GradleKpmModule {
@@ -54,9 +54,10 @@ internal class KotlinMappedNativeCompilationFactory(
        val module = target.project.kpmModules.maybeCreate(name)
        val variant = module.fragments.create(target.name, variantClass)

-        return KotlinNativeCompilation(
+        return target.project.objects.newInstance(
+            KotlinNativeCompilation::class.java,
            target.konanTarget,
-            VariantMappedCompilationDetails(variant, target)
+            VariantMappedCompilationDetails<KotlinCommonOptions>(variant, target)
        )
    }
 }
@@ -5,7 +5,7 @@ import org.jetbrains.kotlin.konan.target.KonanTarget
 import javax.inject.Inject

 // DO NOT EDIT MANUALLY! Generated by org.jetbrains.kotlin.generators.gradle.dsl.KpmNativeVariantCodegenKt
-open class GradleKpmAndroidNativeX64Variant @Inject constructor(
+abstract class GradleKpmAndroidNativeX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -23,12 +23,28 @@ open class GradleKpmAndroidNativeX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.ANDROID_X64, GradleKpmAndroidNativeX64Variant::class.java, ::GradleKpmAndroidNativeX64Variant
-        )
+            KonanTarget.ANDROID_X64,
+            GradleKpmAndroidNativeX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmAndroidNativeX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmAndroidNativeX86Variant @Inject constructor(
+abstract class GradleKpmAndroidNativeX86Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -46,12 +62,28 @@ open class GradleKpmAndroidNativeX86Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.ANDROID_X86, GradleKpmAndroidNativeX86Variant::class.java, ::GradleKpmAndroidNativeX86Variant
-        )
+            KonanTarget.ANDROID_X86,
+            GradleKpmAndroidNativeX86Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmAndroidNativeX86Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmAndroidNativeArm32Variant @Inject constructor(
+abstract class GradleKpmAndroidNativeArm32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -69,12 +101,28 @@ open class GradleKpmAndroidNativeArm32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.ANDROID_ARM32, GradleKpmAndroidNativeArm32Variant::class.java, ::GradleKpmAndroidNativeArm32Variant
-        )
+            KonanTarget.ANDROID_ARM32,
+            GradleKpmAndroidNativeArm32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmAndroidNativeArm32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmAndroidNativeArm64Variant @Inject constructor(
+abstract class GradleKpmAndroidNativeArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -92,12 +140,28 @@ open class GradleKpmAndroidNativeArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.ANDROID_ARM64, GradleKpmAndroidNativeArm64Variant::class.java, ::GradleKpmAndroidNativeArm64Variant
-        )
+            KonanTarget.ANDROID_ARM64,
+            GradleKpmAndroidNativeArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmAndroidNativeArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmIosArm32Variant @Inject constructor(
+abstract class GradleKpmIosArm32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -115,12 +179,28 @@ open class GradleKpmIosArm32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.IOS_ARM32, GradleKpmIosArm32Variant::class.java, ::GradleKpmIosArm32Variant
-        )
+            KonanTarget.IOS_ARM32,
+            GradleKpmIosArm32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmIosArm32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmIosArm64Variant @Inject constructor(
+abstract class GradleKpmIosArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -138,12 +218,28 @@ open class GradleKpmIosArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.IOS_ARM64, GradleKpmIosArm64Variant::class.java, ::GradleKpmIosArm64Variant
-        )
+            KonanTarget.IOS_ARM64,
+            GradleKpmIosArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmIosArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmIosX64Variant @Inject constructor(
+abstract class GradleKpmIosX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -161,12 +257,28 @@ open class GradleKpmIosX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.IOS_X64, GradleKpmIosX64Variant::class.java, ::GradleKpmIosX64Variant
-        )
+            KonanTarget.IOS_X64,
+            GradleKpmIosX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmIosX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmIosSimulatorArm64Variant @Inject constructor(
+abstract class GradleKpmIosSimulatorArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -184,12 +296,28 @@ open class GradleKpmIosSimulatorArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.IOS_SIMULATOR_ARM64, GradleKpmIosSimulatorArm64Variant::class.java, ::GradleKpmIosSimulatorArm64Variant
-        )
+            KonanTarget.IOS_SIMULATOR_ARM64,
+            GradleKpmIosSimulatorArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmIosSimulatorArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWatchosArm32Variant @Inject constructor(
+abstract class GradleKpmWatchosArm32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -207,12 +335,28 @@ open class GradleKpmWatchosArm32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WATCHOS_ARM32, GradleKpmWatchosArm32Variant::class.java, ::GradleKpmWatchosArm32Variant
-        )
+            KonanTarget.WATCHOS_ARM32,
+            GradleKpmWatchosArm32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWatchosArm32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWatchosArm64Variant @Inject constructor(
+abstract class GradleKpmWatchosArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -230,12 +374,28 @@ open class GradleKpmWatchosArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WATCHOS_ARM64, GradleKpmWatchosArm64Variant::class.java, ::GradleKpmWatchosArm64Variant
-        )
+            KonanTarget.WATCHOS_ARM64,
+            GradleKpmWatchosArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWatchosArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWatchosX86Variant @Inject constructor(
+abstract class GradleKpmWatchosX86Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -253,12 +413,28 @@ open class GradleKpmWatchosX86Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WATCHOS_X86, GradleKpmWatchosX86Variant::class.java, ::GradleKpmWatchosX86Variant
-        )
+            KonanTarget.WATCHOS_X86,
+            GradleKpmWatchosX86Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWatchosX86Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWatchosX64Variant @Inject constructor(
+abstract class GradleKpmWatchosX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -276,12 +452,28 @@ open class GradleKpmWatchosX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WATCHOS_X64, GradleKpmWatchosX64Variant::class.java, ::GradleKpmWatchosX64Variant
-        )
+            KonanTarget.WATCHOS_X64,
+            GradleKpmWatchosX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWatchosX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWatchosSimulatorArm64Variant @Inject constructor(
+abstract class GradleKpmWatchosSimulatorArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -299,12 +491,28 @@ open class GradleKpmWatchosSimulatorArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WATCHOS_SIMULATOR_ARM64, GradleKpmWatchosSimulatorArm64Variant::class.java, ::GradleKpmWatchosSimulatorArm64Variant
-        )
+            KonanTarget.WATCHOS_SIMULATOR_ARM64,
+            GradleKpmWatchosSimulatorArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWatchosSimulatorArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmTvosArm64Variant @Inject constructor(
+abstract class GradleKpmTvosArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -322,12 +530,28 @@ open class GradleKpmTvosArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.TVOS_ARM64, GradleKpmTvosArm64Variant::class.java, ::GradleKpmTvosArm64Variant
-        )
+            KonanTarget.TVOS_ARM64,
+            GradleKpmTvosArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmTvosArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmTvosX64Variant @Inject constructor(
+abstract class GradleKpmTvosX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -345,12 +569,28 @@ open class GradleKpmTvosX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.TVOS_X64, GradleKpmTvosX64Variant::class.java, ::GradleKpmTvosX64Variant
-        )
+            KonanTarget.TVOS_X64,
+            GradleKpmTvosX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmTvosX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmTvosSimulatorArm64Variant @Inject constructor(
+abstract class GradleKpmTvosSimulatorArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -368,12 +608,28 @@ open class GradleKpmTvosSimulatorArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.TVOS_SIMULATOR_ARM64, GradleKpmTvosSimulatorArm64Variant::class.java, ::GradleKpmTvosSimulatorArm64Variant
-        )
+            KonanTarget.TVOS_SIMULATOR_ARM64,
+            GradleKpmTvosSimulatorArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmTvosSimulatorArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmLinuxX64Variant @Inject constructor(
+abstract class GradleKpmLinuxX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -391,12 +647,28 @@ open class GradleKpmLinuxX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.LINUX_X64, GradleKpmLinuxX64Variant::class.java, ::GradleKpmLinuxX64Variant
-        )
+            KonanTarget.LINUX_X64,
+            GradleKpmLinuxX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmLinuxX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmMingwX86Variant @Inject constructor(
+abstract class GradleKpmMingwX86Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -414,12 +686,28 @@ open class GradleKpmMingwX86Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.MINGW_X86, GradleKpmMingwX86Variant::class.java, ::GradleKpmMingwX86Variant
-        )
+            KonanTarget.MINGW_X86,
+            GradleKpmMingwX86Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmMingwX86Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmMingwX64Variant @Inject constructor(
+abstract class GradleKpmMingwX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -437,12 +725,28 @@ open class GradleKpmMingwX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.MINGW_X64, GradleKpmMingwX64Variant::class.java, ::GradleKpmMingwX64Variant
-        )
+            KonanTarget.MINGW_X64,
+            GradleKpmMingwX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmMingwX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmMacosX64Variant @Inject constructor(
+abstract class GradleKpmMacosX64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -460,12 +764,28 @@ open class GradleKpmMacosX64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.MACOS_X64, GradleKpmMacosX64Variant::class.java, ::GradleKpmMacosX64Variant
-        )
+            KonanTarget.MACOS_X64,
+            GradleKpmMacosX64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmMacosX64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmMacosArm64Variant @Inject constructor(
+abstract class GradleKpmMacosArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -483,12 +803,28 @@ open class GradleKpmMacosArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.MACOS_ARM64, GradleKpmMacosArm64Variant::class.java, ::GradleKpmMacosArm64Variant
-        )
+            KonanTarget.MACOS_ARM64,
+            GradleKpmMacosArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmMacosArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmLinuxArm64Variant @Inject constructor(
+abstract class GradleKpmLinuxArm64Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -506,12 +842,28 @@ open class GradleKpmLinuxArm64Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.LINUX_ARM64, GradleKpmLinuxArm64Variant::class.java, ::GradleKpmLinuxArm64Variant
-        )
+            KonanTarget.LINUX_ARM64,
+            GradleKpmLinuxArm64Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmLinuxArm64Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmLinuxArm32HfpVariant @Inject constructor(
+abstract class GradleKpmLinuxArm32HfpVariant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -529,12 +881,28 @@ open class GradleKpmLinuxArm32HfpVariant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.LINUX_ARM32_HFP, GradleKpmLinuxArm32HfpVariant::class.java, ::GradleKpmLinuxArm32HfpVariant
-        )
+            KonanTarget.LINUX_ARM32_HFP,
+            GradleKpmLinuxArm32HfpVariant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmLinuxArm32HfpVariant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmLinuxMips32Variant @Inject constructor(
+abstract class GradleKpmLinuxMips32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -552,12 +920,28 @@ open class GradleKpmLinuxMips32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.LINUX_MIPS32, GradleKpmLinuxMips32Variant::class.java, ::GradleKpmLinuxMips32Variant
-        )
+            KonanTarget.LINUX_MIPS32,
+            GradleKpmLinuxMips32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmLinuxMips32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmLinuxMipsel32Variant @Inject constructor(
+abstract class GradleKpmLinuxMipsel32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -575,12 +959,28 @@ open class GradleKpmLinuxMipsel32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.LINUX_MIPSEL32, GradleKpmLinuxMipsel32Variant::class.java, ::GradleKpmLinuxMipsel32Variant
-        )
+            KonanTarget.LINUX_MIPSEL32,
+            GradleKpmLinuxMipsel32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmLinuxMipsel32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

-open class GradleKpmWasm32Variant @Inject constructor(
+abstract class GradleKpmWasm32Variant @Inject constructor(
    containingModule: GradleKpmModule,
    fragmentName: String,
    dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
@@ -598,8 +998,24 @@ open class GradleKpmWasm32Variant @Inject constructor(
 ) {
    companion object {
        val constructor = GradleKpmNativeVariantConstructor(
-            KonanTarget.WASM32, GradleKpmWasm32Variant::class.java, ::GradleKpmWasm32Variant
-        )
+            KonanTarget.WASM32,
+            GradleKpmWasm32Variant::class.java
+        ) { containingModule: GradleKpmModule,
+            fragmentName: String,
+            dependencyConfigurations: GradleKpmFragmentDependencyConfigurations,
+            compileDependencyConfiguration: Configuration,
+            apiElementsConfiguration: Configuration,
+            hostSpecificMetadataElementsConfiguration: Configuration? ->
+            containingModule.project.objects.newInstance(
+                GradleKpmWasm32Variant::class.java,
+                containingModule,
+                fragmentName,
+                dependencyConfigurations,
+                compileDependencyConfiguration,
+                apiElementsConfiguration,
+                hostSpecificMetadataElementsConfiguration
+            )
+        }
    }
 }

@@ -5,11 +5,10 @@

 package org.jetbrains.kotlin.gradle.plugin.sources

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.InvalidUserCodeException
 import org.gradle.api.Project
 import org.gradle.api.file.SourceDirectorySet
-import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.build.DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
@@ -21,10 +20,11 @@ import org.jetbrains.kotlin.tooling.core.closure
 import org.jetbrains.kotlin.tooling.core.withClosure
 import java.io.File
 import java.util.*
+import javax.inject.Inject

 const val METADATA_CONFIGURATION_NAME_SUFFIX = "DependenciesMetadata"

-class DefaultKotlinSourceSet(
+abstract class DefaultKotlinSourceSet @Inject constructor(
    private val project: Project,
    val displayName: String
 ) : KotlinSourceSet {
@@ -65,11 +65,15 @@ class DefaultKotlinSourceSet(

    override val resources: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name resources")

-    override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet =
-        kotlin.apply { ConfigureUtil.configure(configureClosure, this) }
+    override fun kotlin(configure: SourceDirectorySet.() -> Unit): SourceDirectorySet = kotlin.apply {
+        configure(this)
+    }

-    override fun languageSettings(configureClosure: Closure<Any?>): LanguageSettingsBuilder = languageSettings.apply {
-        ConfigureUtil.configure(configureClosure, this)
+    override fun kotlin(configure: Action<SourceDirectorySet>): SourceDirectorySet =
+        kotlin { configure.execute(this) }
+
+    override fun languageSettings(configure: Action<LanguageSettingsBuilder>): LanguageSettingsBuilder = languageSettings {
+        configure.execute(this)
    }

    override fun languageSettings(configure: LanguageSettingsBuilder.() -> Unit): LanguageSettingsBuilder =
@@ -80,8 +84,8 @@ class DefaultKotlinSourceSet(
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit): Unit =
        DefaultKotlinDependencyHandler(this, project).run(configure)

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        dependencies f@{ ConfigureUtil.configure(configureClosure, this@f) }
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        dependencies { configure.execute(this) }

    override fun dependsOn(other: KotlinSourceSet) {
        dependsOnSourceSetsImpl.add(other)
@@ -253,7 +257,7 @@ internal fun createDefaultSourceDirectorySet(project: Project, name: String?): S
    project.objects.sourceDirectorySet(name!!, name)


-val KotlinSourceSet.dependsOnClosure get() = closure { it.dependsOn }
+val KotlinSourceSet.dependsOnClosure get() = closure<KotlinSourceSet> { it.dependsOn }

 val KotlinSourceSet.withDependsOnClosure get() = withClosure { it.dependsOn }

@@ -160,7 +160,6 @@ internal class DefaultKotlinSourceSetFactory(
            }
    }

-    override fun doCreateSourceSet(name: String): DefaultKotlinSourceSet {
-        return DefaultKotlinSourceSet(project, name)
-    }
+    override fun doCreateSourceSet(name: String): DefaultKotlinSourceSet =
+        project.objects.newInstance(DefaultKotlinSourceSet::class.java, project, name)
 }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin.sources.kpm

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.InvalidUserDataException
 import org.gradle.api.Project
 import org.gradle.api.file.SourceDirectorySet
@@ -16,8 +16,9 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
 import org.jetbrains.kotlin.gradle.plugin.sources.createDefaultSourceDirectorySet
+import javax.inject.Inject

-class FragmentMappedKotlinSourceSet(
+abstract class FragmentMappedKotlinSourceSet @Inject constructor(
    private val sourceSetName: String,
    private val project: Project,
    internal val underlyingFragment: GradleKpmFragment
@@ -46,11 +47,15 @@ class FragmentMappedKotlinSourceSet(

    override val resources: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name resources")

-    override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet =
-        kotlin.apply { project.configure(this, configureClosure) }
+    override fun kotlin(configure: SourceDirectorySet.() -> Unit): SourceDirectorySet = kotlin.apply {
+        configure(this)
+    }

-    override fun languageSettings(configureClosure: Closure<Any?>): LanguageSettingsBuilder = languageSettings.apply {
-        project.configure(this, configureClosure)
+    override fun kotlin(configure: Action<SourceDirectorySet>): SourceDirectorySet =
+        kotlin { configure.execute(this) }
+
+    override fun languageSettings(configure: Action<LanguageSettingsBuilder>): LanguageSettingsBuilder = languageSettings.apply {
+        configure.execute(this)
    }

    override fun languageSettings(configure: LanguageSettingsBuilder.() -> Unit): LanguageSettingsBuilder =
@@ -61,8 +66,8 @@ class FragmentMappedKotlinSourceSet(
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit): Unit =
        underlyingFragment.dependencies(configure)

-    override fun dependencies(configureClosure: Closure<Any?>) =
-        underlyingFragment.dependencies(configureClosure)
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) =
+        underlyingFragment.dependencies(configure)

    override fun dependsOn(other: KotlinSourceSet) {
        if (other !is FragmentMappedKotlinSourceSet) {
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.gradle.plugin.sources.kpm

 import org.gradle.api.NamedDomainObjectFactory
 import org.gradle.api.Project
-import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.kpmModules

@@ -20,6 +19,6 @@ class FragmentMappedKotlinSourceSetFactory constructor(private val project: Proj
        val fragment = project.kpmModules.maybeCreate(location.moduleName).fragments.maybeCreate(location.fragmentName)

        /** TODO setup JS-specific attributes similar to [org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSetFactory]*/
-        return FragmentMappedKotlinSourceSet(name, project, fragment)
+        return project.objects.newInstance(FragmentMappedKotlinSourceSet::class.java, name, project, fragment)
    }
 }
@@ -20,16 +20,15 @@ import org.jetbrains.kotlin.gradle.targets.js.ir.JsBinary
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsBinaryContainer
 import org.jetbrains.kotlin.gradle.targets.js.npm.PackageJson
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
+import javax.inject.Inject

-open class KotlinJsCompilation internal constructor(
+abstract class KotlinJsCompilation @Inject internal constructor(
    compilationDetails: JsCompilationDetails
 ) : AbstractKotlinCompilationToRunnableFiles<KotlinJsOptions>(compilationDetails),
    KotlinCompilationWithResources<KotlinJsOptions> {

    final override val target: KotlinTarget get() = super.target

-    constructor(target: KotlinTarget, name: String) : this(JsCompilationDetails(target, name))
-
    private val kotlinProperties = PropertiesProvider(target.project)

    internal open val externalsOutputFormat: ExternalsOutputFormat
@@ -18,5 +18,5 @@ class KotlinJsCompilationFactory(
        get() = KotlinJsCompilation::class.java

    override fun create(name: String): KotlinJsCompilation =
-        KotlinJsCompilation(target, name)
+        target.project.objects.newInstance(KotlinJsCompilation::class.java, JsCompilationDetails(target, name))
 }
@@ -10,8 +10,9 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.JsIrCompilationDetails
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat
+import javax.inject.Inject

-class KotlinJsIrCompilation(
+abstract class KotlinJsIrCompilation @Inject constructor(
    target: KotlinTarget,
    name: String
 ) : KotlinJsCompilation(JsIrCompilationDetails(target, name)) {
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.gradle.targets.js.ir

 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCompilationFactory
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTarget

 class KotlinJsIrCompilationFactory(
@@ -18,5 +17,5 @@ class KotlinJsIrCompilationFactory(
        get() = KotlinJsIrCompilation::class.java

    override fun create(name: String): KotlinJsIrCompilation =
-        KotlinJsIrCompilation(target, name)
+        target.project.objects.newInstance(KotlinJsIrCompilation::class.java, target, name)
 }
@@ -16,8 +16,9 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptionsImpl
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.getJavaTaskProvider
 import org.jetbrains.kotlin.gradle.plugin.getTestedVariantData
+import javax.inject.Inject

-class KotlinJvmAndroidCompilation(
+abstract class KotlinJvmAndroidCompilation @Inject constructor(
    compilationDetails: AndroidCompilationDetails
 ) : AbstractKotlinCompilationToRunnableFiles<KotlinJvmOptions>(compilationDetails) {

@@ -34,6 +35,6 @@ class KotlinJvmAndroidCompilation(
    override val compileKotlinTaskProvider: TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>
        get() = super.compileKotlinTaskProvider as TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>

-    val compileJavaTaskProvider: TaskProvider<out JavaCompile>?
+    val compileJavaTaskProvider: TaskProvider<out JavaCompile>
        get() = androidVariant.getJavaTaskProvider()
 }
@@ -19,7 +19,7 @@ class KotlinJvmAndroidCompilationFactory(
    override fun create(name: String): KotlinJvmAndroidCompilation {
        lateinit var result: KotlinJvmAndroidCompilation
        val details = AndroidCompilationDetails(target, name) { result }
-        result = KotlinJvmAndroidCompilation(details)
+        result = project.objects.newInstance(KotlinJvmAndroidCompilation::class.java, details)
        return result
    }
 }
@@ -13,8 +13,9 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
 import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.variantImplementationFactory
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import javax.inject.Inject

-open class KotlinJvmCompilation(
+abstract class KotlinJvmCompilation @Inject constructor(
    compilationDetails: CompilationDetailsWithRuntime<KotlinJvmOptions>,
 ) : AbstractKotlinCompilationToRunnableFiles<KotlinJvmOptions>(compilationDetails), KotlinCompilationWithResources<KotlinJvmOptions> {
    override val target: KotlinJvmTarget get() = compilationDetails.target as KotlinJvmTarget
@@ -16,7 +16,8 @@ open class KotlinJvmCompilationFactory(
        get() = KotlinJvmCompilation::class.java

    override fun create(name: String): KotlinJvmCompilation =
-        KotlinJvmCompilation(
+        target.project.objects.newInstance(
+            KotlinJvmCompilation::class.java,
            DefaultCompilationDetailsWithRuntime(target, name) { KotlinJvmOptionsImpl() }
        )
 }
@@ -13,8 +13,9 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.utils.named
+import javax.inject.Inject

-class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions>(
+abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions> @Inject constructor(
    target: KotlinWithJavaTarget<KotlinOptionsType>,
    name: String,
    kotlinOptions: KotlinOptionsType
@@ -19,8 +19,12 @@ class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions>(
        @Suppress("UNCHECKED_CAST")
        get() = KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType>>

-    override fun create(name: String): KotlinWithJavaCompilation<KotlinOptionsType> {
-        val result = KotlinWithJavaCompilation(target, name, kotlinOptionsFactory())
-        return result
-    }
+    @Suppress("UNCHECKED_CAST")
+    override fun create(name: String): KotlinWithJavaCompilation<KotlinOptionsType> =
+        project.objects.newInstance(
+            KotlinWithJavaCompilation::class.java,
+            target,
+            name,
+            kotlinOptionsFactory()
+        ) as KotlinWithJavaCompilation<KotlinOptionsType>
 }
@@ -54,9 +54,17 @@ internal class GradleKpmMetadataTargetConfigurator(private val metadataTargetCon
                    isNative -> {
                        val konanTargets =
                            mainModule.variantsContainingFragment(fragment).map { (it as GradleKpmNativeVariantInternal).konanTarget }
-                        KotlinSharedNativeCompilation(konanTargets, compilationDetails as CompilationDetails<KotlinCommonOptions>)
+                        target.project.objects.newInstance(
+                            KotlinSharedNativeCompilation::class.java,
+                            konanTargets,
+                            compilationDetails as CompilationDetails<KotlinCommonOptions>
+                        )
                    }
-                    else -> KotlinCommonCompilation(compilationDetails as CompilationDetails<KotlinMultiplatformCommonOptions>)
+                    else -> target.project.objects
+                        .newInstance(
+                            KotlinCommonCompilation::class.java,
+                            (compilationDetails as CompilationDetails<KotlinMultiplatformCommonOptions>)
+                        )
                }

                target.compilations.add(compilation)
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import java.io.File
 import java.util.concurrent.Callable
+import javax.inject.Inject

 internal class NativeCompileOptions(languageSettingsProvider: () -> LanguageSettingsBuilder) : KotlinCommonOptions {
    private val languageSettings: LanguageSettingsBuilder by lazy(languageSettingsProvider)
@@ -86,7 +87,7 @@ internal fun addSourcesToKotlinNativeCompileTask(

 }

-class KotlinNativeCompilation(
+abstract class KotlinNativeCompilation @Inject constructor(
    konanTarget: KonanTarget,
    details: CompilationDetails<KotlinCommonOptions>
 ) : AbstractKotlinNativeCompilation(konanTarget, details),
@@ -111,7 +112,7 @@ class KotlinNativeCompilation(
        get() = lowerCamelCaseName(target.disambiguationClassifier, compilationPurpose, "binaries")
 }

-class KotlinSharedNativeCompilation(
+abstract class KotlinSharedNativeCompilation @Inject constructor(
    val konanTargets: List<KonanTarget>,
    compilationDetails: CompilationDetails<KotlinCommonOptions>
 ) : KotlinNativeFragmentMetadataCompilationData,
@@ -6,7 +6,6 @@
@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.jetbrains.kotlin.konan.target.HostManager
 import org.jetbrains.kotlin.konan.target.KonanTarget

 open class KotlinNativeCompilationFactory(
@@ -22,7 +21,8 @@ open class KotlinNativeCompilationFactory(
    // Note: such validation should be done in the whenEvaluate block because
        // a user can change args during project configuration.

-        KotlinNativeCompilation(
+        target.project.objects.newInstance(
+            KotlinNativeCompilation::class.java,
            target.konanTarget,
            NativeCompilationDetails(target, name) { NativeCompileOptions { defaultSourceSet.languageSettings } }
        )
@@ -36,7 +36,8 @@ class KotlinSharedNativeCompilationFactory(
        get() = KotlinSharedNativeCompilation::class.java

    override fun create(name: String): KotlinSharedNativeCompilation =
-        KotlinSharedNativeCompilation(
+        target.project.objects.newInstance(
+            KotlinSharedNativeCompilation::class.java,
            konanTargets,
            SharedNativeCompilationDetails(target, name) { NativeCompileOptions { defaultSourceSet.languageSettings } }
        )
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.gradle.plugin.sources

-import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.attributes.AttributeContainer
 import org.gradle.api.file.FileCollection
@@ -252,10 +252,11 @@ class MockKotlinSourceSet(private val name: String) : KotlinSourceSet {
    //region Not implemented
    override val kotlin: SourceDirectorySet get() = throw UnsupportedOperationException()

-    override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet = throw UnsupportedOperationException()
+    override fun kotlin(configure: SourceDirectorySet.() -> Unit): SourceDirectorySet = throw UnsupportedOperationException()
+    override fun kotlin(configure: Action<SourceDirectorySet>): SourceDirectorySet = throw UnsupportedOperationException()
    override val resources: SourceDirectorySet get() = throw UnsupportedOperationException()
    override val languageSettings: LanguageSettingsBuilder get() = throw UnsupportedOperationException()
-    override fun languageSettings(configureClosure: Closure<Any?>): LanguageSettingsBuilder = languageSettings
+    override fun languageSettings(configure: Action<LanguageSettingsBuilder>): LanguageSettingsBuilder = languageSettings
    override fun languageSettings(configure: LanguageSettingsBuilder.() -> Unit): LanguageSettingsBuilder = languageSettings
    override val apiMetadataConfigurationName: String get() = throw UnsupportedOperationException()
    override val implementationMetadataConfigurationName: String get() = throw UnsupportedOperationException()
@@ -263,7 +264,7 @@ class MockKotlinSourceSet(private val name: String) : KotlinSourceSet {
    override val runtimeOnlyMetadataConfigurationName: String get() = throw UnsupportedOperationException()
    override val customSourceFilesExtensions: Iterable<String> get() = throw UnsupportedOperationException()
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit) = throw UnsupportedOperationException()
-    override fun dependencies(configureClosure: Closure<Any?>) = throw UnsupportedOperationException()
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) = throw UnsupportedOperationException()
    override val apiConfigurationName: String get() = throw UnsupportedOperationException()
    override val implementationConfigurationName: String get() = throw UnsupportedOperationException()
    override val compileOnlyConfigurationName: String get() = throw UnsupportedOperationException()
@@ -307,12 +308,12 @@ class MockKotlinCompilation(
    override val compileKotlinTaskProvider: TaskProvider<out KotlinCompile<KotlinCommonOptions>> get() = throw UnsupportedOperationException()
    override fun getAttributes(): AttributeContainer = throw UnsupportedOperationException()
    override fun dependencies(configure: KotlinDependencyHandler.() -> Unit) = throw UnsupportedOperationException()
-    override fun dependencies(configureClosure: Closure<Any?>) = throw UnsupportedOperationException()
+    override fun dependencies(configure: Action<KotlinDependencyHandler>) = throw UnsupportedOperationException()
    override val apiConfigurationName: String get() = throw UnsupportedOperationException()
    override val implementationConfigurationName: String get() = throw UnsupportedOperationException()
    override val compileOnlyConfigurationName: String get() = throw UnsupportedOperationException()
    override val runtimeOnlyConfigurationName: String get() = throw UnsupportedOperationException()
-    override fun defaultSourceSet(configure: Closure<*>) = throw UnsupportedOperationException()
+    override fun defaultSourceSet(configure: Action<KotlinSourceSet>) = throw UnsupportedOperationException()
    override val compileDependencyConfigurationName: String get() = throw UnsupportedOperationException()
    override var compileDependencyFiles: FileCollection
        get() = throw UnsupportedOperationException()
@@ -322,9 +323,9 @@ class MockKotlinCompilation(
    override val compileKotlinTask: KotlinCompile<KotlinCommonOptions> get() = throw UnsupportedOperationException()
    override val kotlinOptions: KotlinCommonOptions get() = throw UnsupportedOperationException()
    override fun kotlinOptions(configure: KotlinCommonOptions.() -> Unit) = throw UnsupportedOperationException()
-    override fun kotlinOptions(configure: Closure<*>) = throw UnsupportedOperationException()
+    override fun kotlinOptions(configure: Action<KotlinCommonOptions>) = throw UnsupportedOperationException()
    override fun attributes(configure: AttributeContainer.() -> Unit) = throw UnsupportedOperationException()
-    override fun attributes(configure: Closure<*>) = throw UnsupportedOperationException()
+    override fun attributes(configure: Action<AttributeContainer>) = throw UnsupportedOperationException()
    override val compileAllTaskName: String get() = throw UnsupportedOperationException()
    override val moduleName: String get() = throw UnsupportedOperationException()
    override fun toString(): String = "compilation '${name}'"