[Gradle, JS] Migrate onto destinationDirectory and outputName

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSCompilerArguments.kt

@@ -28,6 +28,12 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-output", valueDescription = "<filepath>", description = "Destination *.js file for the compilation result")
     var outputFile: String? by NullableStringFreezableVar(null)
 
+    @Argument(value = "-Xir-output-dir", valueDescription = "<directory>", description = "Destination for generated files")
+    var outputDir: String? by NullableStringFreezableVar(null)
+
+    @Argument(value = "-Xir-output-name", description = "Base name of generated files")
+    var outputName: String? by NullableStringFreezableVar(null)
+
     @GradleOption(
         value = DefaultValues.BooleanTrueDefault::class,
         gradleInputType = GradleInputTypes.INPUT

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -238,9 +238,15 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
         if (!checkKotlinPackageUsage(environmentForJS.configuration, sourcesFiles)) return ExitCode.COMPILATION_ERROR
 
-        val outputFilePath = arguments.outputFile
+        val outputDirPath = arguments.outputDir
-        if (outputFilePath == null) {
+        val outputName = arguments.outputName
-            messageCollector.report(ERROR, "IR: Specify output file via -output", null)
+        if (outputDirPath == null) {
+            messageCollector.report(ERROR, "IR: Specify output dir via -Xir-output-dir", null)
+            return ExitCode.COMPILATION_ERROR
+        }
+
+        if (outputName == null) {
+            messageCollector.report(ERROR, "IR: Specify output name via -Xir-output-name", null)
             return ExitCode.COMPILATION_ERROR
         }
 
@@ -257,12 +263,11 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             reportCompiledSourcesList(messageCollector, sourcesFiles)
         }
 
-        val outputFile = File(outputFilePath)
+        val moduleName = arguments.irModuleName ?: outputName
-
-        val moduleName = arguments.irModuleName ?: FileUtil.getNameWithoutExtension(outputFile)
         configurationJs.put(CommonConfigurationKeys.MODULE_NAME, moduleName)
 
-        val outputDir: File = outputFile.parentFile ?: outputFile.absoluteFile.parentFile!!
+        val outputDir = File(outputDirPath)
+
         try {
             configurationJs.put(JSConfigurationKeys.OUTPUT_DIR, outputDir.canonicalFile)
         } catch (e: IOException) {
@@ -279,7 +284,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         val icCaches = if (!arguments.wasm && cacheDirectories.isNotEmpty()) {
             messageCollector.report(INFO, "")
             messageCollector.report(INFO, "Building cache:")
-            messageCollector.report(INFO, "to: ${outputFilePath}")
+            messageCollector.report(INFO, "to: ${outputDir}")
             messageCollector.report(INFO, arguments.cacheDirectories ?: "")
             messageCollector.report(INFO, libraries.toString())
 
@@ -347,21 +352,21 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
-            if (arguments.irProduceKlibFile) {
-                require(outputFile.extension == KLIB_FILE_EXTENSION) { "Please set up .klib file as output" }
-            }
 
             generateKLib(
                 sourceModule,
                 irFactory = IrFactoryImpl,
-                outputKlibPath = outputFile.path,
+                outputKlibPath = if (arguments.irProduceKlibFile)
+                    outputDir.resolve("$outputName.klib").normalize().absolutePath
+                else
+                    outputDirPath,
                 nopack = arguments.irProduceKlibDir,
                 jsOutputName = arguments.irPerModuleOutputName,
             )
         }
 
         if (arguments.irProduceJs) {
-            messageCollector.report(INFO, "Produce executable: $outputFilePath")
+            messageCollector.report(INFO, "Produce executable: $outputDirPath")
             messageCollector.report(INFO, arguments.cacheDirectories ?: "")
 
             if (icCaches.isNotEmpty()) {
@@ -383,10 +388,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     }
                 )
 
-                outputFile.write(outputs)
+                outputs.write(outputDir, outputName)
-                outputs.dependencies.forEach { (name, content) ->
-                    outputFile.resolveSibling("$name.js").write(content)
-                }
 
                 messageCollector.report(INFO, "Executable production duration (IC): ${System.currentTimeMillis() - beforeIc2Js}ms")
 
@@ -416,6 +418,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
 
             if (arguments.wasm) {
+                val outputFile = File(arguments.outputFile)
                 val (allModules, backendContext) = compileToLoweredIr(
                     depsDescriptors = module,
                     phaseConfig = PhaseConfig(wasmPhases),
@@ -455,10 +458,8 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
                 messageCollector.report(INFO, "Executable production duration: ${System.currentTimeMillis() - start}ms")
 
-                outputFile.write(outputs)
+                outputs.write(outputDir, outputName)
-                outputs.dependencies.forEach { (name, content) ->
+
-                    outputFile.resolveSibling("$name.js").write(content)
-                }
                 if (arguments.generateDts) {
                     val dtsFile = outputFile.withReplacedExtensionOrNull(outputFile.extension, "d.ts")!!
                     dtsFile.writeText(tsDefinitions)
@@ -481,6 +482,18 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         return OK
     }
 
+    private fun CompilationOutputs.write(outputDir: File, outputName: String) {
+        val outputFile = outputDir.resolve("$outputName.js")
+        outputFile.parentFile.mkdirs()
+        outputFile.write(this)
+        dependencies.forEach { (name, content) ->
+            outputDir.resolve("$name.js").let {
+                it.parentFile.mkdirs()
+                it.write(content)
+            }
+        }
+    }
+
     private fun File.write(outputs: CompilationOutputs) {
         writeText(outputs.jsCode)
         outputs.writeSourceMapIfPresent(this)

compiler/testData/cli/js/jsExtraHelp.out

@@ -38,6 +38,8 @@ where advanced options include:
                              Enable runtime diagnostics when access safely to boolean in external declarations
   -Xlegacy-deprecated-no-warn Disable warnings of deprecation of legacy compiler
   -Xmetadata-only            Generate *.meta.js and *.kjsm files only
+  -Xir-output-dir=<directory> Destination for generated files
+  -Xir-output-name           Base name of generated files
   -Xpartial-linkage          Allow unlinked symbols
   -Xrepositories=<path>      Paths to additional places where libraries could be found
   -Xstrict-implicit-export-types Generate strict types for implicitly exported entities inside d.ts files. Available in IR backend only.

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

@@ -120,10 +120,8 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
                 ) { task ->
                     task.dependsOn(binary.linkSyncTask)
                     val entryFileProvider = binary.linkSyncTask.flatMap { syncTask ->
-                        binary.linkTask.flatMap { linkTask ->
+                        binary.linkTask.map {
-                            linkTask.outputFileProperty.map {
+                            syncTask.destinationDir.resolve(it.outputFileProperty.get().name)
-                                syncTask.destinationDir.resolve(it.name)
-                            }
                         }
                     }
 
@@ -207,13 +205,9 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
                     ),
                     listOf(compilation)
                 ) { task ->
-                    task.dependsOn(binary.linkSyncTask)
+                    val entryFileProvider = binary.linkSyncTask.map {
-                    val entryFileProvider = binary.linkSyncTask.flatMap { linkSyncTask ->
+                        it.destinationDir
-                        binary.linkTask.flatMap { linkTask ->
+                            .resolve(binary.linkTask.get().outputName.get() + ".js")
-                            linkTask.outputFileProperty.map {
-                                linkSyncTask.destinationDir.resolve(it.name)
-                            }
-                        }
                     }
 
                     task.description = "build webpack ${mode.name.toLowerCase()} bundle"

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

@@ -10,18 +10,21 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
-import org.gradle.work.NormalizeLineEndings
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
 import org.jetbrains.kotlin.compilerRunner.ArgumentUtils
-import org.jetbrains.kotlin.gradle.dsl.CompilerJsOptionsDefault
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptionsImpl
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBinaryMode
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBinaryMode.DEVELOPMENT
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBinaryMode.PRODUCTION
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
+import org.jetbrains.kotlin.gradle.utils.getValue
 import org.jetbrains.kotlin.gradle.utils.toHexString
 import org.jetbrains.kotlin.statistics.metrics.BooleanMetrics
 import org.jetbrains.kotlin.statistics.metrics.StringMetrics
@@ -34,6 +37,7 @@ import javax.inject.Inject
 abstract class KotlinJsIrLink @Inject constructor(
     objectFactory: ObjectFactory,
     workerExecutor: WorkerExecutor,
+    private val projectLayout: ProjectLayout
 ) : Kotlin2JsCompile(
     objectFactory.newInstance(CompilerJsOptionsDefault::class.java),
     objectFactory,
@@ -56,6 +60,10 @@ abstract class KotlinJsIrLink @Inject constructor(
     @get:Internal
     internal lateinit var compilation: KotlinCompilationData<*>
 
+    private val platformType by project.provider {
+        compilation.platformType
+    }
+
     @Transient
     @get:Internal
     internal val propertiesProvider = PropertiesProvider(project)
@@ -86,13 +94,6 @@ abstract class KotlinJsIrLink @Inject constructor(
     @get:PathSensitive(PathSensitivity.RELATIVE)
     internal abstract val entryModule: DirectoryProperty
 
-    @Deprecated(
-        message = "Replace with destinationDirectory",
-        replaceWith = ReplaceWith("destinationDirectory")
-    )
-    @get:Internal
-    val normalizedDestinationDirectory: DirectoryProperty get() = destinationDirectory
-
     @get:Internal
     val rootCacheDirectory by lazy {
         buildDir.resolve("klib/cache")
@@ -144,4 +145,53 @@ abstract class KotlinJsIrLink @Inject constructor(
             .toTypedArray()
             .filterNot { it.isEmpty() }
     }
+
+    override fun setupCompilerArgs(args: K2JSCompilerArguments, defaultsOnly: Boolean, ignoreClasspathResolutionErrors: Boolean) {
+        when (mode) {
+            PRODUCTION -> {
+                kotlinOptions.configureOptions(ENABLE_DCE, GENERATE_D_TS, MINIMIZED_MEMBER_NAMES)
+            }
+
+            DEVELOPMENT -> {
+                kotlinOptions.configureOptions(GENERATE_D_TS)
+            }
+        }
+        val alreadyDefinedOutputMode = kotlinOptions.freeCompilerArgs
+            .any { it.startsWith(PER_MODULE) }
+        if (!alreadyDefinedOutputMode) {
+            kotlinOptions.freeCompilerArgs += outputGranularity.toCompilerArgument()
+        }
+        super.setupCompilerArgs(args, defaultsOnly, ignoreClasspathResolutionErrors)
+    }
+
+    private fun KotlinJsOptions.configureOptions(vararg additionalCompilerArgs: String) {
+        freeCompilerArgs += (additionalCompilerArgs.toList() + PRODUCE_JS + "$ENTRY_IR_MODULE=${entryModule.get().asFile.canonicalPath}")
+            .mapNotNull { arg ->
+                if (kotlinOptions.freeCompilerArgs
+                        .any { it.startsWith(arg) }
+                ) null else arg
+            }
+
+        if (platformType == KotlinPlatformType.wasm) {
+            freeCompilerArgs += WASM_BACKEND
+        }
+    }
+
+    @get:Input
+    override val filteredArgumentsMap: Map<String, String>
+        get() {
+            val superFiltered = super.filteredArgumentsMap
+            return superFiltered.mapValues { (key, value) ->
+                if (key != K2JSCompilerArguments::freeArgs.name) {
+                    value
+                } else {
+                    value
+                        .removePrefix("[")
+                        .removeSuffix("]")
+                        .split(", ")
+                        .filter { !it.contains(ENTRY_IR_MODULE) }
+                        .joinToString()
+                }
+            }
+        }
 }

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

@@ -121,15 +121,13 @@ abstract class KotlinJsIrSubTarget(
                 KotlinJsBinaryMode.DEVELOPMENT
             ).single()
 
-            testJs.dependsOn(binary.linkSyncTask)
+            testJs.inputFileProperty.set(
-            testJs.inputFileProperty.fileProvider(
+                project.layout.file(
-                binary.linkSyncTask.flatMap { linkSyncTask ->
+                    binary.linkSyncTask.map {
-                    binary.linkTask.flatMap { linkTask ->
+                        it.destinationDir
-                        linkTask.outputFileProperty.map {
+                            .resolve(binary.linkTask.get().outputName.get() + ".js")
-                            linkSyncTask.destinationDir.resolve(it.name)
-                        }
                     }
-                }
+                )
             )
 
             configureTestDependencies(testJs)

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

@@ -11,6 +11,7 @@ import org.gradle.api.Task
 import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptionsImpl
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.AbstractKotlinTargetConfigurator.Companion.runTaskNameSuffix
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation.Companion.MAIN_COMPILATION_NAME
@@ -22,6 +23,7 @@ import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
 import org.jetbrains.kotlin.gradle.targets.js.binaryen.BinaryenExec
 import org.jetbrains.kotlin.gradle.targets.js.dsl.*
 import org.jetbrains.kotlin.gradle.targets.js.internal.RewriteSourceMapFilterReader
+import org.jetbrains.kotlin.gradle.targets.js.npm.NpmProject
 import org.jetbrains.kotlin.gradle.targets.js.npm.npmProject
 import org.jetbrains.kotlin.gradle.targets.js.typescript.TypeScriptValidationTask
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
@@ -120,13 +122,15 @@ constructor(
                     val tsValidationTask = registerTypeScriptCheckTask(binary)
 
                     binary.linkTask.configure {
-                        it.kotlinOptions.outputFile = project.buildDir
+                        it.destinationDirectory.set(
-                            .resolve(COMPILE_SYNC)
+                            project.buildDir
-                            .resolve(if (compilation.platformType == KotlinPlatformType.wasm) "wasm" else "js")
+                                .resolve(COMPILE_SYNC)
-                            .resolve(compilation.name)
+                                .resolve(if (compilation.platformType == KotlinPlatformType.wasm) "wasm" else "js")
-                            .resolve(binary.name)
+                                .resolve(compilation.name)
-                            .resolve(npmProject.main)
+                                .resolve(binary.name)
-                            .canonicalPath
+                                .resolve(NpmProject.DIST_FOLDER)
+                        )
+                        (it.kotlinOptions as KotlinJsOptionsImpl).outputName = npmProject.name
 
                         it.finalizedBy(syncTask)
 
@@ -145,7 +149,11 @@ constructor(
         return project.registerTask<Copy>(
             binary.linkSyncTaskName
         ) { task ->
-            task.from(binary.linkTask.flatMap { it.normalizedDestinationDirectory })
+            task.from(
+                binary.linkTask.flatMap { linkTask ->
+                    linkTask.destinationDirectory.map { it.asFile }
+                }
+            )
 
             task.from(project.tasks.named(compilation.processResourcesTaskName))
 
@@ -173,7 +181,7 @@ constructor(
             null
         } else {
             project.registerTask(binary.validateGeneratedTsTaskName, listOf(compilation)) {
-                it.inputDir.set(linkTask.flatMap { it.normalizedDestinationDirectory })
+                it.inputDir.set(linkTask.destinationDirectory.map { it.asFile })
                 it.validationStrategy.set(
                     when (binary.mode) {
                         KotlinJsBinaryMode.DEVELOPMENT -> propertiesProvider.jsIrGeneratedTypeScriptValidationDevStrategy
@@ -184,12 +192,6 @@ constructor(
         }
     }
 
-//    private val TaskProvider<KotlinJsIrLink>.normalizedDestinationDirectory
-//        get() =
-//            flatMap { linkTask ->
-//                linkTask.normalizedDestinationDirectory.map { it.asFile }
-//            }
-
     //Binaryen
     private val applyBinaryenHandlers = mutableListOf<(BinaryenExec.() -> Unit) -> Unit>()
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -980,18 +980,12 @@ abstract class Kotlin2JsCompile @Inject constructor(
     @get:Internal
     internal abstract val defaultDestinationDirectory: DirectoryProperty
 
-    // This can be file or directory
+    @Deprecated("Use destinationDirectory and moduleName instead")
     @get:Internal
     abstract val outputFileProperty: Property<File>
 
-    @Deprecated("Please use outputFileProperty, this is kept for backwards compatibility.", replaceWith = ReplaceWith("outputFileProperty"))
+    @get:Input
-    @get:Internal
+    abstract val outputName: Property<String>
-    val outputFile: File
-        get() = outputFileProperty.get()
-
-    @get:OutputFile
-    @get:Optional
-    abstract val optionalOutputFile: RegularFileProperty
 
     // Workaround to add additional compiler args based on the exising one
     // Currently there is a logic to add additional compiler arguments based on already existing one.
@@ -1018,15 +1012,18 @@ abstract class Kotlin2JsCompile @Inject constructor(
         (compilerOptions as CompilerJsOptionsDefault).fillDefaultValues(args)
         super.setupCompilerArgs(args, defaultsOnly = defaultsOnly, ignoreClasspathResolutionErrors = ignoreClasspathResolutionErrors)
 
-        try {
+        if (kotlinOptions.isIrBackendEnabled()) {
-            outputFileProperty.get().canonicalPath
+            if (kotlinOptions.outputFile != null) {
-        } catch (ex: Throwable) {
+                args.outputDir = (kotlinOptions as KotlinJsOptionsImpl).destDir
-            logger.warn("IO EXCEPTION: outputFile: ${outputFileProperty.get().path}")
+                kotlinOptions.outputFile?.let { args.outputName = File(it).nameWithoutExtension }
-            throw ex
+            } else {
+                args.outputDir = destinationDirectory.get().asFile.normalize().absolutePath
+                args.outputName = outputName.get()
+            }
+        } else {
+            args.outputFile = outputFileProperty.get().absoluteFile.normalize().absolutePath
         }
 
-        args.outputFile = outputFileProperty.get().absoluteFile.normalize().absolutePath
-
         if (defaultsOnly) return
 
         (compilerOptions as CompilerJsOptionsDefault).fillCompilerArguments(args)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/Kotlin2JsCompileConfig.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.gradle.tasks.configuration
 
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptionsImpl
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.isMainCompilationData
@@ -73,6 +74,10 @@ internal open class BaseKotlin2JsCompileConfig<TASK : Kotlin2JsCompile>(
                 )
                 .disallowChanges()
 
+            task.outputName.value(task.project.provider {
+                (task.kotlinOptions as KotlinJsOptionsImpl).outputName ?: compilation.ownModuleName
+            }).disallowChanges()
+
             task.optionalOutputFile.fileProvider(
                 task.outputFileProperty.flatMap { outputFile ->
                     task.enhancedFreeCompilerArgs.flatMap { freeArgs ->

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KotlinJsIrLinkConfig.kt

@@ -5,6 +5,9 @@
 
 package org.jetbrains.kotlin.gradle.tasks.configuration
 
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrLink
+import java.io.File
 import org.gradle.api.InvalidUserDataException
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData