Refactoring: do not use extraProperties to pass kapt options to task

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

@@ -0,0 +1,24 @@
+package org.jetbrains.kotlin.gradle.tasks
+
+import java.io.File
+
+class CompilerPluginOptions {
+    private val mutableClasspath = arrayListOf<String>()
+    private val mutableArguments = arrayListOf<String>()
+
+    val classpath: List<String>
+        get() = mutableClasspath
+
+    val arguments: List<String>
+        get() = mutableArguments
+
+    // used in kotlin-gradle-plugin
+    @Suppress("unused")
+    fun addClasspathEntry(file: File) {
+        mutableClasspath.add(file.canonicalPath)
+    }
+
+    fun addPluginArgument(pluginId: String, key: String, value: String) {
+        mutableArguments.add("plugin:$pluginId:$key=$value")
+    }
+}

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

@@ -0,0 +1,9 @@
+package org.jetbrains.kotlin.gradle.tasks
+
+import java.io.File
+
+class KaptOptions {
+    var supportInheritedAnnotations: Boolean = false
+    var classFileStubsDir: File? = null
+    var annotationsFile: File? = null
+}

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

@@ -157,6 +157,8 @@ open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments>() {
 
     private var kaptAnnotationsFileUpdater: AnnotationFileUpdater? = null
     private var kaptStubGeneratingMode = false
+    val kaptOptions = KaptOptions()
+    val pluginOptions = CompilerPluginOptions()
 
     override fun populateTargetSpecificArgs(args: K2JVMCompilerArguments) {
         // show kotlin compiler where to look for java source files
@@ -176,14 +178,10 @@ open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments>() {
         logger.kotlinDebug("destinationDir = $destinationDir")
 
         val extraProperties = extensions.extraProperties
-        args.pluginClasspaths = extraProperties.getOrNull<Array<String>>("compilerPluginClasspaths") ?: arrayOf()
+        args.pluginClasspaths = pluginOptions.classpath.toTypedArray()
         logger.kotlinDebug("args.pluginClasspaths = ${args.pluginClasspaths.joinToString(File.pathSeparator)}")
-        val basePluginOptions = extraProperties.getOrNull<Array<String>>("compilerPluginArguments") ?: arrayOf()
+        handleKaptProperties()
-
+        args.pluginOptions = pluginOptions.arguments.toTypedArray()
-        val pluginOptions = arrayListOf(*basePluginOptions)
-        handleKaptProperties(extraProperties, pluginOptions)
-
-        args.pluginOptions = pluginOptions.toTypedArray()
         logger.kotlinDebug("args.pluginOptions = ${args.pluginOptions.joinToString(File.pathSeparator)}")
 
         args.noStdlib = true
@@ -476,26 +474,23 @@ open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments>() {
         }
     }
 
-    private fun handleKaptProperties(extraProperties: ExtraPropertiesExtension, pluginOptions: MutableList<String>) {
+    private fun handleKaptProperties() {
-        val kaptAnnotationsFile = extraProperties.getOrNull<File>("kaptAnnotationsFile")
+        kaptOptions.annotationsFile?.let { kaptAnnotationsFile ->
-        if (kaptAnnotationsFile != null) {
             if (incremental) {
                 kaptAnnotationsFileUpdater = AnnotationFileUpdater(kaptAnnotationsFile)
             }
 
             if (kaptAnnotationsFile.exists()) kaptAnnotationsFile.delete()
-            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:output=" + kaptAnnotationsFile)
+            pluginOptions.addPluginArgument(ANNOTATIONS_PLUGIN_NAME, "output", kaptAnnotationsFile.canonicalPath)
         }
 
-        val kaptClassFileStubsDir = extraProperties.getOrNull<File>("kaptStubsDir")
+        kaptOptions.classFileStubsDir?.let { kaptClassFileStubsDir ->
-        if (kaptClassFileStubsDir != null) {
             kaptStubGeneratingMode = true
-            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:stubs=" + kaptClassFileStubsDir)
+            pluginOptions.addPluginArgument(ANNOTATIONS_PLUGIN_NAME, "stubs", kaptClassFileStubsDir.canonicalPath)
         }
 
-        val supportInheritedAnnotations = extraProperties.getOrNull<Boolean>("kaptInheritedAnnotations")
+        if (kaptOptions.supportInheritedAnnotations) {
-        if (supportInheritedAnnotations != null && supportInheritedAnnotations) {
+            pluginOptions.addPluginArgument(ANNOTATIONS_PLUGIN_NAME, "inherited", true.toString())
-            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:inherited=true")
         }
     }
 

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

@@ -23,6 +23,7 @@ import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.compile.JavaCompile
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider
 import org.jetbrains.kotlin.gradle.tasks.kapt.generateAnnotationProcessorWrapper
 import org.jetbrains.kotlin.gradle.tasks.kapt.generateKotlinAptAnnotation
 import java.io.File
@@ -37,20 +38,20 @@ fun Project.initKapt(
         variantName: String,
         kotlinOptions: Any?,
         subpluginEnvironment: SubpluginEnvironment,
-        taskFactory: (suffix: String) -> AbstractCompile
+        tasksProvider: KotlinTasksProvider
 ): AbstractCompile? {
     val kaptExtension = extensions.getByType(KaptExtension::class.java)
-    val kotlinAfterJavaTask: AbstractCompile?
+    val kotlinAfterJavaTask: KotlinCompile?
 
     if (kaptExtension.generateStubs) {
-        kotlinAfterJavaTask = createKotlinAfterJavaTask(javaTask, kotlinTask, kotlinOptions, taskFactory)
+        kotlinAfterJavaTask = createKotlinAfterJavaTask(javaTask, kotlinTask, kotlinOptions, tasksProvider)
         mapKotlinTaskProperties(this, kotlinAfterJavaTask)
 
         kotlinTask.logger.kotlinDebug("kapt: Using class file stubs")
 
         val stubsDir = File(buildDir, "tmp/kapt/$variantName/classFileStubs")
         stubsDir.mkdirs()
-        kotlinTask.extensions.extraProperties.set("kaptStubsDir", stubsDir)
+        kotlinTask.kaptOptions.classFileStubs = stubsDir
         javaTask.appendClasspathDynamically(stubsDir)
         kotlinTask.appendClasspathDynamically(stubsDir)
 
@@ -76,9 +77,7 @@ fun Project.initKapt(
     javaTask.appendClasspathDynamically(kaptManager.wrappersDirectory)
     javaTask.source(kaptManager.hackAnnotationDir)
 
-    if (kaptExtension.inheritedAnnotations) {
+    kotlinTask.kaptOptions.supportInheritedAnnotations = kaptExtension.inheritedAnnotations
-        kotlinTask.extensions.extraProperties.set("kaptInheritedAnnotations", true)
-    }
 
     kotlinTask.doFirst {
         kaptManager.generateJavaHackFile()
@@ -98,18 +97,18 @@ fun Project.initKapt(
         kaptManager.afterJavaCompile()
     }
 
-    kotlinTask.storeKaptAnnotationsFile(kaptManager)
+    kotlinTask.kaptOptions.annotationsFile = kaptManager.getAnnotationFile()
     return kotlinAfterJavaTask
 }
 
 private fun Project.createKotlinAfterJavaTask(
         javaTask: AbstractCompile,
-        kotlinTask: AbstractCompile,
+        kotlinTask: KotlinCompile,
         kotlinOptions: Any?,
-        taskFactory: (suffix: String) -> AbstractCompile
-): AbstractCompile {
-    val kotlinAfterJavaTask = with (taskFactory(KOTLIN_AFTER_JAVA_TASK_SUFFIX)) {
         destinationDir = kotlinTask.destinationDir
+        tasksProvider: KotlinTasksProvider
+): KotlinCompile {
+    val kotlinAfterJavaTask = with (tasksProvider.createKotlinJVMTask(this, KOTLIN_AFTER_JAVA_TASK_SUFFIX)) {
         classpath = kotlinTask.classpath - project.files(javaTask.destinationDir)
         this
     }

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

@@ -172,9 +172,7 @@ class Kotlin2JvmSourceSetProcessor(
                             aptConfiguration.resolve(), aptOutputDir, aptWorkingDir)
 
                     kotlinAfterJavaTask = project.initKapt(kotlinTask, javaTask, kaptManager,
-                            sourceSetName, null, subpluginEnvironment) {
+                            sourceSetName, null, subpluginEnvironment, tasksProvider)
-                        createKotlinCompileTask(it)
-                    }
 
                     if (kotlinAfterJavaTask != null) {
                         javaTask.doFirst {
@@ -442,11 +440,7 @@ open class KotlinAndroidPlugin @Inject constructor(val scriptHandler: ScriptHand
                 val kaptManager = AnnotationProcessingManager(kotlinTask, javaTask, variantDataName,
                         aptFiles.toSet(), aptOutputDir, aptWorkingDir, variantData)
 
-                kotlinTask.storeKaptAnnotationsFile(kaptManager)
+                kotlinAfterJavaTask = project.initKapt(kotlinTask, javaTask, kaptManager, variantDataName, kotlinOptions, subpluginEnvironment, tasksProvider)
-
-                kotlinAfterJavaTask = project.initKapt(kotlinTask, javaTask, kaptManager, variantDataName, kotlinOptions, subpluginEnvironment) {
-                    tasksProvider.createKotlinJVMTask(project, kotlinTaskName + KOTLIN_AFTER_JAVA_TASK_SUFFIX)
-                }
             }
 
             configureJavaTask(kotlinTask, javaTask, kotlinAfterJavaTask, logger)
@@ -560,32 +554,23 @@ class SubpluginEnvironment(
     val subplugins: List<KotlinGradleSubplugin>
 ) {
 
-    fun addSubpluginArguments(project: Project, compileTask: AbstractCompile) {
+    fun addSubpluginArguments(project: Project, kotlinTask: KotlinCompile) {
-        val realPluginClasspaths = arrayListOf<String>()
+        val pluginOptions = kotlinTask.pluginOptions
-        val pluginArguments = arrayListOf<String>()
-        fun getPluginOptionString(pluginId: String, key: String, value: String) = "plugin:$pluginId:$key=$value"
 
         for (subplugin in subplugins) {
-            if (!subplugin.isApplicable(project, compileTask)) continue
+            if (!subplugin.isApplicable(project, kotlinTask)) continue
 
             with (subplugin) {
                 project.logger.kotlinDebug("Subplugin ${getPluginName()} (${getGroupName()}:${getArtifactName()}) loaded.")
             }
 
-            val subpluginClasspath = subpluginClasspaths[subplugin]
+            val subpluginClasspath = subpluginClasspaths[subplugin] ?: continue
-            if (subpluginClasspath != null) {
+            subpluginClasspath.forEach { pluginOptions.addClasspathEntry(it) }
-                subpluginClasspath.forEach { realPluginClasspaths.add(it.absolutePath) }
 
-                for (arg in subplugin.getExtraArguments(project, compileTask)) {
+            for (arg in subplugin.getExtraArguments(project, kotlinTask)) {
-                    val option = getPluginOptionString(subplugin.getPluginName(), arg.key, arg.value)
+                pluginOptions.addPluginArgument(subplugin.getPluginName(), arg.key, arg.value)
-                    pluginArguments.add(option)
-                }
             }
         }
-
-        val extraProperties = compileTask.extensions.extraProperties
-        extraProperties.set("compilerPluginClasspaths", realPluginClasspaths.toTypedArray())
-        extraProperties.set("compilerPluginArguments", pluginArguments.toTypedArray())
     }
 }
 
@@ -610,10 +595,6 @@ open class GradleUtils(val scriptHandler: ScriptHandler, val project: ProjectInt
 internal operator fun FileCollection.plus(other: FileCollection) = this.plus(other)
 internal operator fun FileCollection.minus(other: FileCollection) = this.minus(other)
 
-fun AbstractCompile.storeKaptAnnotationsFile(kapt: AnnotationProcessingManager) {
-    extensions.extraProperties.set("kaptAnnotationsFile", kapt.getAnnotationFile())
-}
-
 private fun Project.getAptDirsForSourceSet(sourceSetName: String): Pair<File, File> {
     val aptOutputDir = File(buildDir, "generated/source/kapt")
     val aptOutputDirForVariant = File(aptOutputDir, sourceSetName)