[Gradle][MPP] Ensure presence of .defaultSourceSet when creating kotlinCompilations

This will finally make calls to KotlinCompilation.defaultSourceSet or sourceSets.getByName(compilation.defaultSourceSetName) safe. This will also enable removing the `kotlinSourceSetsIncludingDefault` pitfall ^KT-52726 Verification Pending
2022-09-09 13:16:07 +02:00
parent 5f085f0448
commit f4eba62f8c
30 changed files with 217 additions and 198 deletions
@@ -33,7 +33,8 @@ interface KotlinCompilation<out T : KotlinCommonOptions> : Named, HasAttributes,

    val allKotlinSourceSets: Set<KotlinSourceSet>

-    val defaultSourceSetName: String
+    @Deprecated("Use defaultSourceSet.name instead", ReplaceWith("defaultSourceSet.name"))
+    val defaultSourceSetName: String get() = defaultSourceSet.name

    val defaultSourceSet: KotlinSourceSet

@@ -8,21 +8,20 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.sources.internal
+import org.jetbrains.kotlin.gradle.utils.MutableObservableSet
 import org.jetbrains.kotlin.gradle.utils.MutableObservableSetImpl
 import org.jetbrains.kotlin.gradle.utils.ObservableSet

-abstract class AbstractCompilationDetails<T : KotlinCommonOptions> : CompilationDetails<T> {
-    private val directlyIncludedKotlinSourceSetsImpl: MutableObservableSetImpl<KotlinSourceSet> by lazy {
-        MutableObservableSetImpl(defaultSourceSet)
-    }
+abstract class AbstractCompilationDetails<T : KotlinCommonOptions>(
+    final override val defaultSourceSet: KotlinSourceSet
+) : CompilationDetails<T> {
+    private val directlyIncludedKotlinSourceSetsImpl: MutableObservableSet<KotlinSourceSet> = MutableObservableSetImpl(defaultSourceSet)

    final override val directlyIncludedKotlinSourceSets: ObservableSet<KotlinSourceSet>
        get() = directlyIncludedKotlinSourceSetsImpl

-    private val allKotlinSourceSetsImpl: MutableObservableSetImpl<KotlinSourceSet> by lazy {
-        MutableObservableSetImpl<KotlinSourceSet>().also { set ->
-            defaultSourceSet.internal.withDependsOnClosure.forAll(set::add)
-        }
+    private val allKotlinSourceSetsImpl: MutableObservableSet<KotlinSourceSet> = MutableObservableSetImpl<KotlinSourceSet>().also { set ->
+        defaultSourceSet.internal.withDependsOnClosure.forAll(set::add)
    }

    final override val allKotlinSourceSets: ObservableSet<KotlinSourceSet>
@@ -13,7 +13,6 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
-import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
 import org.jetbrains.kotlin.gradle.tasks.locateTask
@@ -60,7 +59,9 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(

    final override var compileDependencyFiles: FileCollection
        get() = compilationDetails.compileDependencyFilesHolder.dependencyFiles
-        set(value) { compilationDetails.compileDependencyFilesHolder.dependencyFiles = value }
+        set(value) {
+            compilationDetails.compileDependencyFilesHolder.dependencyFiles = value
+        }

    final override val kotlinSourceSets: ObservableSet<KotlinSourceSet>
        get() = compilationDetails.directlyIncludedKotlinSourceSets
@@ -68,7 +69,7 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(
    override val allKotlinSourceSets: ObservableSet<KotlinSourceSet>
        get() = compilationDetails.allKotlinSourceSets

-    final override val defaultSourceSetName: String get() = compilationDetails.defaultSourceSetName
+    override val defaultSourceSet: KotlinSourceSet get() = compilationDetails.defaultSourceSet

    final override val compilationName: String get() = compilationDetails.compilationData.compilationPurpose

@@ -87,9 +88,6 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(

    override fun getAttributes(): AttributeContainer = attributeContainer

-    override val defaultSourceSet: KotlinSourceSet
-        get() = target.project.kotlinExtension.sourceSets.getByName(defaultSourceSetName)
-
    override fun defaultSourceSet(configure: KotlinSourceSet.() -> Unit) = defaultSourceSet.configure()

    override fun source(sourceSet: KotlinSourceSet) {
@@ -5,6 +5,7 @@

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

+import com.android.build.gradle.api.BaseVariant
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.UnknownTaskException
@@ -19,12 +20,8 @@ import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal.KotlinCompilationsModuleGroups
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.*
-import org.jetbrains.kotlin.gradle.plugin.sources.android.kotlinAndroidSourceSetLayout
-import org.jetbrains.kotlin.gradle.plugin.sources.defaultSourceSetLanguageSettingsChecker
-import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
+import org.jetbrains.kotlin.gradle.plugin.sources.*
 import org.jetbrains.kotlin.gradle.plugin.sources.kpm.FragmentMappedKotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.sources.withDependsOnClosure
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
@@ -51,15 +48,17 @@ interface CompilationDetails<T : KotlinCommonOptions> {
    fun source(sourceSet: KotlinSourceSet)

    val directlyIncludedKotlinSourceSets: ObservableSet<KotlinSourceSet>
+
    val allKotlinSourceSets: ObservableSet<KotlinSourceSet>
-    val defaultSourceSetName: String
+
+    val defaultSourceSet: KotlinSourceSet
+
+    @Deprecated("Use defaultSourceSet.name instead", ReplaceWith("defaultSourceSet.name"), level = DeprecationLevel.WARNING)
+    val defaultSourceSetName: String get() = defaultSourceSet.name

    @Suppress("UNCHECKED_CAST")
    val compilation: KotlinCompilation<T>
        get() = target.compilations.getByName(compilationData.compilationPurpose) as KotlinCompilation<T>
-
-    val defaultSourceSet: KotlinSourceSet
-        get() = target.project.kotlinExtension.sourceSets.getByName(defaultSourceSetName)
 }

 interface CompilationDetailsWithRuntime<T : KotlinCommonOptions> : CompilationDetails<T> {
@@ -72,10 +71,9 @@ internal val CompilationDetails<*>.associateCompilationsClosure: Iterable<Compil
 open class DefaultCompilationDetails<T : KotlinCommonOptions>(
    final override val target: KotlinTarget,
    final override val compilationPurpose: String,
-    createKotlinOptions: DefaultCompilationDetails<*>.() -> T
-) : AbstractCompilationDetails<T>(), KotlinCompilationData<T> {
-
-    override val kotlinOptions: T by lazy { createKotlinOptions() }
+    defaultSourceSet: KotlinSourceSet,
+    override val kotlinOptions: T
+) : AbstractCompilationDetails<T>(defaultSourceSet), KotlinCompilationData<T> {

    final override val project: Project
        get() = target.project
@@ -105,16 +103,6 @@ open class DefaultCompilationDetails<T : KotlinCommonOptions>(
        )
    )

-    override val defaultSourceSetName: String
-        get() = lowerCamelCaseName(
-            target.disambiguationClassifier.takeIf { target !is KotlinMetadataTarget },
-            when {
-                isMainCompilationData() && target is KotlinMetadataTarget ->
-                    KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME // corner case: main compilation of the metadata target compiles commonMain
-                else -> compilationPurpose
-            }
-        )
-
    override val compilationClassifier: String?
        get() = target.disambiguationClassifier

@@ -141,7 +129,7 @@ open class DefaultCompilationDetails<T : KotlinCommonOptions>(
    )

    override val languageSettings: LanguageSettings
-        get() = project.kotlinExtension.sourceSets.getByName(defaultSourceSetName).languageSettings
+        get() = defaultSourceSet.languageSettings

    override val platformType: KotlinPlatformType
        get() = target.platformType
@@ -325,8 +313,11 @@ open class DefaultCompilationDetails<T : KotlinCommonOptions>(
 open class DefaultCompilationDetailsWithRuntime<T : KotlinCommonOptions>(
    target: KotlinTarget,
    compilationPurpose: String,
-    createKotlinOptions: DefaultCompilationDetails<*>.() -> T
-) : DefaultCompilationDetails<T>(target, compilationPurpose, createKotlinOptions), CompilationDetailsWithRuntime<T> {
+    defaultSourceSet: KotlinSourceSet,
+    kotlinOptions: T
+) : DefaultCompilationDetails<T>(
+    target, compilationPurpose, defaultSourceSet, kotlinOptions
+), CompilationDetailsWithRuntime<T> {
    override val runtimeDependencyFilesHolder: GradleKpmDependencyFilesHolder = project.newDependencyFilesHolder(
        lowerCamelCaseName(
            target.disambiguationClassifier,
@@ -339,11 +330,13 @@ open class DefaultCompilationDetailsWithRuntime<T : KotlinCommonOptions>(
 open class NativeCompilationDetails(
    target: KotlinTarget,
    compilationPurpose: String,
-    createKotlinOptions: DefaultCompilationDetails<*>.() -> KotlinCommonOptions
+    defaultSourceSet: KotlinSourceSet,
+    kotlinOptions: KotlinCommonOptions
 ) : DefaultCompilationDetails<KotlinCommonOptions>(
    target,
    compilationPurpose,
-    createKotlinOptions
+    defaultSourceSet,
+    kotlinOptions
 ) {
    override val compileDependencyFilesHolder: GradleKpmDependencyFilesHolder = project.newDependencyFilesHolder(
        lowerCamelCaseName(
@@ -373,12 +366,14 @@ open class NativeCompilationDetails(
 internal open class SharedNativeCompilationDetails(
    target: KotlinTarget,
    compilationPurpose: String,
-    createKotlinOptions: DefaultCompilationDetails<*>.() -> KotlinCommonOptions
+    defaultSourceSet: KotlinSourceSet,
+    kotlinOptions: KotlinCommonOptions
 ) :
    DefaultCompilationDetails<KotlinCommonOptions>(
        target,
        compilationPurpose,
-        createKotlinOptions
+        defaultSourceSet,
+        kotlinOptions
    ) {

    override val friendArtifacts: FileCollection
@@ -399,8 +394,9 @@ internal open class SharedNativeCompilationDetails(

 internal open class MetadataMappedCompilationDetails<T : KotlinCommonOptions>(
    override val target: KotlinMetadataTarget,
+    defaultSourceSet: KotlinSourceSet,
    final override val compilationData: AbstractKotlinFragmentMetadataCompilationData<T>
-) : AbstractCompilationDetails<T>() {
+) : AbstractCompilationDetails<T>(defaultSourceSet) {
    override val compileDependencyFilesHolder: GradleKpmDependencyFilesHolder =
        GradleKpmDependencyFilesHolder.ofMetadataCompilationDependencies(compilationData)

@@ -417,28 +413,18 @@ internal open class MetadataMappedCompilationDetails<T : KotlinCommonOptions>(
    override fun whenSourceSetAdded(sourceSet: KotlinSourceSet) {
        throw UnsupportedOperationException("metadata compilations have predefined sources")
    }
-
-    private val underlyingSourceSet: FragmentMappedKotlinSourceSet
-        get() = target.project.kotlinExtension.sourceSets.withType<FragmentMappedKotlinSourceSet>().single {
-            it.underlyingFragment == compilationData.fragment
-        }
-
-    override val defaultSourceSetName: String
-        get() = underlyingSourceSet.name
 }

 internal open class VariantMappedCompilationDetails<T : KotlinCommonOptions>(
    open val variant: GradleKpmVariantInternal,
-    override val target: KotlinTarget
-) : AbstractCompilationDetails<T>() {
+    override val target: KotlinTarget,
+    defaultSourceSet: FragmentMappedKotlinSourceSet,
+) : AbstractCompilationDetails<T>(defaultSourceSet) {

    @Suppress("UNCHECKED_CAST")
    override val compilationData: KotlinCompilationData<T>
        get() = variant.compilationData as KotlinCompilationData<T>

-    override val defaultSourceSetName: String
-        get() = variant.unambiguousNameInProject
-
    override fun whenSourceSetAdded(sourceSet: KotlinSourceSet) {
        compilation.defaultSourceSet.dependsOn(sourceSet)
    }
@@ -464,8 +450,9 @@ internal open class VariantMappedCompilationDetails<T : KotlinCommonOptions>(

 internal open class VariantMappedCompilationDetailsWithRuntime<T : KotlinCommonOptions>(
    override val variant: GradleKpmVariantWithRuntimeInternal,
-    target: KotlinTarget
-) : VariantMappedCompilationDetails<T>(variant, target),
+    target: KotlinTarget,
+    defaultSourceSet: FragmentMappedKotlinSourceSet
+) : VariantMappedCompilationDetails<T>(variant, target, defaultSourceSet),
    CompilationDetailsWithRuntime<T> {
    override val runtimeDependencyFilesHolder: GradleKpmDependencyFilesHolder
        get() = GradleKpmDependencyFilesHolder.ofVariantRuntimeDependencies(variant)
@@ -474,8 +461,9 @@ internal open class VariantMappedCompilationDetailsWithRuntime<T : KotlinCommonO
 internal class WithJavaCompilationDetails<T : KotlinCommonOptions>(
    target: KotlinTarget,
    compilationPurpose: String,
-    createKotlinOptions: DefaultCompilationDetails<*>.() -> T
-) : DefaultCompilationDetailsWithRuntime<T>(target, compilationPurpose, createKotlinOptions) {
+    defaultSourceSet: KotlinSourceSet,
+    kotlinOptions: T
+) : DefaultCompilationDetailsWithRuntime<T>(target, compilationPurpose, defaultSourceSet, kotlinOptions) {
    override val compilation: KotlinWithJavaCompilation<T>
        get() = super.compilation as KotlinWithJavaCompilation<T>

@@ -506,24 +494,21 @@ internal class WithJavaCompilationDetails<T : KotlinCommonOptions>(
 class AndroidCompilationDetails(
    target: KotlinTarget,
    compilationPurpose: String,
+    defaultSourceSet: KotlinSourceSet,
+    val androidVariant: BaseVariant,
    /** Workaround mutual creation order: a compilation is not added to the target's compilations collection until some point, pass it here */
    private val getCompilationInstance: () -> KotlinJvmAndroidCompilation
 ) : DefaultCompilationDetailsWithRuntime<KotlinJvmOptions>(
    target,
    compilationPurpose,
-    { KotlinJvmOptionsImpl() }
+    defaultSourceSet,
+    KotlinJvmOptionsImpl()
 ) {
    override val compilation: KotlinJvmAndroidCompilation get() = getCompilationInstance()

-    val androidVariant get() = compilation.androidVariant
-
    override val friendArtifacts: FileCollection
        get() = target.project.files(super.friendArtifacts, compilation.testedVariantArtifacts)

-    override val defaultSourceSetName: String by lazy {
-        project.kotlinAndroidSourceSetLayout.naming.defaultKotlinSourceSetName(this) ?: super.defaultSourceSetName
-    }
-
    /*
    * Example of how multiplatform dependencies from common would get to Android test classpath:
    * commonMainImplementation -> androidDebugImplementation -> debugImplementation -> debugAndroidTestCompileClasspath
@@ -554,11 +539,16 @@ class AndroidCompilationDetails(
        }
 }

-internal class MetadataCompilationDetails(target: KotlinTarget, name: String) :
+internal class MetadataCompilationDetails(
+    target: KotlinTarget,
+    name: String,
+    defaultSourceSet: KotlinSourceSet,
+) :
    DefaultCompilationDetails<KotlinMultiplatformCommonOptions>(
        target,
        name,
-        { KotlinMultiplatformCommonOptionsImpl() }
+        defaultSourceSet,
+        KotlinMultiplatformCommonOptionsImpl()
    ) {

    override val friendArtifacts: FileCollection
@@ -572,7 +562,10 @@ internal class MetadataCompilationDetails(target: KotlinTarget, name: String) :
 internal open class JsCompilationDetails(
    target: KotlinTarget,
    compilationPurpose: String,
-) : DefaultCompilationDetailsWithRuntime<KotlinJsOptions>(target, compilationPurpose, { KotlinJsOptionsImpl() }) {
+    defaultSourceSet: KotlinSourceSet,
+) : DefaultCompilationDetailsWithRuntime<KotlinJsOptions>(
+    target, compilationPurpose, defaultSourceSet, KotlinJsOptionsImpl()
+) {

    internal abstract class JsCompilationDependenciesHolder @Inject constructor(
        val target: KotlinTarget,
@@ -616,39 +609,17 @@ internal open class JsCompilationDetails(
    override val kotlinDependenciesHolder: HasKotlinDependencies
        get() = target.project.objects.newInstance(JsCompilationDependenciesHolder::class.java, target, compilationPurpose)

-    override val defaultSourceSetName: String
-        get() {
-            val classifier = if (target is KotlinJsTarget && target.irTarget != null)
-                target.disambiguationClassifierInPlatform
-            else target.disambiguationClassifier
-
-            return lowerCamelCaseName(
-                classifier,
-                compilationPurpose
-            )
-        }
 }

-internal class JsIrCompilationDetails(target: KotlinTarget, compilationPurpose: String) :
-    JsCompilationDetails(target, compilationPurpose) {
+internal class JsIrCompilationDetails(
+    target: KotlinTarget, compilationPurpose: String, defaultSourceSet: KotlinSourceSet
+) : JsCompilationDetails(target, compilationPurpose, defaultSourceSet) {

    override fun addSourcesToCompileTask(sourceSet: KotlinSourceSet, addAsCommonSources: Lazy<Boolean>) {
        super.addSourcesToCompileTask(sourceSet, addAsCommonSources)
        (compilation as KotlinJsIrCompilation).allSources.add(sourceSet.kotlin)
    }

-    override val defaultSourceSetName: String
-        get() {
-            val target = target as KotlinJsIrTarget
-            return lowerCamelCaseName(
-                if (target.mixedMode)
-                    target.disambiguationClassifierInPlatform
-                else
-                    target.disambiguationClassifier,
-                compilationPurpose
-            )
-        }
-
    internal abstract class JsIrCompilationDependencyHolder @Inject constructor(target: KotlinTarget, compilationPurpose: String) :
        JsCompilationDependenciesHolder(target, compilationPurpose) {
        override val disambiguationClassifierInPlatform: String?
@@ -7,18 +7,41 @@
 package org.jetbrains.kotlin.gradle.plugin.mpp

 import org.gradle.api.NamedDomainObjectFactory
+import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
+import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName

 interface KotlinCompilationFactory<T : KotlinCompilation<*>> : NamedDomainObjectFactory<T> {
+    val project: Project get() = target.project
+    val target: KotlinTarget
    val itemClass: Class<T>
+
+    fun defaultSourceSetName(compilationName: String): String = lowerCamelCaseName(
+        target.disambiguationClassifier.takeIf { target !is KotlinMetadataTarget },
+        when {
+            // corner case: main compilation of the metadata target compiles commonMain
+            compilationName == KotlinCompilation.MAIN_COMPILATION_NAME &&
+                    target is KotlinMetadataTarget -> KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME
+
+            else -> compilationName
+        }
+    )
+}
+
+internal fun KotlinCompilationFactory<*>.getOrCreateDefaultSourceSet(compilationName: String): KotlinSourceSet {
+    return project.kotlinExtension.sourceSets.maybeCreate(defaultSourceSetName(compilationName))
 }

 class KotlinCommonCompilationFactory(
-    val target: KotlinOnlyTarget<*>
+    override val target: KotlinOnlyTarget<*>
 ) : KotlinCompilationFactory<KotlinCommonCompilation> {
    override val itemClass: Class<KotlinCommonCompilation>
        get() = KotlinCommonCompilation::class.java

-    override fun create(name: String): KotlinCommonCompilation =
-        target.project.objects.newInstance(KotlinCommonCompilation::class.java, MetadataCompilationDetails(target, name))
-}
+    override fun create(name: String): KotlinCommonCompilation = target.project.objects.newInstance(
+        KotlinCommonCompilation::class.java, MetadataCompilationDetails(target, name, getOrCreateDefaultSourceSet(name))
+    )
+}
@@ -6,11 +6,6 @@
 package org.jetbrains.kotlin.gradle.plugin.mpp

 import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.execution.TaskExecutionListener
-import org.gradle.api.plugins.ExtraPropertiesExtension
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.TaskState
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
@@ -8,10 +8,10 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 import org.gradle.api.artifacts.Configuration
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptionsImpl
-import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 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.plugin.sources.kpm.FragmentMappedKotlinSourceSet
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 import javax.inject.Inject

@@ -62,7 +62,9 @@ internal class KotlinMappedJvmCompilationFactory(

        return target.project.objects.newInstance(
            KotlinJvmCompilation::class.java,
-            VariantMappedCompilationDetailsWithRuntime<KotlinJvmOptions>(variant, target)
+            VariantMappedCompilationDetailsWithRuntime<KotlinJvmOptions>(
+                variant, target, getOrCreateDefaultSourceSet(name) as FragmentMappedKotlinSourceSet
+            )
        )
    }
 }
@@ -25,5 +25,5 @@ internal class GradleKpmNativeVariantCompilationData(
    override val owner: GradleKpmNativeVariant
        get() = variant

-    override val kotlinOptions: KotlinCommonOptions = NativeCompileOptions { variant.languageSettings }
+    override val kotlinOptions: KotlinCommonOptions = NativeCompileOptions(variant.languageSettings)
 }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 import org.gradle.api.artifacts.Configuration
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.publishedConfigurationName
+import org.jetbrains.kotlin.gradle.plugin.sources.kpm.FragmentMappedKotlinSourceSet
 import org.jetbrains.kotlin.konan.target.KonanTarget

 abstract class GradleKpmNativeVariantInternal(
@@ -57,7 +57,9 @@ internal class KotlinMappedNativeCompilationFactory(
        return target.project.objects.newInstance(
            KotlinNativeCompilation::class.java,
            target.konanTarget,
-            VariantMappedCompilationDetails<KotlinCommonOptions>(variant, target)
+            VariantMappedCompilationDetails<KotlinCommonOptions>(
+                variant, target, getOrCreateDefaultSourceSet(name) as FragmentMappedKotlinSourceSet
+            )
        )
    }
 }
@@ -10,9 +10,13 @@ import org.gradle.api.Project
 import org.gradle.api.file.FileCollection
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.tasks.TaskProvider
-import org.jetbrains.kotlin.gradle.dsl.*
+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.*
+import org.jetbrains.kotlin.gradle.dsl.topLevelExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationOutput
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.archivesName
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
@@ -78,7 +82,7 @@ internal abstract class AbstractKotlinFragmentMetadataCompilationData<T : Kotlin
        project.provider { project.buildDir.resolve("processedResources/${fragment.disambiguateName("metadata")}") }
    )

-    override val languageSettings: LanguageSettingsBuilder = fragment.languageSettings
+    final override val languageSettings: LanguageSettingsBuilder = fragment.languageSettings

    override val platformType: KotlinPlatformType
        get() = KotlinPlatformType.common
@@ -118,7 +122,8 @@ internal open class KotlinCommonFragmentMetadataCompilationDataImpl(
    module,
    compileAllTask,
    metadataCompilationRegistry,
-    resolvedMetadataFiles), KotlinCommonFragmentMetadataCompilationData {
+    resolvedMetadataFiles
+), KotlinCommonFragmentMetadataCompilationData {

    override val isActive: Boolean
        get() = !fragment.isNativeShared() &&
@@ -164,7 +169,7 @@ internal open class KotlinNativeFragmentMetadataCompilationDataImpl(
    override val isActive: Boolean
        get() = fragment.isNativeShared() && fragment.containingVariants.count() > 1

-    override val kotlinOptions: NativeCompileOptions = NativeCompileOptions { languageSettings }
+    override val kotlinOptions: NativeCompileOptions = NativeCompileOptions(languageSettings)

    override val konanTarget: KonanTarget
        get() {
@@ -5,8 +5,9 @@

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

+import com.android.build.gradle.api.BaseVariant
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.mpp.AndroidCompilationDetails
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget

 internal interface KotlinAndroidSourceSetNaming {

@@ -24,5 +25,5 @@ internal interface KotlinAndroidSourceSetNaming {
     * Returns `null`, if this naming schema does not know about it. In this case, the
     * 'default' defaultSourceSetName will be constructed by the compilation.
     */
-    fun defaultKotlinSourceSetName(compilation: AndroidCompilationDetails): String? = null
+    fun defaultKotlinSourceSetName(target: KotlinAndroidTarget, variant: BaseVariant): String? = null
 }
@@ -5,8 +5,9 @@

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

+import com.android.build.gradle.api.BaseVariant
 import org.gradle.api.logging.Logging
-import org.jetbrains.kotlin.gradle.plugin.mpp.AndroidCompilationDetails
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName

 internal object MultiplatformLayoutV2KotlinAndroidSourceSetNaming : KotlinAndroidSourceSetNaming {
@@ -28,20 +29,20 @@ internal object MultiplatformLayoutV2KotlinAndroidSourceSetNaming : KotlinAndroi
        return lowerCamelCaseName(disambiguationClassifier, replaceAndroidBaseSourceSetName(androidSourceSetName, knownType))
    }

-    override fun defaultKotlinSourceSetName(compilation: AndroidCompilationDetails): String? {
+    override fun defaultKotlinSourceSetName(target: KotlinAndroidTarget, variant: BaseVariant): String? {
        val kotlinSourceSetName: String? = run {
-            val baseSourceSetName = compilation.androidVariant.type.androidBaseSourceSetName ?: return@run null
+            val baseSourceSetName = variant.type.androidBaseSourceSetName ?: return@run null
            val androidSourceSetName = lowerCamelCaseName(
                baseSourceSetName.takeIf { it != AndroidBaseSourceSetName.Main }?.name,
-                compilation.androidVariant.flavorName,
-                compilation.androidVariant.buildType.name
+                variant.flavorName,
+                variant.buildType.name
            )
-            val androidSourceSet = compilation.androidVariant.sourceSets.find { it.name == androidSourceSetName } ?: return@run null
-            compilation.project.findKotlinSourceSet(androidSourceSet)?.name
+            val androidSourceSet = variant.sourceSets.find { it.name == androidSourceSetName } ?: return@run null
+            target.project.findKotlinSourceSet(androidSourceSet)?.name
        }

        if (kotlinSourceSetName == null) {
-            logger.warn("Can't determine 'defaultKotlinSourceSet' for android compilation: ${compilation.androidVariant.name}")
+            logger.warn("Can't determine 'defaultKotlinSourceSet' for android compilation: ${variant.name}")
        }
        return kotlinSourceSetName
    }
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilationFactory
 import org.jetbrains.kotlin.gradle.plugin.sources.android.KotlinAndroidSourceSets.applyKotlinAndroidSourceSetLayout
 import org.jetbrains.kotlin.gradle.plugin.sources.android.findKotlinSourceSet
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
@@ -74,14 +75,13 @@ internal class AndroidProjectHandler(
                                                    androidPluginIds.joinToString("\n\t") { "* $it" })

        project.forEachVariant { variant ->
+            val compilationFactory = KotlinJvmAndroidCompilationFactory(kotlinAndroidTarget, variant)
            val variantName = getVariantName(variant)

            // Create the compilation and configure it first, then add to the compilations container. As this code is executed
            // in afterEvaluate, a user's build script might have already attached item handlers to the compilations container, and those
            // handlers might break when fired on a compilation that is not yet properly configured (e.g. KT-29964):
-            kotlinAndroidTarget.compilationFactory.create(variantName).let { compilation ->
-                compilation.androidVariant = variant
-
+            compilationFactory.create(variantName).let { compilation ->
                setUpDependencyResolution(variant, compilation)

                preprocessVariant(variant, compilation, project, kotlinOptions, kotlinConfigurationTools.kotlinTasksProvider)
@@ -29,10 +29,8 @@ abstract class KotlinAndroidTarget @Inject constructor(
    override val platformType: KotlinPlatformType
        get() = KotlinPlatformType.androidJvm

-    internal val compilationFactory = KotlinJvmAndroidCompilationFactory(project, this)
-
    override val compilations: NamedDomainObjectContainer<out KotlinJvmAndroidCompilation> =
-        project.container(compilationFactory.itemClass, compilationFactory)
+        project.container(KotlinJvmAndroidCompilation::class.java)

    /** Names of the Android library variants that should be published from the target's project within the default publications which are
     * set up if the `maven-publish` Gradle plugin is applied.
@@ -6,17 +6,13 @@
@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.gradle.api.Project
-import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
-
 class KotlinJsCompilationFactory(
-    val project: Project,
-    val target: KotlinOnlyTarget<KotlinJsCompilation>,
-    val irTarget: KotlinOnlyTarget<KotlinJsIrCompilation>?
+    override val target: KotlinOnlyTarget<KotlinJsCompilation>,
 ) : KotlinCompilationFactory<KotlinJsCompilation> {
    override val itemClass: Class<KotlinJsCompilation>
        get() = KotlinJsCompilation::class.java

-    override fun create(name: String): KotlinJsCompilation =
-        target.project.objects.newInstance(KotlinJsCompilation::class.java, JsCompilationDetails(target, name))
+    override fun create(name: String): KotlinJsCompilation = target.project.objects.newInstance(
+        KotlinJsCompilation::class.java, JsCompilationDetails(target, name, getOrCreateDefaultSourceSet(name))
+    )
 }
@@ -96,7 +96,7 @@ open class KotlinJsTargetPreset(
    }

    override fun createCompilationFactory(forTarget: KotlinJsTarget): KotlinJsCompilationFactory {
-        return KotlinJsCompilationFactory(project, forTarget, irPreset?.let { forTarget.irTarget })
+        return KotlinJsCompilationFactory(forTarget)
    }

    companion object {
@@ -6,16 +6,14 @@
 package org.jetbrains.kotlin.gradle.targets.js.ir

 import org.gradle.api.file.SourceDirectorySet
-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

-abstract class KotlinJsIrCompilation @Inject constructor(
-    target: KotlinTarget,
-    name: String
-) : KotlinJsCompilation(JsIrCompilationDetails(target, name)) {
+abstract class KotlinJsIrCompilation @Inject internal constructor(
+    compilationDetails: JsIrCompilationDetails
+) : KotlinJsCompilation(compilationDetails) {

    override val externalsOutputFormat: ExternalsOutputFormat = ExternalsOutputFormat.SOURCE

@@ -5,17 +5,31 @@

 package org.jetbrains.kotlin.gradle.targets.js.ir

-import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.plugin.mpp.JsIrCompilationDetails
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCompilationFactory
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.getOrCreateDefaultSourceSet
+import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName

 class KotlinJsIrCompilationFactory(
-    val project: Project,
-    val target: KotlinOnlyTarget<KotlinJsIrCompilation>
+    override val target: KotlinOnlyTarget<KotlinJsIrCompilation>
 ) : KotlinCompilationFactory<KotlinJsIrCompilation> {
    override val itemClass: Class<KotlinJsIrCompilation>
        get() = KotlinJsIrCompilation::class.java

+    override fun defaultSourceSetName(compilationName: String): String {
+        val target = target as KotlinJsIrTarget
+        return lowerCamelCaseName(
+            if (target.mixedMode)
+                target.disambiguationClassifierInPlatform
+            else
+                target.disambiguationClassifier,
+            compilationName
+        )
+    }
+
    override fun create(name: String): KotlinJsIrCompilation =
-        target.project.objects.newInstance(KotlinJsIrCompilation::class.java, target, name)
+        target.project.objects.newInstance(
+            KotlinJsIrCompilation::class.java, JsIrCompilationDetails(target, name, getOrCreateDefaultSourceSet(name))
+        )
 }
@@ -80,7 +80,7 @@ open class KotlinJsIrTargetPreset(
    public override fun createCompilationFactory(
        forTarget: KotlinJsIrTarget
    ): KotlinCompilationFactory<KotlinJsIrCompilation> =
-        KotlinJsIrCompilationFactory(project, forTarget)
+        KotlinJsIrCompilationFactory(forTarget)

    companion object {
        val JS_PRESET_NAME = lowerCamelCaseName(
@@ -6,7 +6,9 @@
 package org.jetbrains.kotlin.gradle.targets.js.ir

 import org.gradle.api.Project
-import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.AbstractKotlinTargetConfigurator
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCompilationFactory
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTargetPreset
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.PublicationRegistrationMode
@@ -64,7 +66,7 @@ class KotlinWasmTargetPreset(
    public override fun createCompilationFactory(
        forTarget: KotlinJsIrTarget
    ): KotlinCompilationFactory<KotlinJsIrCompilation> =
-        KotlinJsIrCompilationFactory(project, forTarget)
+        KotlinJsIrCompilationFactory(forTarget)

    companion object {
        private const val WASM_PRESET_NAME = "wasm"
@@ -12,21 +12,17 @@ import org.gradle.api.provider.Property
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.compile.JavaCompile
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
-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

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

-    lateinit var androidVariant: BaseVariant
-        internal set
+    val androidVariant: BaseVariant = compilationDetails.androidVariant

-    @Suppress("UnstableApiUsage")
-    internal val testedVariantArtifacts: Property<FileCollection> = target.project.objects.property(FileCollection::class.java)
+    internal val testedVariantArtifacts: Property<FileCollection> =
+        compilationDetails.target.project.objects.property(FileCollection::class.java)

    override val compileKotlinTask: org.jetbrains.kotlin.gradle.tasks.KotlinCompile
        get() = super.compileKotlinTask as org.jetbrains.kotlin.gradle.tasks.KotlinCompile
@@ -6,20 +6,28 @@
@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.gradle.api.Project
+import com.android.build.gradle.api.BaseVariant
+import org.jetbrains.kotlin.gradle.plugin.sources.android.kotlinAndroidSourceSetLayout

 class KotlinJvmAndroidCompilationFactory(
-    val project: Project,
-    val target: KotlinAndroidTarget
+    override val target: KotlinAndroidTarget,
+    private val variant: BaseVariant,
 ) : KotlinCompilationFactory<KotlinJvmAndroidCompilation> {

    override val itemClass: Class<KotlinJvmAndroidCompilation>
        get() = KotlinJvmAndroidCompilation::class.java

+
+    override fun defaultSourceSetName(compilationName: String): String {
+        return project.kotlinAndroidSourceSetLayout.naming.defaultKotlinSourceSetName(target, variant)
+            ?: super.defaultSourceSetName(compilationName)
+    }
+
    override fun create(name: String): KotlinJvmAndroidCompilation {
        lateinit var result: KotlinJvmAndroidCompilation
-        val details = AndroidCompilationDetails(target, name) { result }
+        val details = AndroidCompilationDetails(target, name, getOrCreateDefaultSourceSet(name), variant) { result }
        result = project.objects.newInstance(KotlinJvmAndroidCompilation::class.java, details)
        return result
    }
+
 }
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptionsImpl
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget

 open class KotlinJvmCompilationFactory(
-    val target: KotlinJvmTarget
+    override val target: KotlinJvmTarget
 ) : KotlinCompilationFactory<KotlinJvmCompilation> {
    override val itemClass: Class<KotlinJvmCompilation>
        get() = KotlinJvmCompilation::class.java
@@ -18,6 +18,8 @@ open class KotlinJvmCompilationFactory(
    override fun create(name: String): KotlinJvmCompilation =
        target.project.objects.newInstance(
            KotlinJvmCompilation::class.java,
-            DefaultCompilationDetailsWithRuntime(target, name) { KotlinJvmOptionsImpl() }
+            DefaultCompilationDetailsWithRuntime(
+                target, name, getOrCreateDefaultSourceSet(name), KotlinJvmOptionsImpl()
+            )
        )
 }
@@ -11,6 +11,7 @@ import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.compile.JavaCompile
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.utils.named
 import javax.inject.Inject
@@ -18,9 +19,11 @@ import javax.inject.Inject
 abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions> @Inject constructor(
    target: KotlinWithJavaTarget<KotlinOptionsType>,
    name: String,
+    override val defaultSourceSet: KotlinSourceSet,
    kotlinOptions: KotlinOptionsType
-) : AbstractKotlinCompilationToRunnableFiles<KotlinOptionsType>(WithJavaCompilationDetails(target, name) { kotlinOptions }),
-    KotlinCompilationWithResources<KotlinOptionsType> {
+) : AbstractKotlinCompilationToRunnableFiles<KotlinOptionsType>(
+    WithJavaCompilationDetails(target, name, defaultSourceSet, kotlinOptions)
+), KotlinCompilationWithResources<KotlinOptionsType> {
    lateinit var javaSourceSet: SourceSet

    override val processResourcesTaskName: String
@@ -6,12 +6,10 @@
@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions

 class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions>(
-    val project: Project,
-    val target: KotlinWithJavaTarget<KotlinOptionsType>,
+    override val target: KotlinWithJavaTarget<KotlinOptionsType>,
    val kotlinOptionsFactory: () -> KotlinOptionsType
 ) : KotlinCompilationFactory<KotlinWithJavaCompilation<KotlinOptionsType>> {

@@ -25,6 +23,7 @@ class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions>(
            KotlinWithJavaCompilation::class.java,
            target,
            name,
+            getOrCreateDefaultSourceSet(name),
            kotlinOptionsFactory()
        ) as KotlinWithJavaCompilation<KotlinOptionsType>
 }
@@ -44,7 +44,7 @@ abstract class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions> @In
        @Suppress("UNCHECKED_CAST")
        project.container(
            KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType>>,
-            KotlinWithJavaCompilationFactory(project, this, kotlinOptionsFactory)
+            KotlinWithJavaCompilationFactory(this, kotlinOptionsFactory)
        )

    private val layout = project.layout
@@ -7,13 +7,11 @@ package org.jetbrains.kotlin.gradle.targets.metadata

 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonOptions
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.MetadataMappedCompilationDetails
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmAwareTargetConfigurator
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.kpmModules
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.metadataCompilationRegistryByModuleId
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.unambiguousNameInProject
 import org.jetbrains.kotlin.gradle.plugin.whenEvaluated
 import org.jetbrains.kotlin.project.model.utils.variantsContainingFragment

@@ -45,7 +43,8 @@ internal class GradleKpmMetadataTargetConfigurator(private val metadataTargetCon
                val compilationData = metadataCompilations.getForFragmentOrNull(fragment) ?: return@forEach
                if (!compilationData.isActive) return@forEach

-                val compilationDetails = MetadataMappedCompilationDetails(target, compilationData)
+                val defaultSourceSet = target.project.kotlinExtension.sourceSets.maybeCreate(fragment.unambiguousNameInProject)
+                val compilationDetails = MetadataMappedCompilationDetails(target, defaultSourceSet, compilationData)

                val isNative = compilationData is KotlinNativeFragmentMetadataCompilationData

@@ -60,6 +59,7 @@ internal class GradleKpmMetadataTargetConfigurator(private val metadataTargetCon
                            compilationDetails as CompilationDetails<KotlinCommonOptions>
                        )
                    }
+
                    else -> target.project.objects
                        .newInstance(
                            KotlinCommonCompilation::class.java,
@@ -21,8 +21,7 @@ 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)
+internal class NativeCompileOptions(private val languageSettings: LanguageSettingsBuilder) : KotlinCommonOptions {

    override var apiVersion: String?
        get() = languageSettings.apiVersion
@@ -9,36 +9,42 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 import org.jetbrains.kotlin.konan.target.KonanTarget

 open class KotlinNativeCompilationFactory(
-    val target: KotlinNativeTarget
+    override val target: KotlinNativeTarget
 ) : KotlinCompilationFactory<KotlinNativeCompilation> {

    override val itemClass: Class<KotlinNativeCompilation>
        get() = KotlinNativeCompilation::class.java

-    override fun create(name: String): KotlinNativeCompilation =
-    // TODO: Validate compilation free args using the [CompilationFreeArgsValidator]
-    //       when the compilation and the link args are separated (see KT-33717).
-    // Note: such validation should be done in the whenEvaluate block because
+    override fun create(name: String): KotlinNativeCompilation {
+        // TODO: Validate compilation free args using the [CompilationFreeArgsValidator]
+        //       when the compilation and the link args are separated (see KT-33717).
+        // Note: such validation should be done in the whenEvaluate block because
        // a user can change args during project configuration.

-        target.project.objects.newInstance(
+        val defaultSourceSet = getOrCreateDefaultSourceSet(name)
+        return target.project.objects.newInstance(
            KotlinNativeCompilation::class.java,
            target.konanTarget,
-            NativeCompilationDetails(target, name) { NativeCompileOptions { defaultSourceSet.languageSettings } }
+            NativeCompilationDetails(
+                target, name, defaultSourceSet, NativeCompileOptions(defaultSourceSet.languageSettings)
+            )
        )
+    }
 }

 class KotlinSharedNativeCompilationFactory(
-    val target: KotlinMetadataTarget,
+    override val target: KotlinMetadataTarget,
    val konanTargets: List<KonanTarget>
-): KotlinCompilationFactory<KotlinSharedNativeCompilation> {
+) : KotlinCompilationFactory<KotlinSharedNativeCompilation> {
    override val itemClass: Class<KotlinSharedNativeCompilation>
        get() = KotlinSharedNativeCompilation::class.java

-    override fun create(name: String): KotlinSharedNativeCompilation =
-        target.project.objects.newInstance(
+    override fun create(name: String): KotlinSharedNativeCompilation {
+        val defaultSourceSet = getOrCreateDefaultSourceSet(name)
+        return target.project.objects.newInstance(
            KotlinSharedNativeCompilation::class.java,
            konanTargets,
-            SharedNativeCompilationDetails(target, name) { NativeCompileOptions { defaultSourceSet.languageSettings } }
+            SharedNativeCompilationDetails(target, name, defaultSourceSet, NativeCompileOptions(defaultSourceSet.languageSettings))
        )
+    }
 }
@@ -14,7 +14,6 @@ import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.kotlin.gradle.applyMultiplatformPlugin
 import org.jetbrains.kotlin.gradle.plugin.forEachVariant
-import org.jetbrains.kotlin.gradle.plugin.mpp.AndroidCompilationDetails
 import org.jetbrains.kotlin.gradle.plugin.sources.android.*
 import org.jetbrains.kotlin.gradle.setMultiplatformAndroidSourceSetLayoutVersion
 import org.jetbrains.kotlin.gradle.utils.androidExtension
@@ -271,11 +270,12 @@ class MultiplatformAndroidSourceSetLayoutV2Test {
        project.evaluate()

        kotlin.android().compilations.all { compilation ->
-            val compilationDetails = compilation.compilationDetails as AndroidCompilationDetails
-            val defaultKotlinSourceSetName = multiplatformAndroidSourceSetLayoutV2.naming.defaultKotlinSourceSetName(compilationDetails)
+            val defaultKotlinSourceSetName = multiplatformAndroidSourceSetLayoutV2.naming
+                .defaultKotlinSourceSetName(kotlin.android(), compilation.androidVariant)
+
            assertNotNull(
                defaultKotlinSourceSetName,
-                "Expected non-null 'defaultKotlinSourceSetName' for compilation ${compilationDetails.compilation.name}"
+                "Expected non-null 'defaultKotlinSourceSetName' for compilation ${compilation.name}"
            )

            val kotlinSourceSet = kotlin.sourceSets.getByName(defaultKotlinSourceSetName)