kapt: Lazy evaluation of additional arguments

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

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.gradle.internal
 
+import com.android.build.gradle.BaseExtension
+import org.gradle.api.UnknownDomainObjectException
 import org.gradle.api.plugins.ExtraPropertiesExtension
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.compile.JavaCompile
@@ -34,7 +36,8 @@ public class AnnotationProcessingManager(
         private val aptFiles: Set<File>,
         private val aptOutputDir: File,
         private val aptWorkingDir: File,
-        private val coreClassLoader: ClassLoader) {
+        private val coreClassLoader: ClassLoader,
+        private val androidVariant: Any? = null) {
 
     private val project = task.getProject()
 
@@ -98,7 +101,7 @@ public class AnnotationProcessingManager(
 
     private fun appendAdditionalComplerArgs() {
         val kaptExtension = project.getExtensions().getByType(javaClass<KaptExtension>())
-        val args = kaptExtension.getAdditionalCompilerArgs()
+        val args = kaptExtension.getAdditionalArguments(project, androidVariant, getAndroidExtension())
         if (args.isEmpty()) return
 
         javaTask.modifyCompilerArguments { list ->
@@ -139,6 +142,14 @@ public class AnnotationProcessingManager(
         }
     }
 
+    private fun getAndroidExtension(): BaseExtension? {
+        try {
+            return project.getExtensions().getByName("android") as BaseExtension
+        } catch (e: UnknownDomainObjectException) {
+            return null
+        }
+    }
+
     private fun addGeneratedSourcesOutputToCompilerArgs(javaTask: JavaCompile, outputDir: File) {
         outputDir.mkdirs()
 

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

@@ -16,19 +16,45 @@
 
 package org.jetbrains.kotlin.gradle.plugin
 
+import groovy.lang.Closure
+import org.gradle.api.Project
+
 public open class KaptExtension {
 
     public open var generateStubs: Boolean = false
 
-    private val additionalCompilerArgs = arrayListOf<String>()
+    private var closure: Closure<*>? = null
 
-    public open fun arg(name: String, vararg values: String) {
+    public open fun arguments(closure: Closure<*>) {
+        this.closure = closure
+    }
+
+    fun getAdditionalArguments(project: Project, variant: Any?, android: Any?): List<String> {
+        val closureToExecute = closure ?: return emptyList()
+
+        val executor = KaptAdditionalArgumentsDelegate(project, variant, android)
+        executor.execute(closureToExecute)
+        return executor.additionalCompilerArgs
+    }
+}
+
+public open class KaptAdditionalArgumentsDelegate(
+        public open val project: Project,
+        public open val variant: Any?,
+        public open val android: Any?
+) {
+
+    val additionalCompilerArgs = arrayListOf<String>()
+
+    public open fun arg(name: Any, vararg values: Any) {
         val valuesString = if (values.isNotEmpty()) values.joinToString(" ", prefix = "=") else ""
         additionalCompilerArgs.add("-A$name$valuesString")
     }
 
-    public open fun getAdditionalCompilerArgs(): List<String> {
+    fun execute(closure: Closure<*>) {
-        return additionalCompilerArgs.toList()
+        closure.setResolveStrategy(Closure.DELEGATE_FIRST)
+        closure.setDelegate(this)
+        closure.call()
     }
 
 }

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

@@ -442,7 +442,7 @@ open class KotlinAndroidPlugin @Inject constructor(val scriptHandler: ScriptHand
 
             if (javaTask is JavaCompile && aptFiles.isNotEmpty()) {
                 val kaptManager = AnnotationProcessingManager(kotlinTask, javaTask, variantDataName,
-                        aptFiles.toSet(), aptOutputDir, aptWorkingDir, tasksProvider.tasksLoader)
+                        aptFiles.toSet(), aptOutputDir, aptWorkingDir, tasksProvider.tasksLoader, variantData)
 
                 kotlinTask.storeKaptAnnotationsFile(kaptManager)
 
@@ -626,21 +626,23 @@ private fun Project.initKapt(
 
 private fun Project.createKotlinAfterJavaTask(
         javaTask: AbstractCompile,
-        kotlinDestinationDir: File,
+        kotlinOutputDir: File,
         taskFactory: (suffix: String) -> AbstractCompile
 ): AbstractCompile {
-    val kotlinTaskAfterJava = taskFactory("AfterJava")
+    val kotlinAfterJavaTask = with (taskFactory("AfterJava")) {
-    kotlinTaskAfterJava.setProperty("kotlinDestinationDir", kotlinDestinationDir)
+        setProperty("kotlinDestinationDir", kotlinOutputDir)
-    kotlinTaskAfterJava.setDestinationDir(javaTask.getDestinationDir())
+        setDestinationDir(javaTask.getDestinationDir())
-    kotlinTaskAfterJava.setClasspath(javaTask.getClasspath())
+        setClasspath(javaTask.getClasspath())
+        dependsOn(javaTask.getDependsOn(), javaTask)
+        this
+    }
 
-    getTasks().filter {
+    val dependsOnJava = getTasks().filter { javaTask in it.getDependsOn() && it != kotlinAfterJavaTask }
-        javaTask in it.getTaskDependencies().getDependencies(it)
+    for (task in dependsOnJava) {
-    }.forEach { it.dependsOn(kotlinTaskAfterJava) }
+        task.dependsOn(kotlinAfterJavaTask)
+    }
 
-    kotlinTaskAfterJava.dependsOn(javaTask)
+    return kotlinAfterJavaTask
-
-    return kotlinTaskAfterJava
 }
 
 //copied from BasePlugin.getLocalVersion