[Gradle] Use Gradle properties for KAPT tasks

Use lazy properties to configure KAPT tasks and in the model builder.
Also, avoid eager dependency resolution of the kaptExternalClasspath
file collection.

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/Kapt3KotlinGradleSubplugin.kt

@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompileTaskData
 import org.jetbrains.kotlin.gradle.tasks.locateTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.utils.isConfigurationCacheAvailable
@@ -497,10 +496,21 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
             project.dependencies.add(classStructureIfIncremental.name, project.files(project.provider { kotlinCompile.get().classpath }))
         }
 
+        val kaptClasspathConfiguration = project.configurations.create("kaptClasspath_$taskName")
+            .setExtendsFrom(kaptClasspathConfigurations).also {
+                it.isVisible = false
+                it.isCanBeConsumed = false
+            }
+
         val kaptTaskProvider = project.registerTask(taskName, taskClass, emptyList()) { kaptTask ->
             kaptTask.useBuildCache = kaptExtension.useBuildCache
 
-            kaptTask.kotlinCompileTask = kotlinCompilation.compileKotlinTaskProvider.get() as KotlinCompile
+            val kotlinCompileTask = kotlinCompilation.compileKotlinTaskProvider.get() as KotlinCompile
+            if (kaptTask is KaptWithoutKotlincTask) {
+                KaptWithoutKotlincTask.Configurator(kotlinCompileTask).configure(kaptTask)
+            } else {
+                KaptWithKotlincTask.Configurator(kotlinCompileTask).configure(kaptTask as KaptWithKotlincTask)
+            }
 
             kaptTask.stubsDir.set(getKaptStubsDir())
 
@@ -512,12 +522,13 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
             kaptTask.isIncremental = project.isIncrementalKapt()
 
             if (kaptTask.isIncremental) {
-                kaptTask.incAptCache.set(getKaptIncrementalAnnotationProcessingCache())
+                kaptTask.incAptCache.fileValue(getKaptIncrementalAnnotationProcessingCache()).disallowChanges()
-                kaptTask.localState.register(kaptTask.incAptCache)
 
-                kaptTask.classpathStructure = classStructureIfIncremental!!.incoming.artifactView { viewConfig ->
+                kaptTask.classpathStructure.from(
-                    viewConfig.attributes.attribute(artifactType, CLASS_STRUCTURE_ARTIFACT_TYPE)
+                    classStructureIfIncremental!!.incoming.artifactView { viewConfig ->
-                }.files
+                        viewConfig.attributes.attribute(artifactType, CLASS_STRUCTURE_ARTIFACT_TYPE)
+                    }.files
+                ).disallowChanges()
 
                 if (kaptTask is KaptWithKotlincTask) {
                     kaptTask.pluginOptions.addPluginArgument(
@@ -530,24 +541,16 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
                 }
             }
 
-            val kaptClasspathConfiguration =
+            kaptTask.kaptClasspath.from(kaptClasspathConfiguration).disallowChanges()
-                project.configurations.create("kaptClasspath_" + kaptTask.name).setExtendsFrom(kaptClasspathConfigurations).also {
+            kaptTask.kaptExternalClasspath.from(kaptClasspathConfiguration.fileCollection { it is ExternalDependency })
-                    it.isVisible = false
+            kaptTask.kaptClasspathConfigurationNames.value(kaptClasspathConfigurations.map { it.name }).disallowChanges()
-                    it.isCanBeConsumed = false
-                }
-
-            kaptTask.kaptClasspath.from(kaptClasspathConfiguration)
-            kaptTask.kaptExternalClasspath.from(*kaptClasspathConfiguration.files { it is ExternalDependency }.toTypedArray())
-            kaptTask.kaptClasspathConfigurationNames.set(kaptClasspathConfigurations.map { it.name })
 
             KaptWithAndroid.androidVariantData(this)?.annotationProcessorOptionProviders?.let {
                 kaptTask.annotationProcessorOptionProviders.add(it)
             }
         }
 
-        kotlinCompilation.output.apply {
+        kotlinCompilation.output.classesDirs.from(kaptTaskProvider.map { it.destinationDir })
-            addClassesDir { project.files(classesOutputDir).builtBy(kaptTaskProvider) }
-        }
 
         kotlinCompilation.compileKotlinTaskProvider.configure {
             it as SourceTask
@@ -568,7 +571,8 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
                 if (javaCompile != null && "-source" !in result && "--source" !in result && "--release" !in result) {
                     val atLeast12Java =
                         if (isConfigurationCacheAvailable(project.gradle)) {
-                            val currentJavaVersion = JavaVersion.parse(project.providers.systemProperty("java.version").forUseAtConfigurationTime().get())
+                            val currentJavaVersion =
+                                JavaVersion.parse(project.providers.systemProperty("java.version").forUseAtConfigurationTime().get())
                             currentJavaVersion.feature >= 12
                         } else {
                             SystemInfo.isJavaVersionAtLeast(12, 0, 0)
@@ -644,26 +648,20 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
     private fun Kapt3SubpluginContext.createKaptGenerateStubsTask(): TaskProvider<KaptGenerateStubsTask> {
         val kaptTaskName = getKaptTaskName("kaptGenerateStubs")
 
-        KotlinCompileTaskData.register(kaptTaskName, kotlinCompilation).apply {
-            useModuleDetection.set(KotlinCompileTaskData.get(project, kotlinCompile.name).useModuleDetection)
-            destinationDir.set(project.provider { getKaptIncrementalDataDir() })
-        }
-
         val kaptTaskProvider = project.registerTask<KaptGenerateStubsTask>(kaptTaskName) { kaptTask ->
-            kaptTask.kotlinCompileTask = kotlinCompile.get()
+            KaptGenerateStubsTask.Configurator(kotlinCompile.get(), kotlinCompilation).configure(kaptTask)
 
             kaptTask.stubsDir.set(getKaptStubsDir())
-            kaptTask.setDestinationDir { getKaptIncrementalDataDir() }
+            kaptTask.destinationDirectory.set(getKaptIncrementalDataDir())
-            kaptTask.mapClasspath { kaptTask.kotlinCompileTask.classpath }
             kaptTask.generatedSourcesDirs = listOf(sourcesOutputDir, kotlinSourcesOutputDir)
 
-            kaptTask.kaptClasspathConfigurations = kaptClasspathConfigurations
+            kaptTask.kaptClasspath.from(kaptClasspathConfigurations)
 
             PropertiesProvider(project).mapKotlinTaskProperties(kaptTask)
 
             if (!includeCompileClasspath) {
                 kaptTask.onlyIf {
-                    !(it as KaptGenerateStubsTask).kaptClasspath.isEmpty()
+                    !(it as KaptGenerateStubsTask).kaptClasspath.isEmpty
                 }
             }
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/model/builder/KaptModelBuilder.kt

@@ -34,10 +34,9 @@ class KaptModelBuilder : ToolingModelBuilder {
     companion object {
 
         private fun KaptTask.createKaptSourceSet(): KaptSourceSet {
-            val sourceSetName = kotlinCompileTask.sourceSetName
             return KaptSourceSetImpl(
-                sourceSetName,
+                this.sourceSetName.get(),
-                if (sourceSetName.contains(
+                if (this.sourceSetName.get().contains(
                         "test",
                         true
                     )