[Gradle, JS] Copy JS plugin for IR

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

@@ -24,8 +24,10 @@ import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 import org.jetbrains.kotlin.konan.target.CompilerOutputKind
 import kotlin.reflect.KClass
 
@@ -68,7 +70,7 @@ abstract class KotlinSingleTargetExtension : KotlinProjectExtension() {
 }
 
 abstract class KotlinSingleJavaTargetExtension : KotlinSingleTargetExtension() {
-    override abstract val target: KotlinWithJavaTarget<*>
+    abstract override val target: KotlinWithJavaTarget<*>
 }
 
 open class KotlinJvmProjectExtension : KotlinSingleJavaTargetExtension() {
@@ -98,6 +100,19 @@ open class KotlinJsProjectExtension : KotlinSingleTargetExtension() {
         target.project.container(KotlinTarget::class.java).apply { add(target) }
 }
 
+open class KotlinJsIrProjectExtension : KotlinSingleTargetExtension() {
+    override lateinit var target: KotlinJsIrTarget
+
+    open fun target(body: KotlinJsIrTarget.() -> Unit) = target.run(body)
+
+    @Deprecated(
+        "Needed for IDE import using the MPP import mechanism",
+        level = DeprecationLevel.HIDDEN
+    )
+    fun getTargets() =
+        target.project.container(KotlinTarget::class.java).apply { add(target) }
+}
+
 open class KotlinCommonProjectExtension : KotlinSingleJavaTargetExtension() {
     override lateinit var target: KotlinWithJavaTarget<KotlinMultiplatformCommonOptions>
         internal set

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

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
 import org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSetFactory
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsPlugin
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrPlugin
 import org.jetbrains.kotlin.gradle.targets.js.npm.addNpmDependencyExtension
 import org.jetbrains.kotlin.gradle.tasks.KOTLIN_COMPILER_EMBEDDABLE
 import org.jetbrains.kotlin.gradle.tasks.KOTLIN_MODULE_GROUP
@@ -164,6 +165,18 @@ open class KotlinJsPluginWrapper @Inject constructor(
     override fun createTestRegistry(project: Project) = KotlinTestsRegistry(project, "test")
 }
 
+open class KotlinJsIrPluginWrapper @Inject constructor(
+    fileResolver: FileResolver
+) : KotlinBasePluginWrapper(fileResolver) {
+    override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
+        KotlinJsIrPlugin(kotlinPluginVersion)
+
+    override val projectExtensionClass: KClass<out KotlinJsIrProjectExtension>
+        get() = KotlinJsIrProjectExtension::class
+
+    override fun createTestRegistry(project: Project) = KotlinTestsRegistry(project, "test")
+}
+
 open class KotlinMultiplatformPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     private val featurePreviews: FeaturePreviews

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/KotlinJsPlatformTestRun.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.gradle.targets.js
 
 import org.jetbrains.kotlin.gradle.execution.KotlinAggregateExecutionSource
-import org.jetbrains.kotlin.gradle.execution.KotlinAggregatingExecution
 import org.jetbrains.kotlin.gradle.plugin.CompilationExecutionSource
 import org.jetbrains.kotlin.gradle.plugin.CompilationExecutionSourceSupport
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetTestRun
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 import org.jetbrains.kotlin.gradle.targets.js.subtargets.KotlinJsSubTarget
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
 import org.jetbrains.kotlin.gradle.testing.KotlinReportAggregatingTestRun
@@ -48,6 +48,13 @@ class JsAggregatingExecutionSource(private val aggregatingTestRun: KotlinJsRepor
         get() = aggregatingTestRun.getConfiguredExecutions().map { it.executionSource }
 }
 
+class JsIrAggregatingExecutionSource(private val aggregatingTestRun: KotlinJsIrReportAggregatingTestRun) :
+    KotlinAggregateExecutionSource<JsCompilationExecutionSource> {
+
+    override val executionSources: Iterable<JsCompilationExecutionSource>
+        get() = aggregatingTestRun.getConfiguredExecutions().map { it.executionSource }
+}
+
 open class KotlinJsReportAggregatingTestRun(
     testRunName: String,
     override val target: KotlinJsTarget
@@ -82,3 +89,38 @@ open class KotlinJsReportAggregatingTestRun(
         target.whenNodejsConfigured { doConfigureInChildren(this as KotlinJsSubTarget) }
     }
 }
+
+open class KotlinJsIrReportAggregatingTestRun(
+    testRunName: String,
+    override val target: KotlinJsIrTarget
+) : KotlinReportAggregatingTestRun<JsCompilationExecutionSource, JsIrAggregatingExecutionSource, KotlinJsPlatformTestRun>(testRunName),
+    KotlinTargetTestRun<JsIrAggregatingExecutionSource>,
+    CompilationExecutionSourceSupport<KotlinJsCompilation> {
+
+    override fun setExecutionSourceFrom(compilation: KotlinJsCompilation) = configureAllExecutions {
+        setExecutionSourceFrom(compilation)
+    }
+
+    override val executionSource: JsIrAggregatingExecutionSource
+        get() = JsIrAggregatingExecutionSource(this)
+
+    private fun KotlinJsSubTarget.getChildTestExecution() = testRuns.maybeCreate(testRunName)
+
+    override fun getConfiguredExecutions(): Iterable<KotlinJsPlatformTestRun> = mutableListOf<KotlinJsPlatformTestRun>().apply {
+        if (target.isNodejsConfigured) {
+            add(target.nodejs.getChildTestExecution())
+        }
+        if (target.isBrowserConfigured) {
+            add(target.browser.getChildTestExecution())
+        }
+    }
+
+    override fun configureAllExecutions(configure: KotlinJsPlatformTestRun.() -> Unit) {
+        val doConfigureInChildren: KotlinJsSubTarget.() -> Unit = {
+            configure(getChildTestExecution())
+        }
+
+        target.whenBrowserConfigured { doConfigureInChildren(this as KotlinJsSubTarget) }
+        target.whenNodejsConfigured { doConfigureInChildren(this as KotlinJsSubTarget) }
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/KotlinJsTargetDsl.kt

@@ -9,12 +9,33 @@ import groovy.lang.Closure
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDce
+import org.jetbrains.kotlin.gradle.targets.js.KotlinJsIrReportAggregatingTestRun
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsPlatformTestRun
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsReportAggregatingTestRun
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsExec
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
 import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpack
 
+interface KotlinJsIrTargetDsl {
+    fun browser() = browser { }
+    fun browser(body: KotlinJsBrowserDsl.() -> Unit)
+    fun browser(fn: Closure<*>) {
+        browser {
+            ConfigureUtil.configure(fn, this)
+        }
+    }
+
+    fun nodejs() = nodejs { }
+    fun nodejs(body: KotlinJsNodeDsl.() -> Unit)
+    fun nodejs(fn: Closure<*>) {
+        nodejs {
+            ConfigureUtil.configure(fn, this)
+        }
+    }
+
+    val testRuns: NamedDomainObjectContainer<KotlinJsIrReportAggregatingTestRun>
+}
+
 interface KotlinJsTargetDsl {
     fun browser() = browser { }
     fun browser(body: KotlinJsBrowserDsl.() -> Unit)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrPlugin.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.targets.js.ir
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaBasePlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsIrProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+import org.jetbrains.kotlin.gradle.plugin.configureDefaultVersionsResolutionStrategy
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsIrSingleTargetPreset
+import org.jetbrains.kotlin.gradle.utils.checkGradleCompatibility
+
+open class KotlinJsIrPlugin(
+    private val kotlinPluginVersion: String
+) : Plugin<Project> {
+
+    override fun apply(project: Project) {
+        // TODO get rid of this plugin, too? Use the 'base' plugin instead?
+        // in fact, the attributes schema of the Java base plugin may be required to consume non-MPP Kotlin/JS libs,
+        // so investigation is needed
+        project.plugins.apply(JavaBasePlugin::class.java)
+
+        checkGradleCompatibility()
+
+        val kotlinExtension = project.kotlinExtension as KotlinJsIrProjectExtension
+        configureDefaultVersionsResolutionStrategy(project, kotlinPluginVersion)
+
+        val target = KotlinJsIrSingleTargetPreset(project, kotlinPluginVersion).createTarget("Js")
+
+        kotlinExtension.target = target
+
+        project.components.addAll(target.components)
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTarget.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.targets.js.ir
+
+import org.gradle.api.NamedDomainObjectContainer
+import org.gradle.api.Project
+import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.plugin.AbstractKotlinTargetConfigurator.Companion.runTaskNameSuffix
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.KotlinTargetWithTests
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinOnlyTarget
+import org.jetbrains.kotlin.gradle.targets.js.JsIrAggregatingExecutionSource
+import org.jetbrains.kotlin.gradle.targets.js.KotlinJsIrReportAggregatingTestRun
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBrowserDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsIrTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsNodeDsl
+import org.jetbrains.kotlin.gradle.targets.js.subtargets.KotlinBrowserJs
+import org.jetbrains.kotlin.gradle.targets.js.subtargets.KotlinNodeJs
+import org.jetbrains.kotlin.gradle.tasks.locateTask
+import org.jetbrains.kotlin.gradle.testing.internal.KotlinTestReport
+import org.jetbrains.kotlin.gradle.testing.testTaskName
+import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import javax.inject.Inject
+
+open class KotlinJsIrTarget @Inject constructor(project: Project, platformType: KotlinPlatformType) :
+    KotlinOnlyTarget<KotlinJsCompilation>(project, platformType),
+    KotlinTargetWithTests<JsIrAggregatingExecutionSource, KotlinJsIrReportAggregatingTestRun>,
+    KotlinJsIrTargetDsl {
+    override lateinit var testRuns: NamedDomainObjectContainer<KotlinJsIrReportAggregatingTestRun>
+        internal set
+
+    val testTaskName get() = testRuns.getByName(KotlinTargetWithTests.DEFAULT_TEST_RUN_NAME).testTaskName
+    val testTask: TaskProvider<KotlinTestReport>
+        get() = checkNotNull(project.locateTask(testTaskName))
+
+    val runTaskName get() = lowerCamelCaseName(disambiguationClassifier, runTaskNameSuffix)
+    val runTask
+        get() = project.tasks.maybeCreate(runTaskName).also {
+            it.description = "Run js on all configured platforms"
+        }
+
+    private val browserLazyDelegate = lazy {
+        project.objects.newInstance(KotlinBrowserJs::class.java, this).also {
+            it.configure()
+            browserConfiguredHandlers.forEach { handler -> handler(it) }
+            browserConfiguredHandlers.clear()
+        }
+    }
+
+    private val browserConfiguredHandlers = mutableListOf<KotlinJsBrowserDsl.() -> Unit>()
+
+    val browser by browserLazyDelegate
+
+    internal val isBrowserConfigured: Boolean = browserLazyDelegate.isInitialized()
+
+    override fun browser(body: KotlinJsBrowserDsl.() -> Unit) {
+        body(browser)
+    }
+
+    private val nodejsLazyDelegate = lazy {
+        project.objects.newInstance(KotlinNodeJs::class.java, this).also {
+            it.configure()
+            nodejsConfiguredHandlers.forEach { handler -> handler(it) }
+            nodejsConfiguredHandlers.clear()
+        }
+    }
+
+    private val nodejsConfiguredHandlers = mutableListOf<KotlinJsNodeDsl.() -> Unit>()
+
+    val nodejs by nodejsLazyDelegate
+
+    internal val isNodejsConfigured: Boolean = nodejsLazyDelegate.isInitialized()
+
+    override fun nodejs(body: KotlinJsNodeDsl.() -> Unit) {
+        body(nodejs)
+    }
+
+    fun whenBrowserConfigured(body: KotlinJsBrowserDsl.() -> Unit) {
+        if (browserLazyDelegate.isInitialized()) {
+            browser(body)
+        } else {
+            browserConfiguredHandlers += body
+        }
+    }
+
+    fun whenNodejsConfigured(body: KotlinJsNodeDsl.() -> Unit) {
+        if (nodejsLazyDelegate.isInitialized()) {
+            nodejs(body)
+        } else {
+            nodejsConfiguredHandlers += body
+        }
+    }
+
+    fun useCommonJs() {
+        compilations.all {
+            it.compileKotlinTask.kotlinOptions {
+                moduleKind = "commonjs"
+                sourceMap = true
+                sourceMapEmbedSources = null
+            }
+        }
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTargetConfigurator.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.targets.js.ir
+
+import org.jetbrains.kotlin.gradle.plugin.Kotlin2JsSourceSetProcessor
+import org.jetbrains.kotlin.gradle.plugin.KotlinOnlyTargetConfigurator
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetProcessor
+import org.jetbrains.kotlin.gradle.plugin.KotlinTargetWithTestsConfigurator
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
+import org.jetbrains.kotlin.gradle.targets.js.KotlinJsIrReportAggregatingTestRun
+import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider
+import org.jetbrains.kotlin.gradle.testing.internal.kotlinTestRegistry
+import org.jetbrains.kotlin.gradle.testing.testTaskName
+
+open class KotlinJsIrTargetConfigurator(kotlinPluginVersion: String) :
+    KotlinOnlyTargetConfigurator<KotlinJsCompilation, KotlinJsIrTarget>(true, true, kotlinPluginVersion),
+    KotlinTargetWithTestsConfigurator<KotlinJsIrReportAggregatingTestRun, KotlinJsIrTarget> {
+
+    override val testRunClass: Class<KotlinJsIrReportAggregatingTestRun> get() = KotlinJsIrReportAggregatingTestRun::class.java
+
+    override fun createTestRun(
+        name: String,
+        target: KotlinJsIrTarget
+    ): KotlinJsIrReportAggregatingTestRun {
+        val result = KotlinJsIrReportAggregatingTestRun(name, target)
+
+        val testTask = target.project.kotlinTestRegistry.getOrCreateAggregatedTestTask(
+            name = result.testTaskName,
+            description = "Run JS tests for all platforms"
+        )
+
+        // workaround to avoid the infinite recursion in item factories of the target and the subtargets:
+        target.testRuns.matching { it.name == name }.whenObjectAdded {
+            it.configureAllExecutions {
+                // do not do anything with the aggregated test run, but ensure that they are created
+            }
+        }
+
+        result.executionTask = testTask
+
+        return result
+    }
+
+    override fun buildCompilationProcessor(compilation: KotlinJsCompilation): KotlinSourceSetProcessor<*> {
+        val tasksProvider = KotlinTasksProvider(compilation.target.targetName)
+        return Kotlin2JsSourceSetProcessor(compilation.target.project, tasksProvider, compilation, kotlinPluginVersion)
+    }
+
+    override fun configureCompilations(target: KotlinJsIrTarget) {
+        super.configureCompilations(target)
+
+        target.compilations.all {
+            it.compileKotlinTask.kotlinOptions {
+                moduleKind = "umd"
+                sourceMap = true
+                sourceMapEmbedSources = null
+            }
+        }
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTargetPreset.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("PackageDirectoryMismatch")
+
+// Old package for compatibility
+package org.jetbrains.kotlin.gradle.plugin.mpp
+
+import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTargetConfigurator
+
+open class KotlinJsIrTargetPreset(
+    project: Project,
+    kotlinPluginVersion: String
+) : KotlinOnlyTargetPreset<KotlinJsIrTarget, KotlinJsCompilation>(
+    project,
+    kotlinPluginVersion
+) {
+    override val platformType: KotlinPlatformType
+        get() = KotlinPlatformType.js
+
+    override fun instantiateTarget(): KotlinJsIrTarget {
+        return project.objects.newInstance(KotlinJsIrTarget::class.java, project, platformType)
+    }
+
+    override fun createKotlinTargetConfigurator() = KotlinJsIrTargetConfigurator(kotlinPluginVersion)
+
+    override fun getName(): String = PRESET_NAME
+
+    override fun createCompilationFactory(forTarget: KotlinOnlyTarget<KotlinJsCompilation>) =
+        KotlinJsCompilationFactory(project, forTarget)
+
+    companion object {
+        const val PRESET_NAME = "js"
+    }
+}
+
+class KotlinJsIrSingleTargetPreset(
+    project: Project,
+    kotlinPluginVersion: String
+) :
+    KotlinJsIrTargetPreset(project, kotlinPluginVersion) {
+
+    // In a Kotlin/JS single-platform project, we don't need any disambiguation suffixes or prefixes in the names:
+    override fun provideTargetDisambiguationClassifier(target: KotlinOnlyTarget<KotlinJsCompilation>): String? = null
+
+    override fun createKotlinTargetConfigurator() = KotlinJsIrTargetConfigurator(kotlinPluginVersion)
+}

libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/org.jetbrains.kotlin.js.ir.properties

@@ -0,0 +1 @@
+implementation-class=org.jetbrains.kotlin.gradle.plugin.KotlinJsIrPluginWrapper

libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/org.jetbrains.kotlin.js.properties

@@ -1 +1 @@
-implementation-class=org.jetbrains.kotlin.gradle.plugin.KotlinJsPluginWrapper
+implementation-class=org.jetbrains.kotlin.gradle.plugin.KotlinJsIrPluginWrapper