Drop convention usage on accessing Java SourceSet

This is only valid for Gradle 7.1+, so new plugin variant was added - "gradle71". For Gradle <=7.0 old convention approach is still used. ^KT-47047 In Progress
2022-05-31 22:30:41 +02:00
parent f192c2a541
commit c495c07b1a
20 changed files with 421 additions and 84 deletions
@@ -44,7 +44,7 @@ enum class GradlePluginVariant(
 ) {
    GRADLE_MIN("main", "6.7", "6.9"),
    GRADLE_70("gradle70", "7.0", "7.0"),
-    //GRADLE_71("gradle71", "7.1", "7.1"),
+    GRADLE_71("gradle71", "7.1", "7.1"),
 }

 /**
@@ -55,10 +55,17 @@ tasks.named("jar") {
 }

 if (!kotlinBuildProperties.isInJpsBuildIdeaSync) {
-    // Used for Gradle 7.0+ versions
+    // Used for Gradle 7.0 version
    val gradle70SourceSet = createGradlePluginVariant(
        GradlePluginVariant.GRADLE_70,
        commonSourceSet = commonSourceSet
    )
    publishShadowedJar(gradle70SourceSet, commonSourceSet)
+
+    // Used for Gradle 7.1+ versions
+    val gradle71SourceSet = createGradlePluginVariant(
+        GradlePluginVariant.GRADLE_71,
+        commonSourceSet = commonSourceSet
+    )
+    publishShadowedJar(gradle71SourceSet, commonSourceSet)
 }
@@ -19,13 +19,20 @@ extensions.extraProperties["kotlin.stdlib.default.dependency"] = "false"
 val commonSourceSet = createGradleCommonSourceSet()
 reconfigureMainSourcesSetForGradlePlugin(commonSourceSet)

-// Used for Gradle 7.0+ versions
+// Used for Gradle 7.0 version
 createGradlePluginVariant(
    GradlePluginVariant.GRADLE_70,
    commonSourceSet = commonSourceSet,
    isGradlePlugin = false
 )

+// Used for Gradle 7.1+ versions
+createGradlePluginVariant(
+    GradlePluginVariant.GRADLE_71,
+    commonSourceSet = commonSourceSet,
+    isGradlePlugin = false
+)
+
 publishing {
    publications {
        register<MavenPublication>(DEFAULT_MAIN_PUBLICATION_NAME) {
@@ -442,7 +442,11 @@ class KotlinGradleIT : KGPBaseTest() {
            buildGradle.appendText(
                """
                                    
-                archivesBaseName = 'a/really\\tricky\n\rmodule\tname'
+                archivesBaseName = 'a/really\\trick\n\rmodule\tname'
+                
+                tasks.withType(Jar.class).configureEach {
+                    archiveBaseName.set('typeAlias')
+                }
                """.trimIndent()
            )

@@ -211,15 +211,18 @@ class SimpleKotlinGradleIT : KGPBaseTest() {
    }

    @DisplayName("Proper Gradle plugin variant is used")
-    @GradleTestVersions(additionalVersions = [TestVersions.Gradle.G_7_0])
+    @GradleTestVersions(
+        additionalVersions = [TestVersions.Gradle.G_7_0],
+        maxVersion = TestVersions.Gradle.G_7_1
+    )
    @GradleTest
    internal fun pluginVariantIsUsed(gradleVersion: GradleVersion) {
        project("kotlinProject", gradleVersion) {
            build("tasks") {
-                val expectedVariant = if (gradleVersion < GradleVersion.version("7.0")) {
-                    "main"
-                } else {
-                    "gradle70"
+                val expectedVariant = when (gradleVersion) {
+                    GradleVersion.version(TestVersions.Gradle.G_7_1) -> "gradle71"
+                    GradleVersion.version(TestVersions.Gradle.G_7_0) -> "gradle70"
+                    else -> "main"
                }

                assertOutputContains("Using Kotlin Gradle Plugin $expectedVariant variant")
@@ -9,7 +9,6 @@ import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.logging.Logger
-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.gradle.jvm.tasks.Jar
 import org.gradle.workers.WorkQueue
@@ -27,9 +26,11 @@ import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.logging.kotlinInfo
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskLoggers
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
+import org.jetbrains.kotlin.gradle.plugin.variantImplementationFactory
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.utils.IsolatedKotlinClasspathClassCastException
 import org.jetbrains.kotlin.gradle.utils.archivePathCompatible
@@ -310,7 +311,7 @@ internal open class GradleCompilerRunner(
                        }
                    }
                } else if (task is InspectClassesForMultiModuleIC) {
-                    jarToClassListFile[File(task.archivePath.get())] = task.classesListFile
+                    jarToClassListFile[File(task.archivePath.get())] = task.classesListFile.get().asFile
                }
            }

@@ -360,10 +361,15 @@ internal open class GradleCompilerRunner(
            }
        }

-        private fun jarForSourceSet(project: Project, sourceSetName: String): File? {
-            val javaConvention = project.convention.findPlugin(JavaPluginConvention::class.java)
-                ?: return null
-            val sourceSet = javaConvention.sourceSets.findByName(sourceSetName) ?: return null
+        private fun jarForSourceSet(
+            project: Project,
+            sourceSetName: String
+        ): File? {
+            val sourceSets = project.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                .getInstance(project)
+                .sourceSetsIfAvailable ?: return null
+            val sourceSet = sourceSets.findByName(sourceSetName) ?: return null
+
            val jarTask = project.tasks.findByName(sourceSet.jarTaskName) as? Jar
            return jarTask?.archiveFile?.get()?.asFile
        }
@@ -16,15 +16,14 @@

 package org.jetbrains.kotlin.gradle.plugin

-import com.android.build.gradle.BaseExtension
 import org.gradle.api.*
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.file.SourceDirectorySet
-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.logging.kotlinWarn
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.utils.SingleWarningPerBuild
 import org.jetbrains.kotlin.gradle.utils.androidPluginIds
@@ -118,8 +117,9 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
                addCommonSourceSetToPlatformSourceSet(commonSourceSet, platformProject)

                // Workaround for older versions of Kotlin/Native overriding the old signature
-                commonProject.convention.findPlugin(JavaPluginConvention::class.java)
-                    ?.sourceSets
+                commonProject.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                    .getInstance(commonProject)
+                    .sourceSetsIfAvailable
                    ?.findByName(commonSourceSet.name)
                    ?.let { javaSourceSet ->
                        @Suppress("DEPRECATION")
@@ -20,14 +20,12 @@ import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.logging.Logging
 import org.gradle.api.plugins.InvalidPluginException
 import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.provider.Provider
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPom
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.jvm.tasks.Jar
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
@@ -37,6 +35,7 @@ import org.jetbrains.kotlin.gradle.internal.checkAndroidAnnotationProcessorDepen
 import org.jetbrains.kotlin.gradle.internal.customizeKotlinDependencies
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.model.builder.KotlinModelBuilder
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.internal.MavenPluginConfigurator
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
@@ -103,7 +102,10 @@ internal abstract class KotlinSourceSetProcessor<T : AbstractKotlinCompile<*>>(
            return (compilation as? KotlinWithJavaCompilation<*>)?.javaSourceSet
                ?: kotlinCompilation.owner.let {
                    if (it is KotlinJvmTarget && it.withJavaEnabled && compilation is KotlinJvmCompilation)
-                        project.convention.getPlugin(JavaPluginConvention::class.java).sourceSets.maybeCreate(compilation.name)
+                        project.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                            .getInstance(project)
+                            .sourceSets
+                            .maybeCreate(compilation.name)
                    else null
                }
        }
@@ -447,14 +449,35 @@ internal abstract class AbstractKotlinPlugin(
                )
                return
            }
-            val inspectTask =
-                project.registerTask<InspectClassesForMultiModuleIC>("inspectClassesForKotlinIC") {
-                    it.sourceSetName = SourceSet.MAIN_SOURCE_SET_NAME
-                    it.archivePath.set(project.provider { jarTask.get().archivePathCompatible.canonicalPath })
-                    it.archiveName.set(project.provider { jarTask.get().archiveFileName.get() })
-                    it.dependsOn(classesTask)
-                }
-            jarTask.dependsOn(inspectTask)
+            val inspectTask = project.registerTask<InspectClassesForMultiModuleIC>("inspectClassesForKotlinIC") { inspectTask ->
+                inspectTask.archivePath.set(jarTask.map { it.archivePathCompatible.canonicalPath })
+                inspectTask.archivePath.disallowChanges()
+
+                inspectTask.sourceSetName.set(SourceSet.MAIN_SOURCE_SET_NAME)
+                inspectTask.sourceSetName.disallowChanges()
+
+                inspectTask.classesListFile.set(
+                    project.layout.file(
+                        (project.kotlinExtension as KotlinSingleJavaTargetExtension)
+                            .target
+                            .defaultArtifactClassesListFile
+                    )
+                )
+                inspectTask.classesListFile.disallowChanges()
+
+                val sourceSetClassesDir = project.gradle
+                    .variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                    .getInstance(project)
+                    .sourceSetsIfAvailable
+                    ?.findByName(SourceSet.MAIN_SOURCE_SET_NAME)
+                    ?.output
+                    ?.classesDirs
+                    ?: project.objects.fileCollection()
+                inspectTask.sourceSetOutputClassesDir.from(sourceSetClassesDir).disallowChanges()
+
+                inspectTask.dependsOn(classesTask)
+            }
+            classesTask.configure { it.finalizedBy(inspectTask) }
        }

        internal fun setUpJavaSourceSets(
@@ -462,7 +485,11 @@ internal abstract class AbstractKotlinPlugin(
            duplicateJavaSourceSetsAsKotlinSourceSets: Boolean = true
        ) {
            val project = kotlinTarget.project
-            val javaSourceSets = project.convention.getPlugin(JavaPluginConvention::class.java).sourceSets
+            val javaSourceSets = project
+                .gradle
+                .variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                .getInstance(project)
+                .sourceSets

            val kotlinSourceSetDslName = when (kotlinTarget.platformType) {
                KotlinPlatformType.js -> KOTLIN_JS_DSL_NAME
@@ -29,6 +29,8 @@ import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.internal.KOTLIN_COMPILER_EMBEDDABLE
 import org.jetbrains.kotlin.gradle.internal.KOTLIN_MODULE_GROUP
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
+import org.jetbrains.kotlin.gradle.plugin.internal.DefaultJavaSourceSetsAccessorVariantFactory
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.internal.MavenPluginConfigurator
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
@@ -189,6 +191,11 @@ abstract class KotlinBasePluginWrapper : DefaultKotlinBasePlugin() {
            MavenPluginConfigurator.MavenPluginConfiguratorVariantFactory::class,
            MavenPluginConfigurator.DefaultMavenPluginConfiguratorVariantFactory()
        )
+
+        factories.putIfAbsent(
+            JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory::class,
+            DefaultJavaSourceSetsAccessorVariantFactory()
+        )
    }

    internal open fun createTestRegistry(project: Project) = KotlinTestsRegistry(project)
@@ -0,0 +1,38 @@
+/*
+ * 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.internal
+
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtensionContainer
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.SourceSetContainer
+import org.jetbrains.kotlin.gradle.plugin.VariantImplementationFactories
+import org.jetbrains.kotlin.gradle.utils.findByType
+import org.jetbrains.kotlin.gradle.utils.getByType
+
+interface JavaSourceSetsAccessor {
+    val sourceSets: SourceSetContainer
+
+    val sourceSetsIfAvailable: SourceSetContainer?
+
+    interface JavaSourceSetsAccessorVariantFactory : VariantImplementationFactories.VariantImplementationFactory {
+        fun getInstance(project: Project): JavaSourceSetsAccessor
+    }
+}
+
+internal class DefaultJavaSourceSetsAccessorVariantFactory : JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory {
+    override fun getInstance(project: Project): JavaSourceSetsAccessor = DefaultJavaSourceSetsAccessor(project.extensions)
+}
+
+internal class DefaultJavaSourceSetsAccessor(
+    private val projectExtensions: ExtensionContainer
+) : JavaSourceSetsAccessor {
+    override val sourceSets: SourceSetContainer
+        get() = projectExtensions.getByType<JavaPluginExtension>().sourceSets
+
+    override val sourceSetsIfAvailable: SourceSetContainer?
+        get() = projectExtensions.findByType<JavaPluginExtension>()?.sourceSets
+}
@@ -17,13 +17,13 @@ import org.gradle.api.artifacts.transform.TransformOutputs
 import org.gradle.api.artifacts.transform.TransformParameters
 import org.gradle.api.attributes.Attribute
 import org.gradle.api.file.FileSystemLocation
-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.provider.Provider
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.internal.KaptGenerateStubsTask
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinNativeCompilation
 import org.jetbrains.kotlin.gradle.scripting.ScriptingExtension
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
@@ -53,8 +53,12 @@ class ScriptingGradleSubplugin : Plugin<Project> {
        project.plugins.apply(ScriptingKotlinGradleSubplugin::class.java)

        project.afterEvaluate {
-            val javaPluginConvention = project.convention.findPlugin(JavaPluginConvention::class.java)
-            if (javaPluginConvention?.sourceSets?.isEmpty() == false) {
+            val javaSourceSets = project
+                .gradle
+                .variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                .getInstance(project)
+                .sourceSetsIfAvailable
+            if (javaSourceSets?.isEmpty() == false) {

                val configureAction: (KotlinCompile) -> (Unit) = ca@{ task ->

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

-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
+import org.jetbrains.kotlin.gradle.plugin.variantImplementationFactory
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget

 open class KotlinJvmCompilation(
@@ -31,7 +32,9 @@ open class KotlinJvmCompilation(
    val compileJavaTaskProvider: TaskProvider<out JavaCompile>?
        get() = if (target.withJavaEnabled) {
            val project = target.project
-            val javaSourceSets = project.convention.getPlugin(JavaPluginConvention::class.java).sourceSets
+            val javaSourceSets = project.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+                .getInstance(project)
+                .sourceSets
            val javaSourceSet = javaSourceSets.getByName(compilationPurpose)
            project.tasks.withType(JavaCompile::class.java).named(javaSourceSet.compileJavaTaskName)
        } else null
@@ -11,8 +11,8 @@ import org.gradle.api.Project
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.testing.Test
 import org.gradle.jvm.tasks.Jar
@@ -20,6 +20,7 @@ import org.gradle.language.jvm.tasks.ProcessResources
 import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTarget
 import org.jetbrains.kotlin.gradle.tasks.withType
@@ -55,7 +56,9 @@ open class KotlinJvmTarget @Inject constructor(
        withJavaEnabled = true

        project.plugins.apply(JavaPlugin::class.java)
-        val javaPluginConvention = project.convention.getPlugin(JavaPluginConvention::class.java)
+        val javaSourceSets = project.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
+            .getInstance(project)
+            .sourceSets
        AbstractKotlinPlugin.setUpJavaSourceSets(this, duplicateJavaSourceSetsAsKotlinSourceSets = false)

        // Below, some effort is made to ensure that a user or 3rd-party plugin that inspects or interacts
@@ -64,7 +67,7 @@ open class KotlinJvmTarget @Inject constructor(
        // * the relevant dependencies for Java and Kotlin are in sync,
        // * the Java outputs contain the outputs produced by Kotlin as well

-        javaPluginConvention.sourceSets.all { javaSourceSet ->
+        javaSourceSets.all { javaSourceSet ->
            val compilation = compilations.getByName(javaSourceSet.name)
            val compileJavaTask = project.tasks.withType<AbstractCompile>().named(javaSourceSet.compileJavaTaskName)

@@ -90,7 +93,7 @@ open class KotlinJvmTarget @Inject constructor(
                project.configurations.findByName(outputConfigurationName)?.isCanBeConsumed = false
            }

-        disableJavaPluginTasks(javaPluginConvention)
+        disableJavaPluginTasks(javaSourceSets)
    }

    private fun setupJavaSourceSetSourcesAndResources(
@@ -122,12 +125,12 @@ open class KotlinJvmTarget @Inject constructor(
        }
    }

-    private fun disableJavaPluginTasks(javaPluginConvention: JavaPluginConvention) {
+    private fun disableJavaPluginTasks(javaSourceSet: SourceSetContainer) {
        // A 'normal' build should not do redundant job like running the tests twice or building two JARs,
        // so disable some tasks and just make them depend on the others:
        val targetJar = project.tasks.withType(Jar::class.java).named(artifactsTaskName)

-        project.tasks.withType(Jar::class.java).named(javaPluginConvention.sourceSets.getByName("main").jarTaskName) { javaJar ->
+        project.tasks.withType(Jar::class.java).named(javaSourceSet.getByName("main").jarTaskName) { javaJar ->
            (javaJar.source as? ConfigurableFileCollection)?.setFrom(targetJar.map { it.source })
            javaJar.archiveFileName.set(targetJar.flatMap { it.archiveFileName })
            javaJar.dependsOn(targetJar)
@@ -6,66 +6,45 @@
 package org.jetbrains.kotlin.gradle.tasks

 import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
-import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinSingleJavaTargetExtension
-import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
-import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
-import org.jetbrains.kotlin.gradle.utils.newProperty
 import java.io.File
+import javax.inject.Inject

-internal open class InspectClassesForMultiModuleIC : DefaultTask() {
+internal abstract class InspectClassesForMultiModuleIC @Inject constructor(
+    objects: ObjectFactory
+) : DefaultTask() {
    @get:Input
-    internal val archivePath = project.newProperty<String>()
+    internal abstract val archivePath: Property<String>

    @get:Input
-    internal val archiveName = project.newProperty<String>()
+    internal abstract val sourceSetName: Property<String>

-    @get:Input
-    lateinit var sourceSetName: String
-
-    @Suppress("MemberVisibilityCanBePrivate")
    @get:OutputFile
-    internal val classesListFile: File by lazy {
-        (project.kotlinExtension as KotlinSingleJavaTargetExtension).target.defaultArtifactClassesListFile.get()
-    }
+    internal abstract val classesListFile: RegularFileProperty

    @get:IgnoreEmptyDirectories
    @get:PathSensitive(PathSensitivity.ABSOLUTE)
    @get:InputFiles
-    internal val sourceSetOutputClassesDir by lazy {
-        project.convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets?.findByName(sourceSetName)?.output?.classesDirs
-    }
+    internal abstract val sourceSetOutputClassesDir: ConfigurableFileCollection

-    @get:Internal
-    internal val fileTrees
-        get() = sourceSetOutputClassesDir?.map {
-            objects.fileTree().from(it).include("**/*.class")
-        }
-
-    @get:Internal
-    internal val objects = project.objects
-
-    @Suppress("MemberVisibilityCanBePrivate")
    @get:PathSensitive(PathSensitivity.ABSOLUTE)
    @get:IgnoreEmptyDirectories
    @get:InputFiles
-    internal val classFiles: FileCollection
-        get() {
-            if (sourceSetOutputClassesDir != null) {
-                return objects.fileCollection().from(fileTrees)
-            }
-            return objects.fileCollection()
-        }
+    internal val classFiles: FileCollection = objects.fileCollection()
+        .from({ sourceSetOutputClassesDir.asFileTree.matching { it.include("**/*.class") } })

    @TaskAction
    fun run() {
-        classesListFile.parentFile.mkdirs()
-        val text = classFiles.map { it.absolutePath }.sorted().joinToString(File.pathSeparator)
-        classesListFile.writeText(text)
+        with(classesListFile.get().asFile) {
+            parentFile.mkdirs()
+            writeText(
+                classFiles.map { it.absolutePath }.sorted().joinToString(File.pathSeparator)
+            )
+        }
    }
-
-    private fun sanitizeFileName(candidate: String): String =
-        candidate.filter { it.isLetterOrDigit() }
-}
+}
@@ -0,0 +1,12 @@
+/*
+ * 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.utils
+
+import org.gradle.api.plugins.ExtensionContainer
+
+internal inline fun <reified T> ExtensionContainer.findByType(): T? = findByType(T::class.java)
+
+internal inline fun <reified T> ExtensionContainer.getByType(): T = getByType(T::class.java)
@@ -11,6 +11,8 @@ import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.model.ObjectFactory
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessorG70
 import javax.inject.Inject

 private const val PLUGIN_VARIANT_NAME = "gradle70"
@@ -19,18 +21,33 @@ open class KotlinPluginWrapper @Inject constructor(
    registry: ToolingModelBuilderRegistry
 ) : AbstractKotlinPluginWrapper(registry) {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

 open class KotlinCommonPluginWrapper @Inject constructor(
    registry: ToolingModelBuilderRegistry
 ) : AbstractKotlinCommonPluginWrapper(registry) {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

 open class KotlinAndroidPluginWrapper @Inject constructor(
    registry: ToolingModelBuilderRegistry
 ) : AbstractKotlinAndroidPluginWrapper(registry) {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

@Suppress("DEPRECATION_ERROR")
@@ -38,15 +55,30 @@ open class Kotlin2JsPluginWrapper @Inject constructor(
    registry: ToolingModelBuilderRegistry
 ) : AbstractKotlin2JsPluginWrapper(registry) {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

 open class KotlinMultiplatformPluginWrapper : AbstractKotlinMultiplatformPluginWrapper() {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

@Suppress("unused")
 open class KotlinJsPluginWrapper : AbstractKotlinJsPluginWrapper() {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

@Suppress("unused")
@@ -54,6 +86,11 @@ open class KotlinPm20PluginWrapper @Inject constructor(
    objectFactory: ObjectFactory
 ) : AbstractKotlinPm20PluginWrapper(objectFactory) {
    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
 }

 open class KotlinPlatformJvmPlugin : KotlinPlatformImplementationPluginBase("jvm") {
@@ -95,3 +132,9 @@ open class KotlinPlatformCommonPlugin : KotlinPlatformPluginBase("common") {
        project.applyPlugin<KotlinCommonPluginWrapper>()
    }
 }
+
+private fun Project.registerVariantImplementations() {
+    val factories = VariantImplementationFactories.get(gradle)
+    factories[JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory::class] =
+        JavaSourceSetsAccessorG70.JavaSourceSetAccessorVariantFactoryG70()
+}
@@ -0,0 +1,25 @@
+/*
+ * 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.internal
+
+import org.gradle.api.Project
+import org.gradle.api.plugins.Convention
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.SourceSetContainer
+
+internal class JavaSourceSetsAccessorG70(
+    private val convention: Convention
+) : JavaSourceSetsAccessor {
+    override val sourceSets: SourceSetContainer
+        get() = convention.getPlugin(JavaPluginConvention::class.java).sourceSets
+
+    override val sourceSetsIfAvailable: SourceSetContainer?
+        get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
+
+    internal class JavaSourceSetAccessorVariantFactoryG70 : JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory {
+        override fun getInstance(project: Project): JavaSourceSetsAccessor = JavaSourceSetsAccessorG70(project.convention)
+    }
+}
@@ -0,0 +1,140 @@
+/*
+ * 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
+
+import com.android.build.gradle.BaseExtension
+import org.gradle.api.Named
+import org.gradle.api.NamedDomainObjectContainer
+import org.gradle.api.Project
+import org.gradle.api.model.ObjectFactory
+import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
+import javax.inject.Inject
+
+private const val PLUGIN_VARIANT_NAME = "gradle71"
+
+open class KotlinPluginWrapper @Inject constructor(
+    registry: ToolingModelBuilderRegistry
+) : AbstractKotlinPluginWrapper(registry) {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinCommonPluginWrapper @Inject constructor(
+    registry: ToolingModelBuilderRegistry
+) : AbstractKotlinCommonPluginWrapper(registry) {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinAndroidPluginWrapper @Inject constructor(
+    registry: ToolingModelBuilderRegistry
+) : AbstractKotlinAndroidPluginWrapper(registry) {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+@Suppress("DEPRECATION_ERROR")
+open class Kotlin2JsPluginWrapper @Inject constructor(
+    registry: ToolingModelBuilderRegistry
+) : AbstractKotlin2JsPluginWrapper(registry) {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinMultiplatformPluginWrapper : AbstractKotlinMultiplatformPluginWrapper() {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinJsPluginWrapper : AbstractKotlinJsPluginWrapper() {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinPm20PluginWrapper @Inject constructor(
+    objectFactory: ObjectFactory
+) : AbstractKotlinPm20PluginWrapper(objectFactory) {
+
+    override val pluginVariant: String = PLUGIN_VARIANT_NAME
+
+    override fun apply(project: Project) {
+        project.registerVariantImplementations()
+        super.apply(project)
+    }
+}
+
+open class KotlinPlatformJvmPlugin : KotlinPlatformImplementationPluginBase("jvm") {
+    override fun apply(project: Project) {
+        project.applyPlugin<KotlinPluginWrapper>()
+        super.apply(project)
+    }
+}
+
+open class KotlinPlatformJsPlugin : KotlinPlatformImplementationPluginBase("js") {
+    override fun apply(project: Project) {
+        @Suppress("DEPRECATION_ERROR")
+        project.applyPlugin<Kotlin2JsPluginWrapper>()
+        super.apply(project)
+    }
+}
+
+open class KotlinPlatformAndroidPlugin : KotlinPlatformImplementationPluginBase("android") {
+    override fun apply(project: Project) {
+        project.applyPlugin<KotlinAndroidPluginWrapper>()
+        super.apply(project)
+    }
+
+    override fun namedSourceSetsContainer(project: Project): NamedDomainObjectContainer<*> =
+        (project.extensions.getByName("android") as BaseExtension).sourceSets
+
+    override fun addCommonSourceSetToPlatformSourceSet(commonSourceSet: Named, platformProject: Project) {
+        val androidExtension = platformProject.extensions.getByName("android") as BaseExtension
+        val androidSourceSet = androidExtension.sourceSets.findByName(commonSourceSet.name) ?: return
+        val kotlinSourceSet = androidSourceSet.getConvention(KOTLIN_DSL_NAME) as? KotlinSourceSet
+            ?: return
+        kotlinSourceSet.kotlin.source(getKotlinSourceDirectorySetSafe(commonSourceSet)!!)
+    }
+}
+
+open class KotlinPlatformCommonPlugin : KotlinPlatformPluginBase("common") {
+    override fun apply(project: Project) {
+        warnAboutKotlin12xMppDeprecation(project)
+        project.applyPlugin<KotlinCommonPluginWrapper>()
+    }
+}
+
+@Suppress("unused")
+private fun Project.registerVariantImplementations() {}
@@ -11,6 +11,8 @@ import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.model.ObjectFactory
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessorG6
 import org.jetbrains.kotlin.gradle.plugin.internal.MavenPluginConfigurator
 import org.jetbrains.kotlin.gradle.plugin.internal.MavenPluginConfiguratorG6
 import javax.inject.Inject
@@ -142,4 +144,6 @@ private fun Project.registerVariantImplementations() {
    val factories = VariantImplementationFactories.get(gradle)
    factories[MavenPluginConfigurator.MavenPluginConfiguratorVariantFactory::class] =
        MavenPluginConfiguratorG6.Gradle6MavenPluginConfiguratorVariantFactory()
+    factories[JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory::class] =
+        JavaSourceSetsAccessorG6.JavaSourceSetAccessorVariantFactoryG70()
 }
@@ -0,0 +1,25 @@
+ /*
+ * 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.internal
+
+import org.gradle.api.Project
+import org.gradle.api.plugins.Convention
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.SourceSetContainer
+
+internal class JavaSourceSetsAccessorG6(
+    private val convention: Convention
+) : JavaSourceSetsAccessor {
+    override val sourceSets: SourceSetContainer
+        get() = convention.getPlugin(JavaPluginConvention::class.java).sourceSets
+
+    override val sourceSetsIfAvailable: SourceSetContainer?
+        get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
+
+    internal class JavaSourceSetAccessorVariantFactoryG70 : JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory {
+        override fun getInstance(project: Project): JavaSourceSetsAccessor = JavaSourceSetsAccessorG6(project.convention)
+    }
+}