[Gradle] Implement KotlinWithJavaCompilation with underlying KotlinCompilationImpl

KT-54312
2022-10-04 17:16:47 +02:00
parent e890e8178b
commit af19882589
12 changed files with 177 additions and 97 deletions
@@ -38,7 +38,7 @@ internal abstract class AbstractKotlinPlugin(

    internal abstract fun buildSourceSetProcessor(
        project: Project,
-        compilation: AbstractKotlinCompilation<*>
+        compilation: KotlinCompilation<*>
    ): KotlinSourceSetProcessor<*>

    override fun apply(project: Project) {
@@ -150,7 +150,7 @@ internal abstract class AbstractKotlinPlugin(

        fun configureTarget(
            target: KotlinWithJavaTarget<*, *>,
-            buildSourceSetProcessor: (AbstractKotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
+            buildSourceSetProcessor: (KotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
        ) {
            setUpJavaSourceSets(target)
            configureSourceSetDefaults(target, buildSourceSetProcessor)
@@ -179,7 +179,6 @@ internal abstract class AbstractKotlinPlugin(
            javaSourceSets.all { javaSourceSet ->
                val kotlinCompilation =
                    compilationsUnderConstruction[javaSourceSet.name] ?: kotlinTarget.compilations.maybeCreate(javaSourceSet.name)
-                (kotlinCompilation as? KotlinWithJavaCompilation<*, *>)?.javaSourceSet = javaSourceSet

                if (duplicateJavaSourceSetsAsKotlinSourceSets) {
                    val kotlinSourceSet = project.kotlinExtension.sourceSets.maybeCreate(kotlinCompilation.name)
@@ -198,7 +197,6 @@ internal abstract class AbstractKotlinPlugin(
            kotlinTarget.compilations.all { kotlinCompilation ->
                val sourceSetName = kotlinCompilation.name
                compilationsUnderConstruction[sourceSetName] = kotlinCompilation
-                (kotlinCompilation as? KotlinWithJavaCompilation<*, *>)?.javaSourceSet = javaSourceSets.maybeCreate(sourceSetName)

                // Another Kotlin source set following the other convention, named according to the compilation, not the Java source set:
                val kotlinSourceSet = project.kotlinExtension.sourceSets.maybeCreate(kotlinCompilation.defaultSourceSetName)
@@ -250,7 +248,7 @@ internal abstract class AbstractKotlinPlugin(

        private fun configureSourceSetDefaults(
            kotlinTarget: KotlinWithJavaTarget<*, *>,
-            buildSourceSetProcessor: (AbstractKotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
+            buildSourceSetProcessor: (KotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
        ) {
            kotlinTarget.compilations.all { compilation ->
                AbstractKotlinTargetConfigurator.defineConfigurationsForCompilation(compilation)
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.gradle.plugin
 import org.gradle.api.Project
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 import org.jetbrains.kotlin.gradle.dsl.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider

@@ -26,7 +25,7 @@ internal open class Kotlin2JsPlugin(

    override fun buildSourceSetProcessor(
        project: Project,
-        compilation: AbstractKotlinCompilation<*>
+        compilation: KotlinCompilation<*>
    ): KotlinSourceSetProcessor<*> =
        Kotlin2JsSourceSetProcessor(tasksProvider, KotlinCompilationProjection(compilation))

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.gradle.plugin
 import org.gradle.api.Project
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 import org.jetbrains.kotlin.gradle.dsl.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider

@@ -22,7 +21,7 @@ internal open class KotlinCommonPlugin(

    override fun buildSourceSetProcessor(
        project: Project,
-        compilation: AbstractKotlinCompilation<*>
+        compilation: KotlinCompilation<*>
    ): KotlinSourceSetProcessor<*> =
        KotlinCommonSourceSetProcessor(KotlinCompilationProjection(compilation), tasksProvider)

@@ -37,7 +37,7 @@ internal open class KotlinJvmPlugin(
        private const val targetName = "" // use empty suffix for the task names
    }

-    override fun buildSourceSetProcessor(project: Project, compilation: AbstractKotlinCompilation<*>) =
+    override fun buildSourceSetProcessor(project: Project, compilation: KotlinCompilation<*>) =
        Kotlin2JvmSourceSetProcessor(tasksProvider, KotlinCompilationProjection(compilation))

    override fun apply(project: Project) {
@@ -28,7 +28,7 @@ internal class WithJavaCompilationDetails<T : KotlinCommonOptions, CO : Compiler
    val javaSourceSet: SourceSet
        get() = compilation.javaSourceSet

-    override val output: KotlinCompilationOutput by lazy { KotlinWithJavaCompilationOutput(compilation) }
+    override val output: KotlinCompilationOutput = KotlinWithJavaCompilationOutput(compilation.javaSourceSet)

    override val compileDependencyFilesHolder: GradleKpmDependencyFilesHolder
        get() = object : GradleKpmDependencyFilesHolder {
@@ -9,8 +9,10 @@ import org.gradle.api.attributes.Category
 import org.gradle.api.attributes.Usage
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.DefaultKotlinCompilationDependencyConfigurationsContainer
 import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.KotlinCompilationDependencyConfigurationsContainer
+import org.jetbrains.kotlin.gradle.plugin.mpp.javaSourceSets
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 import org.jetbrains.kotlin.gradle.utils.*
@@ -35,8 +37,13 @@ internal object NativeKotlinCompilationDependencyConfigurationsFactory :
    KotlinCompilationImplFactory.KotlinCompilationDependencyConfigurationsFactory {

    override fun create(target: KotlinTarget, compilationName: String): KotlinCompilationDependencyConfigurationsContainer {
+        val naming = ConfigurationNaming.Default(target, compilationName)
        return KotlinCompilationDependencyConfigurationsContainer(
-            target, compilationName, withRuntime = false, compileClasspathConfigurationSuffix = "compileKlibraries"
+            target = target,
+            compilationName = compilationName,
+            naming = naming,
+            withRuntime = false,
+            compileClasspathConfigurationName = naming.name("compileKlibraries")
        )
    }
 }
@@ -47,41 +54,78 @@ internal object JsKotlinCompilationDependencyConfigurationsFactory :
    override fun create(target: KotlinTarget, compilationName: String): KotlinCompilationDependencyConfigurationsContainer {
        return KotlinCompilationDependencyConfigurationsContainer(
            target, compilationName, withRuntime = true,
-            configurationNamePrefix = lowerCamelCaseName(
-                target.disambiguationClassifierInPlatform, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME }
-            )
+            naming = ConfigurationNaming.Js(target, compilationName)
+        )
+    }
+}
+
+internal class JvmWithJavaCompilationDependencyConfigurationsFactory(private val target: KotlinWithJavaTarget<*, *>) :
+    KotlinCompilationImplFactory.KotlinCompilationDependencyConfigurationsFactory {
+    override fun create(target: KotlinTarget, compilationName: String): KotlinCompilationDependencyConfigurationsContainer {
+        val javaSourceSet = this.target.javaSourceSets.maybeCreate(compilationName)
+        return KotlinCompilationDependencyConfigurationsContainer(
+            target = target, compilationName = compilationName, withRuntime = true,
+            apiConfigurationName = javaSourceSet.apiConfigurationName,
+            implementationConfigurationName = javaSourceSet.implementationConfigurationName,
+            compileOnlyConfigurationName = javaSourceSet.compileOnlyConfigurationName,
+            runtimeOnlyConfigurationName = javaSourceSet.runtimeOnlyConfigurationName,
+            compileClasspathConfigurationName = javaSourceSet.compileClasspathConfigurationName,
+            runtimeClasspathConfigurationName = javaSourceSet.runtimeClasspathConfigurationName
+        )
+    }
+}
+
+private fun interface ConfigurationNaming {
+    fun name(vararg parts: String): String
+
+    class Default(
+        private val target: KotlinTarget,
+        private val compilationName: String,
+    ) : ConfigurationNaming {
+        override fun name(vararg parts: String): String = lowerCamelCaseName(
+            target.disambiguationClassifier, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME }, *parts
        )
    }

-    private val KotlinTarget.disambiguationClassifierInPlatform: String?
-        get() = when (this) {
-            is KotlinJsTarget -> disambiguationClassifierInPlatform
-            is KotlinJsIrTarget -> disambiguationClassifierInPlatform
-            else -> error("Unexpected target type of $this")
-        }
+    class Js(
+        private val target: KotlinTarget,
+        private val compilationName: String
+    ) : ConfigurationNaming {
+        override fun name(vararg parts: String): String = lowerCamelCaseName(
+            target.disambiguationClassifierInPlatform, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME }, *parts
+        )
+
+        private val KotlinTarget.disambiguationClassifierInPlatform: String?
+            get() = when (this) {
+                is KotlinJsTarget -> disambiguationClassifierInPlatform
+                is KotlinJsIrTarget -> disambiguationClassifierInPlatform
+                else -> error("Unexpected target type of $this")
+            }
+    }
 }

+private const val compilation = "compilation"
+
 private fun KotlinCompilationDependencyConfigurationsContainer(
    target: KotlinTarget, compilationName: String, withRuntime: Boolean,
-    configurationNamePrefix: String = lowerCamelCaseName(
-        target.disambiguationClassifier, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME },
-    ),
-    compileClasspathConfigurationSuffix: String = "compileClasspath",
-    runtimeClasspathConfigurationSuffix: String = "runtimeClasspath"
+    naming: ConfigurationNaming = ConfigurationNaming.Default(target, compilationName),
+    apiConfigurationName: String = naming.name(compilation, API),
+    implementationConfigurationName: String = naming.name(compilation, IMPLEMENTATION),
+    compileOnlyConfigurationName: String = naming.name(compilation, COMPILE_ONLY),
+    runtimeOnlyConfigurationName: String = naming.name(compilation, RUNTIME_ONLY),
+    compileClasspathConfigurationName: String = naming.name("compileClasspath"),
+    runtimeClasspathConfigurationName: String = naming.name("runtimeClasspath")
 ): KotlinCompilationDependencyConfigurationsContainer {
    val compilationCoordinates = "${target.disambiguationClassifier}/$compilationName"
-    val compilation = "compilation"

-    fun name(vararg parts: String) = lowerCamelCaseName(configurationNamePrefix, *parts)
-
-    val apiConfiguration = target.project.configurations.maybeCreate(name(compilation, API)).apply {
+    val apiConfiguration = target.project.configurations.maybeCreate(apiConfigurationName).apply {
        isVisible = false
        isCanBeConsumed = false
        isCanBeResolved = false
        description = "API dependencies for $compilationCoordinates"
    }

-    val implementationConfiguration = target.project.configurations.maybeCreate(name(compilation, IMPLEMENTATION)).apply {
+    val implementationConfiguration = target.project.configurations.maybeCreate(implementationConfigurationName).apply {
        extendsFrom(apiConfiguration)
        isVisible = false
        isCanBeConsumed = false
@@ -89,7 +133,7 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
        description = "Implementation only dependencies for $compilationCoordinates."
    }

-    val compileOnlyConfiguration = target.project.configurations.maybeCreate(name(compilation, COMPILE_ONLY)).apply {
+    val compileOnlyConfiguration = target.project.configurations.maybeCreate(compileOnlyConfigurationName).apply {
        isCanBeConsumed = false
        setupAsLocalTargetSpecificConfigurationIfSupported(target)
        attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
@@ -98,14 +142,14 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
        description = "Compile only dependencies for $compilationCoordinates."
    }

-    val runtimeOnlyConfiguration = target.project.configurations.maybeCreate(name(compilation, RUNTIME_ONLY)).apply {
+    val runtimeOnlyConfiguration = target.project.configurations.maybeCreate(runtimeOnlyConfigurationName).apply {
        isVisible = false
        isCanBeConsumed = false
        isCanBeResolved = false
        description = "Runtime only dependencies for $compilationCoordinates."
    }

-    val compileDependencyConfiguration = target.project.configurations.maybeCreate(name(compileClasspathConfigurationSuffix)).apply {
+    val compileDependencyConfiguration = target.project.configurations.maybeCreate(compileClasspathConfigurationName).apply {
        extendsFrom(compileOnlyConfiguration, implementationConfiguration)
        usesPlatformOf(target)
        isVisible = false
@@ -117,20 +161,19 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
        description = "Compile classpath for $compilationCoordinates."
    }

-    val runtimeDependencyConfiguration = if (withRuntime) target.project.configurations.maybeCreate(
-        name(runtimeClasspathConfigurationSuffix)
-    ).apply {
-        extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
-        usesPlatformOf(target)
-        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = true
-        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
-        if (target.platformType != KotlinPlatformType.androidJvm) {
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
-        }
-        description = "Runtime classpath of $compilationCoordinates."
-    } else null
+    val runtimeDependencyConfiguration =
+        if (withRuntime) target.project.configurations.maybeCreate(runtimeClasspathConfigurationName).apply {
+            extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
+            usesPlatformOf(target)
+            isVisible = false
+            isCanBeConsumed = false
+            isCanBeResolved = true
+            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
+            if (target.platformType != KotlinPlatformType.androidJvm) {
+                attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+            }
+            description = "Runtime classpath of $compilationCoordinates."
+        } else null

    return DefaultKotlinCompilationDependencyConfigurationsContainer(
        apiConfiguration = apiConfiguration,
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.factory
+
+import org.gradle.api.tasks.SourceSet
+import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.KotlinCompilationTaskNamesContainer
+
+internal class JvmWithJavaCompilationTaskNamesContainerFactory(private val javaSourceSet: SourceSet) :
+    KotlinCompilationImplFactory.KotlinCompilationTaskNamesContainerFactory {
+    override fun create(target: KotlinTarget, compilationName: String): KotlinCompilationTaskNamesContainer =
+        DefaultKotlinCompilationTaskNamesContainerFactory.create(target, compilationName)
+            .copy(compileAllTaskName = javaSourceSet.classesTaskName)
+}
@@ -14,3 +14,4 @@ internal object NativeKotlinCompilationTaskNamesContainerFactory :
        DefaultKotlinCompilationTaskNamesContainerFactory.create(target, compilationName)
            .copy(compileAllTaskName = lowerCamelCaseName(target.disambiguationClassifier, compilationName, "klibrary"))
 }
+
@@ -3,49 +3,51 @@
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

-@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
+@file:Suppress("PackageDirectoryMismatch", "UNCHECKED_CAST") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

+import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.compile.JavaCompile
-import org.jetbrains.kotlin.gradle.dsl.*
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationToRunnableFiles
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.mpp.compilationDetailsImpl.WithJavaCompilationDetails
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.KotlinCompilationImpl
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.utils.named
 import javax.inject.Inject

-abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions, CO : KotlinCommonCompilerOptions> @Inject constructor(
-    target: KotlinWithJavaTarget<KotlinOptionsType, CO>,
-    name: String,
-    override val defaultSourceSet: KotlinSourceSet,
-    compilerOptions: HasCompilerOptions<CO>,
-    kotlinOptions: KotlinOptionsType
-) : AbstractKotlinCompilationToRunnableFiles<KotlinOptionsType>(
-    WithJavaCompilationDetails<KotlinOptionsType, CO>(target, name, defaultSourceSet, { compilerOptions }, { kotlinOptions })
-), KotlinCompilationWithResources<KotlinOptionsType> {
-    lateinit var javaSourceSet: SourceSet
+open class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions> @Inject internal constructor(
+    private val compilation: KotlinCompilationImpl,
+    val javaSourceSet: SourceSet,
+) : InternalKotlinCompilation<KotlinOptionsType> by compilation as InternalKotlinCompilation<KotlinOptionsType>,
+    KotlinCompilationWithResources<KotlinOptionsType>,
+    KotlinCompilationToRunnableFiles<KotlinOptionsType> {
+
+    @Suppress("UNCHECKED_CAST")
+    override val compilerOptions: HasCompilerOptions<CO> =
+        compilation.compilerOptions as HasCompilerOptions<CO>
+
+    @Suppress("UNCHECKED_CAST")
+    override val kotlinOptions: KotlinOptionsType
+        get() = compilation.kotlinOptions as KotlinOptionsType
+
+    val compileJavaTaskProvider: TaskProvider<out JavaCompile>
+        get() = target.project.tasks.withType(JavaCompile::class.java).named(javaSourceSet.compileJavaTaskName)
+
+    override val runtimeDependencyConfigurationName: String
+        get() = compilation.runtimeDependencyConfigurationName ?: error("Missing 'runtimeDependencyConfigurationName'")
+
+    override var runtimeDependencyFiles: FileCollection = compilation.runtimeDependencyFiles ?: error("Missing 'runtimeDependencyFiles'")

    override val processResourcesTaskName: String
-        get() = javaSourceSet.processResourcesTaskName
+        get() = compilation.processResourcesTaskName ?: error("Missing 'processResourcesTaskName'")

-    override val runtimeOnlyConfigurationName: String
-        get() = javaSourceSet.runtimeOnlyConfigurationName
-
-    override val implementationConfigurationName: String
-        get() = javaSourceSet.implementationConfigurationName
-
-    override val apiConfigurationName: String
-        get() = javaSourceSet.apiConfigurationName
-
-    override val compileOnlyConfigurationName: String
-        get() = javaSourceSet.compileOnlyConfigurationName
-
-    override val compileAllTaskName: String
-        get() = javaSourceSet.classesTaskName
+    override val relatedConfigurationNames: List<String>
+        get() = compilation.relatedConfigurationNames

    fun source(javaSourceSet: SourceSet) {
        with(target.project) {
@@ -56,7 +58,4 @@ abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions
            }
        }
    }
-
-    val compileJavaTaskProvider: TaskProvider<out JavaCompile>
-        get() = target.project.tasks.withType(JavaCompile::class.java).named(javaSourceSet.compileJavaTaskName)
 }
@@ -6,30 +6,44 @@
@file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp

-import org.jetbrains.kotlin.gradle.dsl.*
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.JvmKotlinCompilationAssociator
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.factory.JvmWithJavaCompilationDependencyConfigurationsFactory
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.factory.JvmWithJavaCompilationTaskNamesContainerFactory
+import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.factory.KotlinCompilationImplFactory

-class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions, CO : KotlinCommonCompilerOptions>(
+class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions> internal constructor(
    override val target: KotlinWithJavaTarget<KotlinOptionsType, CO>,
    val compilerOptionsFactory: () -> HasCompilerOptions<CO>,
    val kotlinOptionsFactory: (CO) -> KotlinOptionsType
 ) : KotlinCompilationFactory<KotlinWithJavaCompilation<KotlinOptionsType, CO>> {

+    @Suppress("UNCHECKED_CAST")
    override val itemClass: Class<KotlinWithJavaCompilation<KotlinOptionsType, CO>>
-        @Suppress("UNCHECKED_CAST")
        get() = KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType, CO>>

    @Suppress("UNCHECKED_CAST")
    override fun create(name: String): KotlinWithJavaCompilation<KotlinOptionsType, CO> {
-        val compilerOptions = compilerOptionsFactory()
-        val kotlinOptions = kotlinOptionsFactory(compilerOptions.options)
+        val javaSourceSet = target.javaSourceSets.maybeCreate(name)
+
+        val compilationImplFactory = KotlinCompilationImplFactory(
+            compilerOptionsFactory = { _, _ ->
+                val compilerOptions = compilerOptionsFactory()
+                val kotlinOptions = kotlinOptionsFactory(compilerOptions.options)
+                KotlinCompilationImplFactory.CompilerOptionsFactory.Options(compilerOptions, kotlinOptions)
+            },
+            compilationAssociator = JvmKotlinCompilationAssociator,
+            compilationOutputFactory = { _, compilationName ->
+                KotlinWithJavaCompilationOutput(target.javaSourceSets.maybeCreate(compilationName))
+            },
+            compilationDependencyConfigurationsFactory = JvmWithJavaCompilationDependencyConfigurationsFactory(target),
+            compilationTaskNamesContainerFactory = JvmWithJavaCompilationTaskNamesContainerFactory(javaSourceSet),
+        )
+
        return project.objects.newInstance(
-            KotlinWithJavaCompilation::class.java,
-            target,
-            name,
-            getOrCreateDefaultSourceSet(name),
-            compilerOptions,
-            kotlinOptions
+            KotlinWithJavaCompilation::class.java, compilationImplFactory.create(target, name), javaSourceSet
        ) as KotlinWithJavaCompilation<KotlinOptionsType, CO>
    }
-}
+}
@@ -8,16 +8,17 @@ package org.jetbrains.kotlin.gradle.plugin.mpp

 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.SourceSet
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationOutput
 import java.io.File
 import java.util.concurrent.Callable

-class KotlinWithJavaCompilationOutput(
-    internal val compilation: KotlinWithJavaCompilation<*, *>
+class KotlinWithJavaCompilationOutput internal constructor(
+    private val javaSourceSet: SourceSet
 ) : KotlinCompilationOutput, Callable<FileCollection> {

    private val javaSourceSetOutput
-        get() = compilation.javaSourceSet.output
+        get() = javaSourceSet.output

    override val resourcesDir: File
        get() = javaSourceSetOutput.resourcesDir!!
@@ -28,8 +29,8 @@ class KotlinWithJavaCompilationOutput(
            javaSourceSetOutput.setResourcesDir(value)
        }

-    override val classesDirs: ConfigurableFileCollection =
-        javaSourceSetOutput.classesDirs as ConfigurableFileCollection
+    override val classesDirs: ConfigurableFileCollection
+        get() = javaSourceSetOutput.classesDirs as ConfigurableFileCollection

    override val allOutputs: FileCollection
        get() = javaSourceSetOutput
@@ -12,10 +12,13 @@ import org.gradle.api.artifacts.Dependency
 import org.gradle.api.file.Directory
 import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.jvm.tasks.Jar
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
+import org.jetbrains.kotlin.gradle.plugin.variantImplementationFactory
 import org.jetbrains.kotlin.gradle.tasks.KOTLIN_BUILD_DIR_NAME
 import java.io.File
 import javax.inject.Inject
@@ -61,3 +64,9 @@ abstract class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions, CO
 }

 private fun sanitizeFileName(candidate: String): String = candidate.filter { it.isLetterOrDigit() }
+
+internal val KotlinWithJavaTarget<*, *>.javaSourceSets: SourceSetContainer
+    get() = project.gradle
+        .variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+        .getInstance(project)
+        .sourceSets