Kotlin Facet: Distinguish compiler arguments specified for different source sets

 #KT-16698 Fixed

Author: asedunov

idea/kotlin-gradle-tooling/src/KotlinGradleModelBuilder.kt

@@ -17,29 +17,35 @@
 package org.jetbrains.kotlin.gradle
 
 import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.artifacts.ProjectDependency
 import org.jetbrains.plugins.gradle.tooling.ErrorMessageBuilder
 import org.jetbrains.plugins.gradle.tooling.ModelBuilderService
 import java.io.Serializable
 import java.lang.Exception
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+
+typealias CompilerArgumentsBySourceSet = Map<String, List<String>>
 
 interface KotlinGradleModel : Serializable {
     val implements: String?
-    val currentCompilerArguments: List<String>?
-    val defaultCompilerArguments: List<String>?
+    val currentCompilerArgumentsBySourceSet: CompilerArgumentsBySourceSet
+    val defaultCompilerArgumentsBySourceSet: CompilerArgumentsBySourceSet
     val coroutines: String?
 }
 
 class KotlinGradleModelImpl(
         override val implements: String?,
-        override val currentCompilerArguments: List<String>?,
-        override val defaultCompilerArguments: List<String>?,
+        override val currentCompilerArgumentsBySourceSet: CompilerArgumentsBySourceSet,
+        override val defaultCompilerArgumentsBySourceSet: CompilerArgumentsBySourceSet,
         override val coroutines: String?
 ) : KotlinGradleModel
 
 class KotlinGradleModelBuilder : ModelBuilderService {
     companion object {
-        val compileTasks = listOf("compileKotlin", "compileKotlin2Js")
+        val kotlinCompileTaskClasses = listOf("org.jetbrains.kotlin.gradle.tasks.KotlinCompile_Decorated",
+                                              "org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile_Decorated")
     }
 
     override fun getErrorMessageBuilder(project: Project, e: Exception): ErrorMessageBuilder {
@@ -57,15 +63,35 @@ class KotlinGradleModelBuilder : ModelBuilderService {
         return null
     }
 
+    private fun Class<*>.findGetterMethod(name: String): Method? {
+        generateSequence(this) { it.superclass }.forEach {
+            try {
+                return it.getDeclaredMethod(name)
+            }
+            catch(e: Exception) {
+                // Check next super class
+            }
+        }
+        return null
+    }
+
     @Suppress("UNCHECKED_CAST")
-    private fun getCompilerArguments(project: Project, methodName: String): List<String>? {
-        val compileTask = compileTasks.mapNotNull { project.getTasksByName(it, false).firstOrNull() }.firstOrNull() ?: return null
+    private fun collectCompilerArguments(
+            compileTask: Task,
+            methodName: String,
+            argumentsBySourceSet: MutableMap<String, List<String>>
+    ) {
         val taskClass = compileTask.javaClass
-        return try {
-            taskClass.getDeclaredMethod(methodName).invoke(compileTask) as List<String>
+        val sourceSetName = try {
+            taskClass.findGetterMethod("getSourceSetName\$kotlin_gradle_plugin")?.invoke(compileTask) as? String
+        } catch (e : InvocationTargetException) {
+            null // can be thrown if property is not initialized yet
+        } ?: "main"
+        try {
+            argumentsBySourceSet[sourceSetName] = taskClass.getDeclaredMethod(methodName).invoke(compileTask) as List<String>
         }
         catch (e : NoSuchMethodException) {
-            null
+            // No argument accessor method is available
         }
     }
 
@@ -86,11 +112,22 @@ class KotlinGradleModelBuilder : ModelBuilderService {
         }
     }
 
-    override fun buildAll(modelName: String?, project: Project) =
-            KotlinGradleModelImpl(
-                    getImplements(project),
-                    getCompilerArguments(project, "getSerializedCompilerArguments"),
-                    getCompilerArguments(project, "getDefaultSerializedCompilerArguments"),
-                    getCoroutines(project)
-            )
+    override fun buildAll(modelName: String?, project: Project): KotlinGradleModelImpl {
+        val currentCompilerArgumentsBySourceSet = LinkedHashMap<String, List<String>>()
+        val defaultCompilerArgumentsBySourceSet = LinkedHashMap<String, List<String>>()
+
+        project.getAllTasks(false)[project]?.forEach { compileTask ->
+            if (compileTask.javaClass.name !in kotlinCompileTaskClasses) return@forEach
+
+            collectCompilerArguments(compileTask, "getSerializedCompilerArguments", currentCompilerArgumentsBySourceSet)
+            collectCompilerArguments(compileTask, "getDefaultSerializedCompilerArguments", defaultCompilerArgumentsBySourceSet)
+        }
+
+        return KotlinGradleModelImpl(
+                getImplements(project),
+                currentCompilerArgumentsBySourceSet,
+                defaultCompilerArgumentsBySourceSet,
+                getCoroutines(project)
+        )
+    }
 }

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinGradleProjectResolverExtension.kt

@@ -25,6 +25,7 @@ import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.roots.DependencyScope
 import com.intellij.openapi.util.Key
 import org.gradle.tooling.model.idea.IdeaModule
+import org.jetbrains.kotlin.gradle.CompilerArgumentsBySourceSet
 import org.jetbrains.kotlin.gradle.KotlinGradleModel
 import org.jetbrains.kotlin.gradle.KotlinGradleModelBuilder
 import org.jetbrains.kotlin.psi.UserDataProperty
@@ -33,9 +34,12 @@ import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
 import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil.getModuleId
 
-var DataNode<ModuleData>.currentCompilerArguments by UserDataProperty(Key.create<List<String>>("CURRENT_COMPILER_ARGUMENTS"))
-var DataNode<ModuleData>.defaultCompilerArguments by UserDataProperty(Key.create<List<String>>("DEFAULT_COMPILER_ARGUMENTS"))
-var DataNode<ModuleData>.coroutines by UserDataProperty(Key.create<String>("KOTLIN_COROUTINES"))
+var DataNode<ModuleData>.currentCompilerArgumentsBySourceSet
+        by UserDataProperty(Key.create<CompilerArgumentsBySourceSet>("CURRENT_COMPILER_ARGUMENTS"))
+var DataNode<ModuleData>.defaultCompilerArgumentsBySourceSet
+        by UserDataProperty(Key.create<CompilerArgumentsBySourceSet>("DEFAULT_COMPILER_ARGUMENTS"))
+var DataNode<ModuleData>.coroutines
+        by UserDataProperty(Key.create<String>("KOTLIN_COROUTINES"))
 
 class KotlinGradleProjectResolverExtension : AbstractProjectResolverExtension() {
     override fun getToolingExtensionsClasses(): Set<Class<out Any>> {
@@ -61,8 +65,8 @@ class KotlinGradleProjectResolverExtension : AbstractProjectResolverExtension()
             }
         }
 
-        ideModule.currentCompilerArguments = gradleModel.currentCompilerArguments
-        ideModule.defaultCompilerArguments = gradleModel.defaultCompilerArguments
+        ideModule.currentCompilerArgumentsBySourceSet = gradleModel.currentCompilerArgumentsBySourceSet
+        ideModule.defaultCompilerArgumentsBySourceSet = gradleModel.defaultCompilerArgumentsBySourceSet
         ideModule.coroutines = gradleModel.coroutines
 
         super.populateModuleDependencies(gradleModule, ideModule, ideProject)

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinGradleSourceSetDataService.kt

@@ -62,7 +62,7 @@ class KotlinGradleSourceSetDataService : AbstractProjectDataService<GradleSource
             val ideModule = modelsProvider.findIdeModule(sourceSetData) ?: continue
 
             val moduleNode = ExternalSystemApiUtil.findParent(sourceSetNode, ProjectKeys.MODULE) ?: continue
-            val kotlinFacet = configureFacetByGradleModule(moduleNode, ideModule, modelsProvider) ?: continue
+            val kotlinFacet = configureFacetByGradleModule(moduleNode, sourceSetNode, ideModule, modelsProvider) ?: continue
             GradleProjectImportHandler.getInstances(project).forEach { it.importBySourceSet(kotlinFacet, sourceSetNode) }
         }
     }
@@ -83,7 +83,7 @@ class KotlinGradleProjectDataService : AbstractProjectDataService<ModuleData, Vo
 
             val moduleData = moduleNode.data
             val ideModule = modelsProvider.findIdeModule(moduleData) ?: continue
-            val kotlinFacet = configureFacetByGradleModule(moduleNode, ideModule, modelsProvider) ?: continue
+            val kotlinFacet = configureFacetByGradleModule(moduleNode, null, ideModule, modelsProvider) ?: continue
             GradleProjectImportHandler.getInstances(project).forEach { it.importByModule(kotlinFacet, moduleNode) }
         }
     }
@@ -108,6 +108,7 @@ private fun detectPlatformByLibrary(moduleNode: DataNode<ModuleData>): TargetPla
 
 private fun configureFacetByGradleModule(
         moduleNode: DataNode<ModuleData>,
+        sourceSetNode: DataNode<GradleSourceSetData>?,
         ideModule: Module,
         modelsProvider: IdeModifiableModelsProvider
 ): KotlinFacet? {
@@ -121,8 +122,10 @@ private fun configureFacetByGradleModule(
     val kotlinFacet = ideModule.getOrCreateFacet(modelsProvider, false)
     kotlinFacet.configureFacet(compilerVersion, coroutinesProperty, platformKind, modelsProvider)
 
-    val currentCompilerArguments = moduleNode.currentCompilerArguments
-    val defaultCompilerArguments = moduleNode.defaultCompilerArguments ?: emptyList()
+    val sourceSetName = sourceSetNode?.data?.id?.let { it.substring(it.lastIndexOf(':') + 1) } ?: "main"
+
+    val currentCompilerArguments = moduleNode.currentCompilerArgumentsBySourceSet?.get(sourceSetName)
+    val defaultCompilerArguments = moduleNode.defaultCompilerArgumentsBySourceSet?.get(sourceSetName) ?: emptyList()
     if (currentCompilerArguments != null) {
         parseCompilerArgumentsToFacet(currentCompilerArguments, defaultCompilerArguments, kotlinFacet)
     }