Don't create source sets and test compilation for the metadata target

Issue #KT-26253 In progress

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.gradle.plugin
 
-import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
@@ -43,7 +42,9 @@ import java.util.*
 import java.util.concurrent.Callable
 
 abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>(
-    private val buildOutputCleanupRegistry: BuildOutputCleanupRegistry
+    private val buildOutputCleanupRegistry: BuildOutputCleanupRegistry,
+    protected val createDefaultSourceSets: Boolean,
+    protected val createTestCompilation: Boolean
 ) {
     open fun configureTarget(
         target: KotlinTargetType
@@ -71,14 +72,16 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
             }
         }
 
-        platformTarget.compilations.create(KotlinCompilation.TEST_COMPILATION_NAME).apply {
+        if (createTestCompilation) {
-            compileDependencyFiles = project.files(main.output, project.configurations.maybeCreate(compileDependencyConfigurationName))
+            platformTarget.compilations.create(KotlinCompilation.TEST_COMPILATION_NAME).apply {
+                compileDependencyFiles = project.files(main.output, project.configurations.maybeCreate(compileDependencyConfigurationName))
 
-            if (this is KotlinCompilationToRunnableFiles) {
+                if (this is KotlinCompilationToRunnableFiles) {
-                runtimeDependencyFiles = project.files(output, main.output, project.configurations.maybeCreate(runtimeDependencyConfigurationName))
+                    runtimeDependencyFiles =
+                            project.files(output, main.output, project.configurations.maybeCreate(runtimeDependencyConfigurationName))
+                }
             }
         }
-
     }
 
     protected fun configureCompilationDefaults(target: KotlinTargetType) {
@@ -87,8 +90,10 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
         target.compilations.all { compilation ->
             defineConfigurationsForCompilation(compilation, target, project.configurations)
 
-            project.kotlinExtension.sourceSets.maybeCreate(compilation.defaultSourceSetName).also { sourceSet ->
+            if (createDefaultSourceSets) {
-                compilation.source(sourceSet) // also adds dependencies, requires the configurations for target and source set to exist at this point
+                project.kotlinExtension.sourceSets.maybeCreate(compilation.defaultSourceSetName).also { sourceSet ->
+                    compilation.source(sourceSet) // also adds dependencies, requires the configurations for target and source set to exist at this point
+                }
             }
 
             if (compilation is KotlinCompilationWithResources) {
@@ -101,7 +106,7 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
     }
 
     protected fun configureTest(target: KotlinTarget) {
-        val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME) as? KotlinCompilationToRunnableFiles
+        val testCompilation = target.compilations.findByName(KotlinCompilation.TEST_COMPILATION_NAME) as? KotlinCompilationToRunnableFiles
             ?: return // Otherwise, there is no runtime classpath
 
         target.project.tasks.create(lowerCamelCaseName(target.targetName, testTaskNameSuffix), Test::class.java).apply {
@@ -157,19 +162,11 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
 
         val defaultConfiguration = configurations.maybeCreate(target.defaultConfigurationName)
         val mainCompilation = target.compilations.maybeCreate(KotlinCompilation.MAIN_COMPILATION_NAME)
-        val testCompilation = target.compilations.maybeCreate(KotlinCompilation.TEST_COMPILATION_NAME)
 
         val compileConfiguration = configurations.maybeCreate(mainCompilation.deprecatedCompileConfigurationName)
         val implementationConfiguration = configurations.maybeCreate(mainCompilation.implementationConfigurationName)
 
         val runtimeOnlyConfiguration = configurations.maybeCreate(mainCompilation.runtimeOnlyConfigurationName)
-        val compileTestsConfiguration = configurations.maybeCreate(testCompilation.deprecatedCompileConfigurationName)
-        val testImplementationConfiguration = configurations.maybeCreate(testCompilation.implementationConfigurationName)
-        val testRuntimeOnlyConfiguration = configurations.maybeCreate(testCompilation.runtimeOnlyConfigurationName)
-
-        compileTestsConfiguration.extendsFrom(compileConfiguration)
-        testImplementationConfiguration.extendsFrom(implementationConfiguration)
-        testRuntimeOnlyConfiguration.extendsFrom(runtimeOnlyConfiguration)
 
         configurations.maybeCreate(target.apiElementsConfigurationName).apply {
             description = "API elements for main."
@@ -198,25 +195,38 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
             usesPlatformOf(target)
         }
 
-        if (mainCompilation is KotlinCompilationToRunnableFiles && testCompilation is KotlinCompilationToRunnableFiles) {
-            val runtimeConfiguration = configurations.maybeCreate(mainCompilation.deprecatedRuntimeConfigurationName)
-            val testRuntimeConfiguration = configurations.maybeCreate(testCompilation.deprecatedRuntimeConfigurationName)
-            testRuntimeConfiguration.extendsFrom(runtimeConfiguration)
-        }
-
         defaultConfiguration.extendsFrom(runtimeElementsConfiguration).usesPlatformOf(target)
+
+        if (createTestCompilation) {
+            val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME)
+            val compileTestsConfiguration = configurations.maybeCreate(testCompilation.deprecatedCompileConfigurationName)
+            val testImplementationConfiguration = configurations.maybeCreate(testCompilation.implementationConfigurationName)
+            val testRuntimeOnlyConfiguration = configurations.maybeCreate(testCompilation.runtimeOnlyConfigurationName)
+
+            compileTestsConfiguration.extendsFrom(compileConfiguration)
+            testImplementationConfiguration.extendsFrom(implementationConfiguration)
+            testRuntimeOnlyConfiguration.extendsFrom(runtimeOnlyConfiguration)
+
+            if (mainCompilation is KotlinCompilationToRunnableFiles && testCompilation is KotlinCompilationToRunnableFiles) {
+                val runtimeConfiguration = configurations.maybeCreate(mainCompilation.deprecatedRuntimeConfigurationName)
+                val testRuntimeConfiguration = configurations.maybeCreate(testCompilation.deprecatedRuntimeConfigurationName)
+                testRuntimeConfiguration.extendsFrom(runtimeConfiguration)
+            }
+        }
     }
 
     protected fun configureBuild(target: KotlinTargetType) {
         val project = target.project
 
-        val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME)
         val buildNeeded = project.tasks.getByName(JavaBasePlugin.BUILD_NEEDED_TASK_NAME)
         val buildDependent = project.tasks.getByName(JavaBasePlugin.BUILD_DEPENDENTS_TASK_NAME)
 
-        if (testCompilation is KotlinCompilationToRunnableFiles) {
+        if (createTestCompilation) {
-            addDependsOnTaskInOtherProjects(buildNeeded, true, testCompilation.deprecatedRuntimeConfigurationName)
+            val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME)
-            addDependsOnTaskInOtherProjects(buildDependent, false, testCompilation.deprecatedRuntimeConfigurationName)
+            if (testCompilation is KotlinCompilationToRunnableFiles) {
+                addDependsOnTaskInOtherProjects(buildNeeded, true, testCompilation.deprecatedRuntimeConfigurationName)
+                addDependsOnTaskInOtherProjects(buildDependent, false, testCompilation.deprecatedRuntimeConfigurationName)
+            }
         }
     }
 
@@ -309,8 +319,14 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
 }
 
 open class KotlinTargetConfigurator<KotlinCompilationType: KotlinCompilation>(
-    buildOutputCleanupRegistry: BuildOutputCleanupRegistry
+    buildOutputCleanupRegistry: BuildOutputCleanupRegistry,
-) : AbstractKotlinTargetConfigurator<KotlinOnlyTarget<KotlinCompilationType>>(buildOutputCleanupRegistry) {
+    createDefaultSourceSets: Boolean,
+    createTestCompilation: Boolean
+) : AbstractKotlinTargetConfigurator<KotlinOnlyTarget<KotlinCompilationType>>(
+    buildOutputCleanupRegistry,
+    createDefaultSourceSets,
+    createTestCompilation
+) {
 
     override fun configureArchivesAndComponent(target: KotlinOnlyTarget<KotlinCompilationType>) {
         val project = target.project
@@ -358,7 +374,11 @@ open class KotlinTargetConfigurator<KotlinCompilationType: KotlinCompilation>(
 
 open class KotlinNativeTargetConfigurator(
     buildOutputCleanupRegistry: BuildOutputCleanupRegistry
-) : AbstractKotlinTargetConfigurator<KotlinNativeTarget>(buildOutputCleanupRegistry) {
+) : AbstractKotlinTargetConfigurator<KotlinNativeTarget>(
+    buildOutputCleanupRegistry,
+    createDefaultSourceSets = true,
+    createTestCompilation = true
+) {
 
     private val Collection<*>.isDimensionVisible: Boolean
         get() = size > 1

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

@@ -115,11 +115,11 @@ class KotlinMultiplatformPlugin(
 
         targets.all { target ->
             target.compilations.findByName(KotlinCompilation.MAIN_COMPILATION_NAME)?.let { mainCompilation ->
-                sourceSets.maybeCreate(mainCompilation.defaultSourceSetName).dependsOn(production)
+                sourceSets.findByName(mainCompilation.defaultSourceSetName)?.dependsOn(production)
             }
 
             target.compilations.findByName(KotlinCompilation.TEST_COMPILATION_NAME)?.let { testCompilation ->
-                sourceSets.maybeCreate(testCompilation.defaultSourceSetName).dependsOn(test)
+                sourceSets.findByName(testCompilation.defaultSourceSetName)?.dependsOn(test)
             }
         }
     }

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

@@ -85,13 +85,15 @@ abstract class AbstractKotlinCompilation(
                         }
 
                         if (sourceSet.name != defaultSourceSetName) {
-                            // Temporary solution for checking consistency across source sets participating in a compilation that may
+                            kotlinExtension.sourceSets.findByName(defaultSourceSetName)?.let { defaultSourceSet ->
-                            // not be interconnected with the dependsOn relation: check the settings as if the default source set of
+                                // Temporary solution for checking consistency across source sets participating in a compilation that may
-                            // the compilation depends on the one added to the compilation:
+                                // not be interconnected with the dependsOn relation: check the settings as if the default source set of
-                            defaultSourceSetLanguageSettingsChecker.runAllChecks(
+                                // the compilation depends on the one added to the compilation:
-                                kotlinExtension.sourceSets.getByName(defaultSourceSetName),
+                                defaultSourceSetLanguageSettingsChecker.runAllChecks(
-                                sourceSet
+                                    defaultSourceSet,
-                            )
+                                    sourceSet
+                                )
+                            }
                         }
                     }
                 }

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

@@ -11,7 +11,11 @@ import org.gradle.api.plugins.JavaPlugin
 import org.gradle.internal.cleanup.BuildOutputCleanupRegistry
 import org.gradle.internal.reflect.Instantiator
 import org.jetbrains.kotlin.compilerRunner.*
+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.source.KotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.sources.applyLanguageSettingsToKotlinTask
 import org.jetbrains.kotlin.gradle.tasks.AndroidTasksProvider
 import org.jetbrains.kotlin.gradle.tasks.KonanCompilerDownloadTask
 import org.jetbrains.kotlin.gradle.tasks.KonanCompilerDownloadTask.Companion.KONAN_DOWNLOAD_TASK_NAME
@@ -23,10 +27,13 @@ abstract class KotlinOnlyTargetPreset<T : KotlinCompilation>(
     protected val project: Project,
     private val instantiator: Instantiator,
     private val fileResolver: FileResolver,
-    private val buildOutputCleanupRegistry: BuildOutputCleanupRegistry,
+    protected val buildOutputCleanupRegistry: BuildOutputCleanupRegistry,
     protected val kotlinPluginVersion: String
 ) : KotlinTargetPreset<KotlinOnlyTarget<T>> {
 
+    protected open fun createKotlinTargetConfigurator(): KotlinTargetConfigurator<T> =
+        KotlinTargetConfigurator(buildOutputCleanupRegistry, createDefaultSourceSets = true, createTestCompilation = true)
+
     override fun createTarget(name: String): KotlinOnlyTarget<T> {
         val result = KotlinOnlyTarget<T>(project, platformType).apply {
             targetName = name
@@ -36,7 +43,7 @@ abstract class KotlinOnlyTargetPreset<T : KotlinCompilation>(
             compilations = project.container(compilationFactory.itemClass, compilationFactory)
         }
 
-        KotlinTargetConfigurator<T>(buildOutputCleanupRegistry).configureTarget(result)
+        createKotlinTargetConfigurator().configureTarget(result)
 
         result.compilations.all { compilation ->
             buildCompilationProcessor(compilation).run()
@@ -84,6 +91,23 @@ class KotlinMetadataTargetPreset(
     companion object {
         const val PRESET_NAME = "metadata"
     }
+
+    override fun createKotlinTargetConfigurator(): KotlinTargetConfigurator<KotlinCommonCompilation> =
+        KotlinTargetConfigurator(buildOutputCleanupRegistry, createDefaultSourceSets = false, createTestCompilation = false)
+
+    override fun createTarget(name: String): KotlinOnlyTarget<KotlinCommonCompilation> =
+        super.createTarget(name).apply {
+            val mainCompilation = compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+            val commonMainSourceSet = project.kotlinExtension.sourceSets.getByName(KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME)
+
+            mainCompilation.source(commonMainSourceSet)
+
+            project.afterEvaluate {
+                // Since there's no default source set, apply language settings from commonMain:
+                val compileKotlinMetadata = project.tasks.getByName(mainCompilation.compileKotlinTaskName) as KotlinCompile<*>
+                applyLanguageSettingsToKotlinTask(commonMainSourceSet.languageSettings, compileKotlinMetadata)
+            }
+        }
 }
 
 class KotlinJvmTargetPreset(

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/TasksProvider.kt

@@ -52,7 +52,9 @@ internal open class KotlinTasksProvider(val targetName: String) {
         mapKotlinTaskProperties(project, kotlinTask)
 
         project.whenEvaluated {
-            val languageSettings = project.kotlinExtension.sourceSets.getByName(compilation.defaultSourceSetName).languageSettings
+            val languageSettings = project.kotlinExtension.sourceSets.findByName(compilation.defaultSourceSetName)?.languageSettings
+                ?: return@whenEvaluated
+
             kotlinTask as org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>
             applyLanguageSettingsToKotlinTask(languageSettings, kotlinTask)
         }