[Gradle, Wasm] Binaryen by default for production main binary

^KT-64553 fixed

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/NewMultiplatformIT.kt

@@ -1679,7 +1679,6 @@ open class NewMultiplatformIT : BaseGradleIT() {
         }
         build(":wasmJs${name}Test") {
             assertTasksExecuted(":compileKotlinWasmJs")
-
             assertTasksNotExecuted(":compileTestDevelopmentExecutableKotlinWasmJsOptimize")
             assertTasksFailed(":wasmJs${name}Test")
             assertTestResults(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/binaryen/BinaryenExec.kt

@@ -5,8 +5,12 @@
 
 package org.jetbrains.kotlin.gradle.targets.js.binaryen
 
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.file.RegularFile
 import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 import org.gradle.work.DisableCachingByDefault
 import org.gradle.work.NormalizeLineEndings
@@ -37,8 +41,16 @@ constructor() : AbstractExecTask<BinaryenExec>(BinaryenExec::class.java) {
     @NormalizeLineEndings
     val inputFileProperty: RegularFileProperty = project.newFileProperty()
 
-    @OutputFile
+    @get:OutputDirectory
-    val outputFileProperty: RegularFileProperty = project.newFileProperty()
+    abstract val outputDirectory: DirectoryProperty
+
+    @get:Input
+    abstract val outputFileName: Property<String>
+
+    @Internal
+    val outputFileProperty: Provider<RegularFile> = project.provider {
+        outputDirectory.file(outputFileName).get()
+    }
 
     override fun exec() {
         val inputFile = inputFileProperty.asFile.get()
@@ -46,7 +58,7 @@ constructor() : AbstractExecTask<BinaryenExec>(BinaryenExec::class.java) {
         newArgs.addAll(binaryenArgs)
         newArgs.add(inputFile.canonicalPath)
         newArgs.add("-o")
-        newArgs.add(outputFileProperty.asFile.get().canonicalPath)
+        newArgs.add(outputDirectory.file(outputFileName).get().asFile.normalize().absolutePath)
         workingDir = inputFile.parentFile
         this.args = newArgs
         super.exec()
@@ -56,7 +68,7 @@ constructor() : AbstractExecTask<BinaryenExec>(BinaryenExec::class.java) {
         fun create(
             compilation: KotlinJsIrCompilation,
             name: String,
-            configuration: BinaryenExec.() -> Unit = {}
+            configuration: BinaryenExec.() -> Unit = {},
         ): TaskProvider<BinaryenExec> {
             val target = compilation.target
             val project = target.project

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/KotlinWasmTargetDsl.kt

@@ -17,8 +17,15 @@ import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
 interface KotlinWasmTargetDsl : KotlinTarget, HasBinaries<KotlinJsBinaryContainer> {
     val wasmTargetType: KotlinWasmTargetType?
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Binaryen is enabled by default. This call is redundant.")
     fun applyBinaryen() = applyBinaryen { }
+
+    @Deprecated("Binaryen is enabled by default. This call is redundant.")
     fun applyBinaryen(body: BinaryenExec.() -> Unit)
+
+    @Suppress("DEPRECATION")
+    @Deprecated("Binaryen is enabled by default. This call is redundant.")
     fun applyBinaryen(fn: Action<BinaryenExec>) {
         applyBinaryen {
             fn.execute(this)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/JsBinaries.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.gradle.targets.js.ir
 
 import org.gradle.api.Project
+import org.gradle.api.file.Directory
 import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskProvider
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.gradle.targets.js.subtargets.createDefaultDistributi
 import org.jetbrains.kotlin.gradle.targets.js.typescript.TypeScriptValidationTask
 import org.jetbrains.kotlin.gradle.tasks.configuration.KotlinJsIrLinkConfig
 import org.jetbrains.kotlin.gradle.tasks.registerTask
-import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.filesProvider
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.gradle.utils.mapToFile
@@ -189,10 +189,45 @@ open class ExecutableWasm(
 ) {
     val optimizeTaskName: String = optimizeTaskName()
 
-    val optimizeTask: TaskProvider<BinaryenExec>
+    val optimizeTask: TaskProvider<BinaryenExec> = BinaryenExec.create(compilation, optimizeTaskName) {
-        get() = target.project.tasks
+        val compileWasmDestDir = linkTask.map {
-            .withType<BinaryenExec>()
+            it.destinationDirectory
-            .named(optimizeTaskName)
+        }
+
+        val compiledWasmFile = linkTask.flatMap { link ->
+            link.destinationDirectory.locationOnly.zip(link.compilerOptions.moduleName) { destDir, moduleName ->
+                destDir.file("$moduleName.wasm")
+            }
+        }
+
+        dependsOn(linkTask)
+        inputFileProperty.set(compiledWasmFile)
+
+        val outputDirectory: Provider<Directory> = target.project.layout.buildDirectory
+            .dir(COMPILE_SYNC)
+            .map { it.dir(compilation.target.targetName) }
+            .map { it.dir(compilation.name) }
+            .map { it.dir(name) }
+            .map { it.dir("optimized") }
+
+        this.outputDirectory.set(outputDirectory)
+
+        outputFileName.set(
+            compiledWasmFile.map { it.asFile.name }
+        )
+
+        doLast {
+            fs.copy {
+                it.from(compileWasmDestDir)
+                it.into(outputDirectory)
+                it.eachFile {
+                    if (it.relativePath.getFile(outputDirectory.get().asFile).exists()) {
+                        it.exclude()
+                    }
+                }
+            }
+        }
+    }
 
     private fun optimizeTaskName(): String =
         "${linkTaskName}Optimize"

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrSubTarget.kt

@@ -16,10 +16,8 @@ import org.jetbrains.kotlin.gradle.plugin.AbstractKotlinTargetConfigurator
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetWithTests
 import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
-import org.jetbrains.kotlin.gradle.utils.whenEvaluated
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsPlatformTestRun
 import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetType
-import org.jetbrains.kotlin.gradle.targets.js.binaryen.BinaryenExec
 import org.jetbrains.kotlin.gradle.targets.js.dsl.Distribution
 import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalDistributionDsl
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBinaryMode
@@ -27,11 +25,12 @@ import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsSubTargetDsl
 import org.jetbrains.kotlin.gradle.targets.js.npm.npmProject
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
 import org.jetbrains.kotlin.gradle.tasks.dependsOn
-import org.jetbrains.kotlin.gradle.tasks.locateTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.testing.internal.configureConventions
 import org.jetbrains.kotlin.gradle.testing.internal.kotlinTestRegistry
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import org.jetbrains.kotlin.gradle.utils.whenEvaluated
+import org.jetbrains.kotlin.gradle.utils.withType
 
 abstract class KotlinJsIrSubTarget(
     val target: KotlinJsIrTarget,
@@ -55,13 +54,17 @@ abstract class KotlinJsIrSubTarget(
     }
 
     internal fun configure() {
+        configureTests()
         target.compilations.all {
             val npmProject = it.npmProject
             @Suppress("DEPRECATION")
             it.compilerOptions.options.freeCompilerArgs.add("$PER_MODULE_OUTPUT_NAME=${npmProject.name}")
+            it.binaries
+                .withType<ExecutableWasm>()
+                .configureEach { binary ->
+                    configureBinaryen(binary)
+                }
         }
-
-        configureTests()
     }
 
     private val produceExecutable: Unit by lazy {
@@ -126,15 +129,8 @@ abstract class KotlinJsIrSubTarget(
                 testJs.dependsOn(binary.linkSyncTask)
                 binary.mainFileSyncPath
             } else {
-                if (project.locateTask<BinaryenExec>((binary as ExecutableWasm).optimizeTaskName) != null) {
+                testJs.dependsOn(binary.linkTask)
-                    testJs.dependsOn(binary.optimizeTask)
+                binary.mainFile
-                    binary.optimizeTask.flatMap { optimizeTask ->
-                        optimizeTask.outputFileProperty
-                    }
-                } else {
-                    testJs.dependsOn(binary.linkTask)
-                    binary.mainFile
-                }
             }
 
             testJs.inputFileProperty.set(
@@ -233,6 +229,21 @@ abstract class KotlinJsIrSubTarget(
             }
     }
 
+    private fun configureBinaryen(binary: ExecutableWasm) {
+        val binaryenExec = binary.optimizeTask
+        if (binary.compilation.isMain() && binary.mode == KotlinJsBinaryMode.PRODUCTION) {
+            if (target.wasmTargetType == KotlinWasmTargetType.WASI) {
+
+                project.tasks.named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME).dependsOn(binaryenExec)
+            } else {
+                binary.linkSyncTask.configure {
+                    it.from.setFrom(binaryenExec.flatMap { it.outputFileProperty.map { it.asFile.parentFile } })
+                    it.dependsOn(binaryenExec)
+                }
+            }
+        }
+    }
+
     internal inline fun <reified T : Task> registerSubTargetTask(
         name: String,
         args: List<Any> = emptyList(),

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

@@ -151,7 +151,6 @@ constructor(
                 .withType(JsIrBinary::class.java)
                 .all { binary ->
                     val syncTask = binary.linkSyncTask
-                    binaryenReplaceInput[binary]?.invoke()
                     val tsValidationTask = registerTypeScriptCheckTask(binary)
 
                     binary.linkTask.configure {
@@ -182,97 +181,8 @@ constructor(
         }
     }
 
-    //Binaryen
+    @Deprecated("Binaryen is enabled by default. This call is redundant.")
-    private var binaryenReplaceInput: MutableMap<JsIrBinary, () -> Unit> = mutableMapOf()
-
     override fun applyBinaryen(body: BinaryenExec.() -> Unit) {
-        compilations.all {
-            it.binaries.all { binary ->
-                if (binary is ExecutableWasm) {
-                    val binaryenExec = createBinaryen(binary, body)
-
-                    if (
-                        wasmTargetType == KotlinWasmTargetType.WASI && nodejsLazyDelegate.isInitialized() ||
-                        project.locateTask<IncrementalSyncTask>(binary.linkSyncTaskName) != null
-                    ) {
-                        configureBinaryen(binary, binaryenExec)
-                    } else {
-                        binaryenReplaceInput[binary] = {
-                            configureBinaryen(binary, binaryenExec)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun createBinaryen(binary: ExecutableWasm, binaryenDsl: BinaryenExec.() -> Unit): TaskProvider<BinaryenExec> {
-        val linkTask = binary.linkTask
-
-        val compileWasmDestDir = linkTask.map {
-            it.destinationDirectory
-        }
-
-        val compiledWasmFile = linkTask.map { link ->
-            link.destinationDirectory.asFile.get().resolve(link.compilerOptions.moduleName.get() + ".wasm")
-        }
-
-        return BinaryenExec.create(binary.compilation, binary.optimizeTaskName) {
-            val compilation = binary.compilation
-            dependsOn(linkTask)
-            inputFileProperty.fileProvider(compiledWasmFile)
-
-            val outputDirectory: Provider<File> = binary.target.project.layout.buildDirectory
-                .dir(COMPILE_SYNC)
-                .map { it.dir(compilation.target.targetName) }
-                .map { it.dir(compilation.name) }
-                .map { it.dir(binary.name) }
-                .map { it.dir("optimized") }
-                .map { it.asFile }
-
-            val outputFile = outputDirectory.map { it.resolve(compiledWasmFile.get().name) }
-
-            outputFileProperty.fileProvider(
-                outputFile
-            )
-
-            doLast {
-                fs.copy {
-                    it.from(compileWasmDestDir)
-                    it.into(outputDirectory)
-                    it.eachFile {
-                        if (it.relativePath.getFile(outputDirectory.get()).exists()) {
-                            it.exclude()
-                        }
-                    }
-                }
-            }
-
-            binaryenDsl()
-        }
-    }
-
-    private fun configureBinaryen(binary: JsIrBinary, binaryenExec: TaskProvider<BinaryenExec>) {
-        if (wasmTargetType == KotlinWasmTargetType.WASI) {
-            if (binary.compilation.isMain() && binary.mode == KotlinJsBinaryMode.PRODUCTION) {
-                project.tasks.named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME).dependsOn(binaryenExec)
-            }
-
-            whenNodejsConfigured {
-                testTask {
-                    val name = binary.mainFileName
-                    it.inputFileProperty.fileProvider(
-                        binaryenExec.flatMap { it.outputFileProperty.map { it.asFile.parentFile.resolve(name.get()) } }
-                    )
-                    it.dependsOn(binaryenExec)
-                }
-            }
-        } else {
-            binary.linkSyncTask.configure {
-                it.from.setFrom(binaryenExec.flatMap { it.outputFileProperty.map { it.asFile.parentFile } })
-                it.dependsOn(binaryenExec)
-            }
-        }
     }
 
     //Browser
@@ -304,12 +214,8 @@ constructor(
             commonLazy
         } else {
             NodeJsRootPlugin.apply(project.rootProject)
-            compilations.all { compilation ->
-                compilation.binaries.all { binary ->
-                    binaryenReplaceInput[binary]?.invoke()
-                }
-            }
         }
+
         project.objects.newInstance(KotlinNodeJsIr::class.java, this).also {
             it.configureSubTarget()
             nodejsConfiguredHandlers.forEach { handler ->