Add native run tasks data to KotlinTarget.

2020-04-07 15:47:29 +03:00
parent dae8872aba
commit e1a88de314
16 changed files with 185 additions and 67 deletions
@@ -13,16 +13,16 @@ import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceTyp
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.util.Key
+import com.intellij.serialization.PropertyMapping
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.config.ExternalSystemTestTask
+import org.jetbrains.kotlin.config.ExternalSystemRunTask
 import org.jetbrains.kotlin.gradle.*
 import org.jetbrains.kotlin.idea.util.CopyableDataNodeUserDataProperty
 import org.jetbrains.plugins.gradle.util.GradleConstants
 import java.io.File
 import java.io.Serializable
 import com.intellij.openapi.externalSystem.model.Key as ExternalKey
-import com.intellij.serialization.PropertyMapping

 var DataNode<out ModuleData>.kotlinSourceSet: KotlinSourceSetInfo?
        by CopyableDataNodeUserDataProperty(Key.create("KOTLIN_SOURCE_SET"))
@@ -49,7 +49,7 @@ class KotlinSourceSetInfo @PropertyMapping("kotlinModule") constructor(val kotli
    var isTestModule: Boolean = false
    var sourceSetIdsByName: MutableMap<String, String> = LinkedHashMap()
    var dependsOn: List<String> = emptyList()
-    var externalSystemTestTasks: Collection<ExternalSystemTestTask> = emptyList()
+    var externalSystemRunTasks: Collection<ExternalSystemRunTask> = emptyList()
 }

 class KotlinAndroidSourceSetData @PropertyMapping("sourceSetInfos") constructor(val sourceSetInfos: List<KotlinSourceSetInfo>
@@ -15,7 +15,7 @@ import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.util.Key
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.config.ExternalSystemTestTask
+import org.jetbrains.kotlin.config.ExternalSystemRunTask
 import org.jetbrains.kotlin.gradle.*
 import org.jetbrains.kotlin.idea.util.CopyableDataNodeUserDataProperty
 import org.jetbrains.plugins.gradle.util.GradleConstants
@@ -45,7 +45,7 @@ class KotlinSourceSetInfo(val kotlinModule: KotlinModule) : Serializable {
    var isTestModule: Boolean = false
    var sourceSetIdsByName: MutableMap<String, String> = LinkedHashMap()
    var dependsOn: List<String> = emptyList()
-    var externalSystemTestTasks: Collection<ExternalSystemTestTask> = emptyList()
+    var externalSystemRunTasks: Collection<ExternalSystemRunTask> = emptyList()
 }

 class KotlinAndroidSourceSetData(
@@ -33,8 +33,7 @@ import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.ManualLanguageFeatureSetting
 import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
-import org.jetbrains.kotlin.config.ExternalSystemTestTask
-import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.gradle.*
 import org.jetbrains.kotlin.idea.configuration.GradlePropertiesFileFacade.Companion.KOTLIN_NOT_IMPORTED_COMMON_SOURCE_SETS_SETTING
 import org.jetbrains.kotlin.idea.configuration.klib.KotlinNativeLibrariesDependencySubstitutor
@@ -283,7 +282,7 @@ open class KotlinMPPGradleProjectResolver : AbstractProjectResolverExtensionComp

            val sourceSetMap = projectDataNode.getUserData(GradleProjectResolver.RESOLVED_SOURCE_SETS)!!

-            val sourceSetToTestTasks = calculateTestTasks(mppModel, gradleModule, resolverCtx)
+            val sourceSetToRunTasks = calculateRunTasks(mppModel, gradleModule, resolverCtx)

            val sourceSetToCompilationData = LinkedHashMap<KotlinSourceSet, MutableSet<GradleSourceSetData>>()
            for (target in mppModel.targets) {
@@ -336,8 +335,8 @@ open class KotlinMPPGradleProjectResolver : AbstractProjectResolverExtensionComp
                        gradleModule,
                        resolverCtx
                    ) ?: continue
-                    kotlinSourceSet.externalSystemTestTasks =
-                        compilation.sourceSets.firstNotNullResult { sourceSetToTestTasks[it] } ?: emptyList()
+                    kotlinSourceSet.externalSystemRunTasks =
+                        compilation.sourceSets.firstNotNullResult { sourceSetToRunTasks[it] } ?: emptyList()

                    if (compilation.platform == KotlinPlatform.JVM || compilation.platform == KotlinPlatform.ANDROID) {
                        compilationData.targetCompatibility = (kotlinSourceSet.compilerArguments as? K2JVMCompilerArguments)?.jvmTarget
@@ -396,7 +395,7 @@ open class KotlinMPPGradleProjectResolver : AbstractProjectResolverExtensionComp
                }

                val kotlinSourceSet = createSourceSetInfo(sourceSet, gradleModule, resolverCtx) ?: continue
-                kotlinSourceSet.externalSystemTestTasks = sourceSetToTestTasks[sourceSet] ?: emptyList()
+                kotlinSourceSet.externalSystemRunTasks = sourceSetToRunTasks[sourceSet] ?: emptyList()

                val sourceSetDataNode =
                    (existingSourceSetDataNode ?: mainModuleNode.createChild(GradleSourceSetData.KEY, sourceSetData)).also {
@@ -419,19 +418,38 @@ open class KotlinMPPGradleProjectResolver : AbstractProjectResolverExtensionComp
            //TODO improve passing version of used multiplatform
        }

-        private fun calculateTestTasks(
+        private fun calculateRunTasks(
            mppModel: KotlinMPPGradleModel,
            gradleModule: IdeaModule,
            resolverCtx: ProjectResolverContext
-        ): Map<KotlinSourceSet, Collection<ExternalSystemTestTask>> {
-            val sourceSetToTestTasks: MutableMap<KotlinSourceSet, MutableCollection<ExternalSystemTestTask>> = HashMap()
+        ): Map<KotlinSourceSet, Collection<ExternalSystemRunTask>> {
+            val sourceSetToRunTasks: MutableMap<KotlinSourceSet, MutableCollection<ExternalSystemRunTask>> = HashMap()
            val dependsOnReverseGraph: MutableMap<String, MutableSet<KotlinSourceSet>> = HashMap()
            mppModel.targets.forEach { target ->
                target.compilations.forEach { compilation ->
-                    val testTasks = target.testTasks.filter { testTask -> testTask.compilationName == compilation.name }
-                        .map { ExternalSystemTestTask(it.taskName, getKotlinModuleId(gradleModule, compilation, resolverCtx), target.name) }
+                    val testRunTasks = target.testRunTasks
+                        .filter { task -> task.compilationName == compilation.name }
+                        .map {
+                            ExternalSystemTestRunTask(
+                                it.taskName,
+                                getKotlinModuleId(gradleModule, compilation, resolverCtx),
+                                target.name
+                            )
+                        }
+                    val nativeMainRunTasks = target.nativeMainRunTasks
+                        .filter { task -> task.compilationName == compilation.name }
+                        .map {
+                            ExternalSystemNativeMainRunTask(
+                                it.taskName,
+                                getKotlinModuleId(gradleModule, compilation, resolverCtx),
+                                target.name,
+                                it.entryPoint,
+                                it.debuggable
+                            )
+                        }
+                    val allRunTasks = testRunTasks + nativeMainRunTasks
                    compilation.sourceSets.forEach { sourceSet ->
-                        sourceSetToTestTasks.getOrPut(sourceSet) { LinkedHashSet() } += testTasks
+                        sourceSetToRunTasks.getOrPut(sourceSet) { LinkedHashSet() } += allRunTasks
                        sourceSet.dependsOnSourceSets.forEach { dependentModule ->
                            dependsOnReverseGraph.getOrPut(dependentModule) { LinkedHashSet() } += sourceSet
                        }
@@ -440,10 +458,10 @@ open class KotlinMPPGradleProjectResolver : AbstractProjectResolverExtensionComp
            }
            mppModel.sourceSets.forEach { (sourceSetName, sourceSet) ->
                dependsOnReverseGraph[sourceSetName]?.forEach { dependingSourceSet ->
-                    sourceSetToTestTasks.getOrPut(sourceSet) { LinkedHashSet() } += sourceSetToTestTasks[dependingSourceSet] ?: emptyList()
+                    sourceSetToRunTasks.getOrPut(sourceSet) { LinkedHashSet() } += sourceSetToRunTasks[dependingSourceSet] ?: emptyList()
                }
            }
-            return sourceSetToTestTasks
+            return sourceSetToRunTasks
        }

        fun populateContentRoots(
@@ -150,7 +150,7 @@ class KotlinSourceSetDataService : AbstractProjectDataService<GradleSourceSetDat
                kind = kotlinSourceSet.kotlinModule.kind

                isTestModule = kotlinSourceSet.isTestModule
-                externalSystemTestTasks = ArrayList(kotlinSourceSet.externalSystemTestTasks)
+                externalSystemRunTasks = ArrayList(kotlinSourceSet.externalSystemRunTasks)

                externalProjectId = kotlinSourceSet.gradleModuleId

@@ -56,7 +56,7 @@ open class KotlinTestTasksResolver : AbstractProjectResolverExtension() {
    ): MutableCollection<TaskData> {
        val testTaskNames = mutableSetOf<String>().apply {
            mppModel.targets.forEach { target ->
-                target.testTasks.forEach { testTaskModel ->
+                target.testRunTasks.forEach { testTaskModel ->
                    add(testTaskModel.taskName)
                }
            }
@@ -53,7 +53,7 @@ open class KotlinTestTasksResolver : AbstractProjectResolverExtension() {
    ): MutableCollection<TaskData> {
        val testTaskNames = mutableSetOf<String>().apply {
            mppModel.targets.forEach { target ->
-                target.testTasks.forEach { testTaskModel ->
+                target.testRunTasks.forEach { testTaskModel ->
                    add(testTaskModel.taskName)
                }
            }
@@ -53,7 +53,7 @@ open class KotlinTestTasksResolver : AbstractProjectResolverExtension() {
    ): MutableCollection<TaskData> {
        val testTaskNames = mutableSetOf<String>().apply {
            mppModel.targets.forEach { target ->
-                target.testTasks.forEach { testTaskModel ->
+                target.testRunTasks.forEach { testTaskModel ->
                    add(testTaskModel.taskName)
                }
            }
@@ -19,7 +19,7 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.idea.caches.project.isNewMPPModule
-import org.jetbrains.kotlin.idea.facet.externalSystemTestTasks
+import org.jetbrains.kotlin.idea.facet.externalSystemTestRunTasks
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -83,7 +83,7 @@ abstract class AbstractKotlinMultiplatformTestMethodGradleConfigurationProducer
        val availableTargets =
            classes
                .mapNotNull { psiClass -> psiClass.module }
-                .flatMap { module -> module.externalSystemTestTasks() }
+                .flatMap { module -> module.externalSystemTestRunTasks() }
                .map { extTask -> extTask.targetName }
                .distinct()

@@ -9,8 +9,8 @@ import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.ExternalSystemTestTask
-import org.jetbrains.kotlin.idea.facet.externalSystemTestTasks
+import org.jetbrains.kotlin.config.ExternalSystemRunTask
+import org.jetbrains.kotlin.idea.facet.externalSystemTestRunTasks
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.plugins.gradle.execution.test.runner.*
 import org.jetbrains.plugins.gradle.util.TasksToRun
@@ -47,7 +47,7 @@ class MultiplatformTestTasksChooser : TestTasksChooser() {
            val module = element.module ?: continue
            val sourceFile = getSourceFile(element) ?: continue

-            val groupedTasks = module.externalSystemTestTasks().groupBy { it.targetName }
+            val groupedTasks = module.externalSystemTestRunTasks().groupBy { it.targetName }

            for ((group, tasksInGroup) in groupedTasks) {
                if (tasksInGroup.isEmpty()) {
@@ -59,7 +59,7 @@ class MultiplatformTestTasksChooser : TestTasksChooser() {
                    tasksMap[sourceFile.path] = TasksToRun.Impl(presentableName, getTaskNames(task))
                } else {
                    for (task in tasksInGroup) {
-                        val rawTaskName = ':' + task.testName
+                        val rawTaskName = ':' + task.taskName
                        val presentableName = if (group != null) "$group ($rawTaskName)" else rawTaskName
                        val tasksMap = tasks.getOrPut(presentableName) { LinkedHashMap() }
                        tasksMap[sourceFile.path] = TasksToRun.Impl(presentableName, getTaskNames(task))
@@ -91,10 +91,10 @@ class MultiplatformTestTasksChooser : TestTasksChooser() {
        super.chooseTestTasks(project, context, testTasks, consumer)
    }

-    private fun getTaskNames(task: ExternalSystemTestTask): List<String> {
-        return listOf("clean" + task.testName.capitalize(), task.testName)
+    private fun getTaskNames(task: ExternalSystemRunTask): List<String> {
+        return listOf("clean" + task.taskName.capitalize(), task.taskName)
    }
 }

-private val ExternalSystemTestTask.presentableName: String
-    get() = targetName ?: (":$testName")
+private val ExternalSystemRunTask.presentableName: String
+    get() = targetName ?: (":$taskName")
@@ -14,9 +14,9 @@ import com.intellij.openapi.roots.impl.ModuleOrderEntryImpl
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.jps.model.module.JpsModuleSourceRootType
 import org.jetbrains.jps.util.JpsPathUtil
-import org.jetbrains.kotlin.config.ExternalSystemTestTask
+import org.jetbrains.kotlin.config.ExternalSystemTestRunTask
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
-import org.jetbrains.kotlin.idea.facet.externalSystemTestTasks
+import org.jetbrains.kotlin.idea.facet.externalSystemTestRunTasks
 import org.jetbrains.kotlin.idea.project.isHMPPEnabled
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.project.platform
@@ -90,7 +90,7 @@ class ModuleInfo(
    private val rootModel = module.rootManager
    private val expectedDependencyNames = HashSet<String>()
    private val expectedSourceRoots = HashSet<String>()
-    private val expectedExternalSystemTestTasks = ArrayList<ExternalSystemTestTask>()
+    private val expectedExternalSystemTestTasks = ArrayList<ExternalSystemTestRunTask>()

    private val sourceFolderByPath by lazy {
        rootModel.contentEntries.asSequence()
@@ -161,7 +161,7 @@ class ModuleInfo(
    }

    fun externalSystemTestTask(taskName: String, projectId: String, targetName: String) {
-        expectedExternalSystemTestTasks.add(ExternalSystemTestTask(taskName, projectId, targetName))
+        expectedExternalSystemTestTasks.add(ExternalSystemTestRunTask(taskName, projectId, targetName))
    }

    fun libraryDependency(libraryName: String, scope: DependencyScope) {
@@ -279,9 +279,9 @@ class ModuleInfo(
            }
        }

-        if ((!module.externalSystemTestTasks().containsAll(expectedExternalSystemTestTasks)) || (projectInfo.exhaustiveTestsList && (module.externalSystemTestTasks() != expectedExternalSystemTestTasks))) {
+        if ((!module.externalSystemTestRunTasks().containsAll(expectedExternalSystemTestTasks)) || (projectInfo.exhaustiveTestsList && (module.externalSystemTestRunTasks() != expectedExternalSystemTestTasks))) {
            projectInfo.messageCollector.report(
-                "Module '${module.name}': Expected tests list $expectedExternalSystemTestTasks doesn't match the actual one: ${module.externalSystemTestTasks()}"
+                "Module '${module.name}': Expected tests list $expectedExternalSystemTestTasks doesn't match the actual one: ${module.externalSystemTestRunTasks()}"
            )
        }