Partial cleanup & refactoring of the Android plugin

The `KotlinAndroidPlugin` used to support two different sets of APIs of
the Android Gradle plugin and used `AbstractAndroidProjectHandler` to
wrap those APIs. Now that there's only one implementation, it
doesn't need the generic `V` (variant data), and some cleanup is needed.

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

@@ -654,7 +654,7 @@ internal open class KotlinAndroidPlugin(
         fun androidTargetHandler(
             kotlinPluginVersion: String,
             androidTarget: KotlinAndroidTarget
-        ): AbstractAndroidProjectHandler<*> {
+        ): AbstractAndroidProjectHandler {
             val tasksProvider = AndroidTasksProvider(androidTarget.targetName)
 
             val version = loadAndroidPluginVersion()
@@ -687,37 +687,35 @@ class KotlinConfigurationTools internal constructor(
     val kotlinPluginVersion: String
 )
 
-abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationTools: KotlinConfigurationTools) {
+abstract class AbstractAndroidProjectHandler(private val kotlinConfigurationTools: KotlinConfigurationTools) {
     protected val logger = Logging.getLogger(this.javaClass)
 
-    abstract fun forEachVariant(project: Project, action: (V) -> Unit): Unit
-    abstract fun getTestedVariantData(variantData: V): V?
-    abstract fun getResDirectories(variantData: V): FileCollection
-    abstract fun getVariantName(variant: V): String
-    abstract fun getFlavorNames(variant: V): List<String>
-    abstract fun getBuildTypeName(variant: V): String
-    abstract fun getLibraryOutputTask(variant: V): Any?
+    abstract fun forEachVariant(project: Project, action: (BaseVariant) -> Unit): Unit
+    abstract fun getResDirectories(variantData: BaseVariant): FileCollection
+    abstract fun getFlavorNames(variant: BaseVariant): List<String>
+    abstract fun getBuildTypeName(variant: BaseVariant): String
+    abstract fun getLibraryOutputTask(variant: BaseVariant): Any?
 
-    protected abstract fun getSourceProviders(variantData: V): Iterable<SourceProvider>
-    protected abstract fun getAllJavaSources(variantData: V): Iterable<File>
-    protected abstract fun getJavaTask(variantData: V): AbstractCompile?
-    protected abstract fun addJavaSourceDirectoryToVariantModel(variantData: V, javaSourceDirectory: File): Unit
+    protected abstract fun getSourceProviders(variantData: BaseVariant): Iterable<SourceProvider>
+    protected abstract fun getAllJavaSources(variantData: BaseVariant): Iterable<File>
+    protected abstract fun getJavaTask(variantData: BaseVariant): AbstractCompile?
+    protected abstract fun addJavaSourceDirectoryToVariantModel(variantData: BaseVariant, javaSourceDirectory: File): Unit
 
-    protected open fun checkVariantIsValid(variant: V) = Unit
+    protected open fun checkVariantIsValid(variant: BaseVariant) = Unit
 
-    protected open fun setUpDependencyResolution(variant: V, compilation: KotlinJvmAndroidCompilation) = Unit
+    protected open fun setUpDependencyResolution(variant: BaseVariant, compilation: KotlinJvmAndroidCompilation) = Unit
 
     protected abstract fun wireKotlinTasks(
         project: Project,
         compilation: KotlinJvmAndroidCompilation,
         androidPlugin: BasePlugin,
         androidExt: BaseExtension,
-        variantData: V,
+        variantData: BaseVariant,
         javaTask: AbstractCompile,
         kotlinTask: KotlinCompile
     )
 
-    protected abstract fun wrapVariantDataForKapt(variantData: V): KaptVariantData<V>
+    protected abstract fun wrapVariantDataForKapt(variantData: BaseVariant): KaptVariantData<BaseVariant>
 
     fun configureTarget(kotlinAndroidTarget: KotlinAndroidTarget) {
         val project = kotlinAndroidTarget.project
@@ -773,11 +771,11 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
             // in afterEvaluate, a user's build script might have already attached item handlers to the compilations container, and those
             // handlers might break when fired on a compilation that is not yet properly configured (e.g. KT-29964):
             kotlinAndroidTarget.compilationFactory.create(variantName).let { compilation ->
-                compilation.androidVariant = variant as BaseVariant
+                compilation.androidVariant = variant
 
                 setUpDependencyResolution(variant, compilation)
 
-                preprocessVariant(variant, compilation, project, ext, plugin, kotlinOptions, kotlinConfigurationTools.kotlinTasksProvider)
+                preprocessVariant(variant, compilation, project, kotlinOptions, kotlinConfigurationTools.kotlinTasksProvider)
 
                 @Suppress("UNCHECKED_CAST")
                 (kotlinAndroidTarget.compilations as NamedDomainObjectCollection<in KotlinJvmAndroidCompilation>).add(compilation)
@@ -852,7 +850,7 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
         // extendsFrom relationship.
         if (kotlinAndroidTarget.disambiguationClassifier != null) {
 
-            val sourceSetToVariants = mutableMapOf<AndroidSourceSet, MutableList<V>>().apply {
+            val sourceSetToVariants = mutableMapOf<AndroidSourceSet, MutableList<BaseVariant>>().apply {
                 forEachVariant(project) { variant ->
                     for (sourceSet in getSourceProviders(variant)) {
                         val androidSourceSet = sourceSet as? AndroidSourceSet ?: continue
@@ -885,11 +883,9 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
     }
 
     private fun preprocessVariant(
-        variantData: V,
+        variantData: BaseVariant,
         compilation: KotlinJvmAndroidCompilation,
         project: Project,
-        androidExt: BaseExtension,
-        androidPlugin: BasePlugin,
         rootKotlinOptions: KotlinJvmOptionsImpl,
         tasksProvider: KotlinTasksProvider
     ) {
@@ -935,7 +931,7 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
     }
 
     private fun postprocessVariant(
-        variantData: V,
+        variantData: BaseVariant,
         compilation: KotlinJvmAndroidCompilation,
         project: Project,
         androidExt: BaseExtension,
@@ -951,7 +947,7 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
     private fun applySubplugins(
         project: Project,
         compilation: KotlinCompilation<*>,
-        variantData: V,
+        variantData: BaseVariant,
         subpluginEnvironment: SubpluginEnvironment
     ) {
         val kotlinTask = project.tasks.getByName(compilation.compileKotlinTaskName) as KotlinCompile
@@ -965,7 +961,7 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
             .forEach { configureSources(it, variantData, null) }
     }
 
-    private fun configureSources(compileTask: AbstractCompile, variantData: V, compilation: KotlinCompilation<*>?) {
+    private fun configureSources(compileTask: AbstractCompile, variantData: BaseVariant, compilation: KotlinCompilation<*>?) {
         val logger = compileTask.project.logger
 
         for (provider in getSourceProviders(variantData)) {

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

@@ -46,7 +46,7 @@ class SubpluginEnvironment(
         kotlinTask: AbstractKotlinCompile<C>,
         javaTask: AbstractCompile? = null,
         variantData: Any? = null,
-        androidProjectHandler: AbstractAndroidProjectHandler<out Any?>? = null,
+        androidProjectHandler: AbstractAndroidProjectHandler? = null,
         kotlinCompilation: KotlinCompilation<*>? = null
     ): List<KotlinGradleSubplugin<AbstractKotlinCompile<C>>> = addSubpluginOptions(
         project,
@@ -64,7 +64,7 @@ class SubpluginEnvironment(
         pluginOptions: CompilerPluginOptions,
         javaTask: AbstractCompile? = null,
         variantData: Any? = null,
-        androidProjectHandler: AbstractAndroidProjectHandler<out Any?>? = null,
+        androidProjectHandler: AbstractAndroidProjectHandler? = null,
         kotlinCompilation: KotlinCompilation<*>? = null
     ): List<KotlinGradleSubplugin<AbstractCompile>> {
         val appliedSubplugins = subplugins.filter { it.isApplicable(project, kotlinTask) }

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

@@ -22,13 +22,12 @@ import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
-import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import java.io.File
 import java.util.concurrent.Callable
 
 class Android25ProjectHandler(
     kotlinConfigurationTools: KotlinConfigurationTools
-) : AbstractAndroidProjectHandler<BaseVariant>(kotlinConfigurationTools) {
+) : AbstractAndroidProjectHandler(kotlinConfigurationTools) {
 
     override fun forEachVariant(project: Project, action: (BaseVariant) -> Unit) {
         val androidExtension = project.extensions.getByName("android")
@@ -96,18 +95,10 @@ class Android25ProjectHandler(
     override fun getAllJavaSources(variantData: BaseVariant): Iterable<File> =
         variantData.getSourceFolders(SourceKind.JAVA).map { it.dir }
 
-    override fun getVariantName(variant: BaseVariant): String = variant.name
-
     override fun getFlavorNames(variant: BaseVariant): List<String> = variant.productFlavors.map { it.name }
 
     override fun getBuildTypeName(variant: BaseVariant): String = variant.buildType.name
 
-    override fun getTestedVariantData(variantData: BaseVariant): BaseVariant? = when (variantData) {
-        is TestVariant -> variantData.testedVariant
-        is UnitTestVariant -> variantData.testedVariant as? BaseVariant
-        else -> null
-    }
-
     override fun getJavaTask(variantData: BaseVariant): AbstractCompile? {
         @Suppress("DEPRECATION") // There is always a Java compile task -- the deprecation was for Jack
         return variantData::class.java.methods.firstOrNull { it.name == "getJavaCompileProvider" }
@@ -245,4 +236,12 @@ class Android25ProjectHandler(
 
     override fun wrapVariantDataForKapt(variantData: BaseVariant): KaptVariantData<BaseVariant> =
         KaptVariant(variantData)
-}
+}
+
+internal fun getTestedVariantData(variantData: BaseVariant): BaseVariant? = when (variantData) {
+    is TestVariant -> variantData.testedVariant
+    is UnitTestVariant -> variantData.testedVariant as? BaseVariant
+    else -> null
+}
+
+internal fun getVariantName(variant: BaseVariant): String = variant.name

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

@@ -6,6 +6,7 @@
 @file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp
 
+import com.android.build.gradle.api.BaseVariant
 import org.gradle.api.InvalidUserDataException
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
@@ -61,8 +62,7 @@ open class KotlinAndroidTarget(
     var publishLibraryVariantsGroupedByFlavor = false
 
     private fun checkPublishLibraryVariantsExist() {
-        // Capture type parameter T
-        fun <T> AbstractAndroidProjectHandler<T>.getLibraryVariantNames() =
+        fun AbstractAndroidProjectHandler.getLibraryVariantNames() =
             mutableSetOf<String>().apply {
                 forEachVariant(project) {
                     if (getLibraryOutputTask(it) != null)
@@ -92,9 +92,8 @@ open class KotlinAndroidTarget(
         KotlinAndroidPlugin.androidTargetHandler(project.getKotlinPluginVersion()!!, this).doCreateComponents()
     }
 
-    // Capture the type parameter T for `AbstractAndroidProjectHandler`
-    private fun <T> AbstractAndroidProjectHandler<T>.doCreateComponents(): Set<KotlinTargetComponent> {
-        val publishableVariants = mutableListOf<T>()
+    private fun AbstractAndroidProjectHandler.doCreateComponents(): Set<KotlinTargetComponent> {
+        val publishableVariants = mutableListOf<BaseVariant>()
             .apply { forEachVariant(project) { add(it) } }
             .toList() // Defensive copy against unlikely modification by the lambda that captures the list above in forEachVariant { }
             .filter { getLibraryOutputTask(it) != null && publishLibraryVariants?.contains(getVariantName(it)) ?: true }
@@ -161,8 +160,8 @@ open class KotlinAndroidTarget(
         }.toSet()
     }
 
-    private fun <T> AbstractAndroidProjectHandler<T>.createAndroidUsageContexts(
-        variant: T,
+    private fun AbstractAndroidProjectHandler.createAndroidUsageContexts(
+        variant: BaseVariant,
         compilation: KotlinCompilation<*>,
         artifactClassifier: String?
     ): Set<DefaultKotlinUsageContext> {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/android/internal/AndroidSubplugin.kt

@@ -164,7 +164,7 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         androidProjectHandler: Any?
     ): List<SubpluginOption> {
         @Suppress("UNCHECKED_CAST")
-        androidProjectHandler as? AbstractAndroidProjectHandler<Any?> ?: return emptyList()
+        androidProjectHandler as? AbstractAndroidProjectHandler ?: return emptyList()
 
         val pluginOptions = arrayListOf<SubpluginOption>()
         pluginOptions += SubpluginOption("features",
@@ -209,7 +209,7 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         val resDirectoriesForAllVariants = mutableListOf<FileCollection>()
 
         androidProjectHandler.forEachVariant(project) { variant ->
-            if (androidProjectHandler.getTestedVariantData(variant) != null) return@forEachVariant
+            if (getTestedVariantData(variant) != null) return@forEachVariant
             resDirectoriesForAllVariants += androidProjectHandler.getResDirectories(variant)
         }