Fix for compatibility with Android Gradle plugin 2.4.0-alpha1

Deferred resolution of JAR-to-AAR mapping, since the Android Gradle
plugin now resolves dependencies at execution phase.
Dropped the code related to the Jack toolchain compatibility.
Throwing a build error when Jack is enabled.
Changed warning about Jack into a build error.

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

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.ObjectOutputStream
-import javax.xml.bind.DatatypeConverter
 import javax.xml.bind.DatatypeConverter.printBase64Binary
 
 // apply plugin: 'kotlin-kapt'
@@ -235,11 +234,6 @@ class Kapt3KotlinGradleSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         // Add generated source dir as a source root for kotlinCompile and javaCompile
         kotlinCompile.source(sourcesOutputDir)
         javaCompile.source(sourcesOutputDir)
-        variantData?.let {
-            if (AndroidGradleWrapper.isJackEnabled(it)) {
-                AndroidGradleWrapper.addSourceToJack(it, sourcesOutputDir)
-            }
-        }
 
         val pluginOptions = kaptTask.pluginOptions
         val compilerPluginId = getCompilerPluginId()
@@ -253,12 +247,6 @@ class Kapt3KotlinGradleSubplugin : KotlinGradleSubplugin<KotlinCompile> {
             val options = javaCompile.options
             options.compilerArgs = options.compilerArgs.filter { !it.startsWith("-proc:") } + "-proc:none"
         }
-
-        variantData?.let {
-            if (AndroidGradleWrapper.isJackEnabled(it)) {
-                AndroidGradleWrapper.disableJackAnnotationProcessing(it)
-            }
-        }
     }
 
     private val BaseVariantData<*>.sourceProviders: List<SourceProvider>

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

@@ -3,8 +3,6 @@ package org.jetbrains.kotlin.gradle.plugin
 import com.android.build.gradle.BaseExtension
 import com.android.build.gradle.BasePlugin
 import com.android.build.gradle.api.AndroidSourceSet
-import com.android.build.gradle.internal.TaskContainerAdaptor
-import com.android.build.gradle.internal.TaskManager
 import com.android.build.gradle.internal.variant.BaseVariantData
 import com.android.build.gradle.internal.variant.BaseVariantOutputData
 import com.android.build.gradle.internal.variant.TestVariantData
@@ -13,6 +11,7 @@ import groovy.lang.Closure
 import org.gradle.api.InvalidUserDataException
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.ProjectConfigurationException
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
@@ -21,7 +20,6 @@ import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.Delete
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.bundling.Zip
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.compile.JavaCompile
 import org.jetbrains.kotlin.com.intellij.openapi.util.io.FileUtil
@@ -32,9 +30,7 @@ import org.jetbrains.kotlin.gradle.internal.Kapt3KotlinGradleSubplugin
 import org.jetbrains.kotlin.gradle.internal.Kapt3KotlinGradleSubplugin.Companion.getKaptClasssesDir
 import org.jetbrains.kotlin.gradle.internal.initKapt
 import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
-import org.jetbrains.kotlin.gradle.plugin.android.KotlinJillTask
 import org.jetbrains.kotlin.gradle.tasks.*
-import org.jetbrains.kotlin.gradle.utils.getDeclaredFieldInHierarchy
 import org.jetbrains.kotlin.incremental.configureMultiProjectIncrementalCompilation
 import org.jetbrains.kotlin.incremental.multiproject.ArtifactDifferenceRegistryProviderAndroidWrapper
 import java.io.File
@@ -373,19 +369,6 @@ internal open class KotlinAndroidPlugin(
         }
     }
 
-    private fun forceCreateJavacTask(project: Project,
-                                     androidPlugin: BasePlugin,
-                                     variantData: BaseVariantData<*>): JavaCompile? {
-        val taskManager = androidPlugin::class.java.getDeclaredFieldInHierarchy("taskManager")
-                ?.let { it.isAccessible = true; it[androidPlugin] as TaskManager }
-        if (taskManager == null) {
-            log.kotlinDebug("TaskManager was not found, possibly, an incompatible Android Gradle plugin version is used.")
-            return null
-        }
-        val taskContainerAdaptor = TaskContainerAdaptor(project.tasks)
-        return taskManager.createJavacTask(taskContainerAdaptor, variantData.scope)?.get(taskContainerAdaptor)
-    }
-
     private fun getTestedVariantData(variantData: BaseVariantData<*>): BaseVariantData<*>? =
             ((variantData as? TestVariantData)?.testedVariantData as? BaseVariantData<*>)
 
@@ -401,6 +384,12 @@ internal open class KotlinAndroidPlugin(
         val subpluginEnvironment = loadSubplugins(project)
 
         for (variantData in variantDataList) {
+            if (AndroidGradleWrapper.isJackEnabled(variantData)) {
+                throw ProjectConfigurationException(
+                        "Kotlin Gradle plugin does not support the deprecated Jack toolchain.\n" +
+                        "Disable Jack or revert to Kotlin Gradle plugin version 1.1.1.", null)
+            }
+
             val variantDataName = variantData.name
             logger.kotlinDebug("Process variant [$variantDataName]")
 
@@ -408,8 +397,7 @@ internal open class KotlinAndroidPlugin(
             val isAndroidTestVariant = variantDataName.endsWith("androidTest", ignoreCase = true) &&
                                        testedVariantData != null
 
-            val javaTask = AndroidGradleWrapper.getJavaTask(variantData) ?:
+            val javaTask = AndroidGradleWrapper.getJavaTask(variantData)
-                           (if (isAndroidTestVariant) forceCreateJavacTask(project, androidPlugin, variantData) else null)
 
             if (javaTask == null) {
                 logger.info("KOTLIN: javaTask is missing for $variantDataName, so Kotlin files won't be compiled for it")
@@ -486,36 +474,14 @@ internal open class KotlinAndroidPlugin(
             createSyncOutputTask(project, kotlinTask, javaTask, kotlinAfterJavaTask, variantDataName)
 
             if ((kotlinAfterJavaTask ?: kotlinTask).incremental) {
-                val jarToAarMapping = AndroidGradleWrapper.getJarToAarMapping(variantData)
                 val artifactFile = project.tryGetSingleArtifact(variantData)
-                val artifactDifferenceRegistryProvider = ArtifactDifferenceRegistryProviderAndroidWrapper(kotlinGradleBuildServices.artifactDifferenceRegistryProvider, jarToAarMapping)
+                val artifactDifferenceRegistryProvider = ArtifactDifferenceRegistryProviderAndroidWrapper(
+                        kotlinGradleBuildServices.artifactDifferenceRegistryProvider,
+                        { AndroidGradleWrapper.getJarToAarMapping(variantData) }
+                )
                 configureMultiProjectIncrementalCompilation(project, kotlinTask, javaTask, kotlinAfterJavaTask,
                         artifactDifferenceRegistryProvider, artifactFile)
             }
-
-            if (AndroidGradleWrapper.isJackEnabled(variantData)) {
-                val scope = variantData.scope
-                val kotlinDestinationDir = kotlinTask.destinationDir
-                val jarPath = File(kotlinDestinationDir.parent, kotlinDestinationDir.name + ".jar")
-                val zipTaskName = scope.getTaskName("zipKotlinClassesFor")
-                project.tasks.create(zipTaskName, Zip::class.java) { zipTask ->
-                    zipTask.from(kotlinDestinationDir)
-                    zipTask.destinationDir = File(jarPath.parent)
-                    zipTask.archiveName = jarPath.name
-                    zipTask.dependsOn(kotlinTask)
-                }
-
-                val kotlinJillTaskName = scope.getTaskName("transformKotlinClassesWithJillFor")
-                val jillOutputFilePath = File(jarPath.absolutePath + ".jill")
-                project.tasks.create(kotlinJillTaskName, KotlinJillTask::class.java) { jillTask ->
-                    jillTask.buildTools = variantData.scope.globalScope.androidBuilder.targetInfo.buildTools
-                    jillTask.inputJarFile = jarPath
-                    jillTask.outputJillFile = jillOutputFilePath
-                    jillTask.dependsOn(zipTaskName)
-                }
-
-                AndroidGradleWrapper.configureJackTask(variantData, jillOutputFilePath, kotlinJillTaskName)
-            }
         }
     }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/android/AndroidGradleWrapper.groovy

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.gradle.plugin.android
 
-import com.android.build.api.transform.*
 import com.android.build.gradle.BaseExtension
 import com.android.build.gradle.BasePlugin
 import com.android.build.gradle.api.AndroidSourceSet
@@ -24,8 +23,6 @@ import com.android.build.gradle.api.ApkVariant
 import com.android.build.gradle.api.BaseVariant
 import com.android.build.gradle.api.TestVariant
 import com.android.build.gradle.internal.VariantManager
-import com.android.build.gradle.internal.pipeline.OriginalStream
-import com.android.build.gradle.internal.pipeline.TransformTask
 import com.android.build.gradle.internal.variant.BaseVariantData
 import com.android.builder.model.SourceProvider
 import org.gradle.api.file.ConfigurableFileTree
@@ -80,12 +77,7 @@ class AndroidGradleWrapper {
 
   @Nullable
   static AbstractCompile getJavaTask(@NotNull Object variantData) {
-      if (isJackEnabled(variantData)) {
+    return getJavaCompile(variantData)
-          return getJavacTask(variantData)
-      }
-      else {
-          return getJavaCompile(variantData)
-      }
   }
 
   @Nullable
@@ -96,53 +88,6 @@ class AndroidGradleWrapper {
     return null
   }
 
-  @Nullable
-  private static TransformTask getJackTask(@NotNull Object variantData) {
-    def compilerTask = variantData.javaCompilerTask
-    if (compilerTask instanceof TransformTask) {
-      return compilerTask
-    }
-    return null
-  }
-
-  @Nullable
-  private static getJackTransform(@NotNull Object variantData) {
-    return getJackTask(variantData)?.transform
-  }
-
-  static addSourceToJack(@NotNull Object variantData, @NotNull File sourceFolder) {
-    getJackTransform(variantData)?.addSource(sourceFolder)
-  }
-
-  static disableJackAnnotationProcessing(@NotNull Object variantData) {
-    def jackOptions = getJackTransform(variantData)?.options
-    jackOptions?.setAnnotationProcessorOutputDirectory(null)
-    jackOptions?.setAnnotationProcessorNames([])
-    jackOptions?.setAnnotationProcessorClassPath([])
-    jackOptions?.setAnnotationProcessorOptions([:])
-  }
-
-  static configureJackTask(
-          @NotNull Object variantData,
-          @NotNull File jillOutputFile,
-          @NotNull String kotlinJillTaskName) {
-    def jackTask = getJackTask(variantData)
-    // There is no Jack task for some variants
-    if (jackTask == null) {
-      return
-    }
-
-    def jillOutputStream = OriginalStream.builder()
-            .addContentType(QualifiedContent.DefaultContentType.CLASSES)
-            .addScope(QualifiedContent.Scope.PROJECT)
-            .setJar(jillOutputFile)
-            .setDependency(kotlinJillTaskName)
-            .build()
-
-    jackTask.consumedInputStreams.add(jillOutputStream)
-    jackTask.dependsOn(kotlinJillTaskName)
-  }
-
   @Nullable
   private static AbstractCompile getJavaCompile(@NotNull Object baseVariantData) {
     if (baseVariantData.getMetaClass().getMetaProperty("javaCompileTask")) {

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

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.gradle.plugin.android
-
-
-import com.android.builder.core.BuildToolsServiceLoader
-import com.android.jill.api.v01.Api01Config
-import com.android.sdklib.BuildToolInfo
-import org.gradle.api.DefaultTask
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
-import java.io.File
-
-open class KotlinJillTask : DefaultTask() {
-
-    @InputFile
-    lateinit var inputJarFile: File
-
-    @OutputFile
-    lateinit var outputJillFile: File
-
-    lateinit var buildTools: BuildToolInfo
-
-    @TaskAction
-    fun transform() {
-        val jillProvider = BuildToolsServiceLoader.INSTANCE
-                .forVersion(buildTools)
-                .getServiceLoader(BuildToolsServiceLoader.JILL)
-                .firstOrNull() ?: error("Jill provider not found")
-
-        outputJillFile.parentFile.mkdirs()
-        val config01: Api01Config = jillProvider.createConfig(Api01Config::class.java)
-        config01.setInputJavaBinaryFile(inputJarFile)
-        config01.setOutputJackFile(outputJillFile)
-        config01.task.run()
-    }
-}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/incremental/multiproject/ArtifactDifferenceRegistryAndroidWrapper.kt

@@ -20,11 +20,11 @@ import java.io.File
 
 internal class ArtifactDifferenceRegistryProviderAndroidWrapper(
         private val provider: ArtifactDifferenceRegistryProvider,
-        private val jarToAarMapping: Map<File, File>
+        private val jarToAarMapping: () -> Map<File, File>
 ) : ArtifactDifferenceRegistryProvider {
     override fun <T> withRegistry(report: (String)->Unit, fn: (ArtifactDifferenceRegistry)->T): T? {
         return provider.withRegistry(report) { originalRegistry ->
-            val wrapped = ArtifactDifferenceRegistryAndroidWrapper(originalRegistry, jarToAarMapping)
+            val wrapped = ArtifactDifferenceRegistryAndroidWrapper(originalRegistry, jarToAarMapping())
             fn(wrapped)
         }
     }