[Gradle] Implement KotlinWithJavaCompilation with underlying KotlinCompilationImpl

KT-54312

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/AbstractKotlinPlugin.kt

@@ -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)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/Kotlin2JsPlugin.kt

@@ -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))
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinCommonPlugin.kt

@@ -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)
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinJvmPlugin.kt

@@ -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) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationDetailsImpl/WithJavaCompilationDetails.kt

@@ -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 {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/factory/DefaultKotlinCompilationDependencyConfigurationsFactory.kt

@@ -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(
+            naming = ConfigurationNaming.Js(target, compilationName)
-                target.disambiguationClassifierInPlatform, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME }
+        )
-            )
+    }
+}
+
+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?
+    class Js(
-        get() = when (this) {
+        private val target: KotlinTarget,
-            is KotlinJsTarget -> disambiguationClassifierInPlatform
+        private val compilationName: String
-            is KotlinJsIrTarget -> disambiguationClassifierInPlatform
+    ) : ConfigurationNaming {
-            else -> error("Unexpected target type of $this")
+        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(
+    naming: ConfigurationNaming = ConfigurationNaming.Default(target, compilationName),
-        target.disambiguationClassifier, compilationName.takeIf { it != KotlinCompilation.MAIN_COMPILATION_NAME },
+    apiConfigurationName: String = naming.name(compilation, API),
-    ),
+    implementationConfigurationName: String = naming.name(compilation, IMPLEMENTATION),
-    compileClasspathConfigurationSuffix: String = "compileClasspath",
+    compileOnlyConfigurationName: String = naming.name(compilation, COMPILE_ONLY),
-    runtimeClasspathConfigurationSuffix: String = "runtimeClasspath"
+    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(apiConfigurationName).apply {
-
-    val apiConfiguration = target.project.configurations.maybeCreate(name(compilation, API)).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(
+    val runtimeDependencyConfiguration =
-        name(runtimeClasspathConfigurationSuffix)
+        if (withRuntime) target.project.configurations.maybeCreate(runtimeClasspathConfigurationName).apply {
-    ).apply {
+            extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
-        extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
+            usesPlatformOf(target)
-        usesPlatformOf(target)
+            isVisible = false
-        isVisible = false
+            isCanBeConsumed = false
-        isCanBeConsumed = false
+            isCanBeResolved = true
-        isCanBeResolved = true
+            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
-        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
+            if (target.platformType != KotlinPlatformType.androidJvm) {
-        if (target.platformType != KotlinPlatformType.androidJvm) {
+                attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+            }
-        }
+            description = "Runtime classpath of $compilationCoordinates."
-        description = "Runtime classpath of $compilationCoordinates."
+        } else null
-    } else null
 
     return DefaultKotlinCompilationDependencyConfigurationsContainer(
         apiConfiguration = apiConfiguration,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/factory/JvmWithJavaCompilationTaskNamesContainerFactory.kt

@@ -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)
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/factory/NativeKotlinCompilationTaskNamesContainerFactory.kt

@@ -14,3 +14,4 @@ internal object NativeKotlinCompilationTaskNamesContainerFactory :
         DefaultKotlinCompilationTaskNamesContainerFactory.create(target, compilationName)
             .copy(compileAllTaskName = lowerCamelCaseName(target.disambiguationClassifier, compilationName, "klibrary"))
 }
+

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilation.kt

@@ -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.compilationImpl.KotlinCompilationImpl
-import org.jetbrains.kotlin.gradle.plugin.mpp.compilationDetailsImpl.WithJavaCompilationDetails
 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(
+open class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions> @Inject internal constructor(
-    target: KotlinWithJavaTarget<KotlinOptionsType, CO>,
+    private val compilation: KotlinCompilationImpl,
-    name: String,
+    val javaSourceSet: SourceSet,
-    override val defaultSourceSet: KotlinSourceSet,
+) : InternalKotlinCompilation<KotlinOptionsType> by compilation as InternalKotlinCompilation<KotlinOptionsType>,
-    compilerOptions: HasCompilerOptions<CO>,
+    KotlinCompilationWithResources<KotlinOptionsType>,
-    kotlinOptions: KotlinOptionsType
+    KotlinCompilationToRunnableFiles<KotlinOptionsType> {
-) : AbstractKotlinCompilationToRunnableFiles<KotlinOptionsType>(
+
-    WithJavaCompilationDetails<KotlinOptionsType, CO>(target, name, defaultSourceSet, { compilerOptions }, { kotlinOptions })
+    @Suppress("UNCHECKED_CAST")
-), KotlinCompilationWithResources<KotlinOptionsType> {
+    override val compilerOptions: HasCompilerOptions<CO> =
-    lateinit var javaSourceSet: SourceSet
+        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
+    override val relatedConfigurationNames: List<String>
-        get() = javaSourceSet.runtimeOnlyConfigurationName
+        get() = compilation.relatedConfigurationNames
-
-    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
 
     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)
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilationFactory.kt

@@ -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 javaSourceSet = target.javaSourceSets.maybeCreate(name)
-        val kotlinOptions = kotlinOptionsFactory(compilerOptions.options)
+
+        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,
+            KotlinWithJavaCompilation::class.java, compilationImplFactory.create(target, name), javaSourceSet
-            target,
-            name,
-            getOrCreateDefaultSourceSet(name),
-            compilerOptions,
-            kotlinOptions
         ) as KotlinWithJavaCompilation<KotlinOptionsType, CO>
     }
-}
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilationOutput.kt

@@ -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(
+class KotlinWithJavaCompilationOutput internal constructor(
-    internal val compilation: KotlinWithJavaCompilation<*, *>
+    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 =
+    override val classesDirs: ConfigurableFileCollection
-        javaSourceSetOutput.classesDirs as ConfigurableFileCollection
+        get() = javaSourceSetOutput.classesDirs as ConfigurableFileCollection
 
     override val allOutputs: FileCollection
         get() = javaSourceSetOutput

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaTarget.kt

@@ -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