[Gradle, JS] Replace outputFileProperty onto Binary's mainFile

^KT-63435 fixed

libraries/kotlin.test/js-ir/it/build.gradle.kts

@@ -56,8 +56,7 @@ val nodeModules by configurations.registering {
 }
 
 val compileTestDevelopmentExecutableKotlinJs = tasks.named<KotlinJsIrLink>("compileTestDevelopmentExecutableKotlinJs") {
-    @Suppress("DEPRECATION")
+    compilerOptions.moduleName = "kotlin-kotlin-test-js-ir-it-test"
-    kotlinOptions.outputFile = buildDir.resolve("compileSync/js/test/testDevelopmentExecutable/kotlin/kotlin-kotlin-test-js-ir-it-test.js").normalize().absolutePath
 }
 
 val populateNodeModules = tasks.register<Copy>("populateNodeModules") {

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

@@ -2,6 +2,7 @@ package org.jetbrains.kotlin.gradle.tasks
 
 import org.gradle.api.Task
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import org.gradle.work.NormalizeLineEndings
@@ -40,7 +41,7 @@ interface IncrementalSyncTask : Task {
      * @suppress
      */
     @get:Internal
-    @Deprecated("Use destinationDirProperty with Provider API", ReplaceWith("destinationDirProperty.get()"))
+    @Deprecated("Use destinationDirectory with Provider API", ReplaceWith("destinationDirectory.get()"))
     val destinationDir: File
         get() = destinationDirectory.get()
 }

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

@@ -37,7 +37,7 @@ class ExecutionStrategyJsIT : ExecutionStrategyIT() {
                     |
                     |afterEvaluate {
                     |    tasks.named('compileKotlinJs') {
-                    |        kotlinOptions.outputFile = "${'$'}{project.projectDir}/web/js/"
+                    |        destinationDirectory = new File(project.projectDir, "web/js/")
                     |    }
                     |}
                     |

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

@@ -847,7 +847,8 @@ class Kotlin2JsIrGradlePluginIT : KGPBaseTest() {
                 """
                 |project("app") {
                 |   tasks.$taskSelector {
-                |        kotlinOptions.outputFile = "${'$'}{buildDir}/kotlin2js/app.js"
+                |       destinationDirectory.set(file("${'$'}{buildDir}/kotlin2js"))
+                |       kotlinOptions.moduleName = "app"
                 |   }
                 |}
                 |

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

@@ -43,35 +43,6 @@ internal class KotlinJsIrSourceSetProcessor(
             it.dependsOn(kotlinTask)
         }
 
-        val compilation = compilationInfo.tcs.compilation as KotlinJsIrCompilation
-
-        compilation.binaries
-            .withType(JsIrBinary::class.java)
-            .all { binary ->
-                val configAction = KotlinJsIrLinkConfig(binary)
-                configAction.configureTask {
-                    it.description = taskDescription
-                    it.libraries.from(project.filesProvider { compilation.runtimeDependencyFiles })
-                }
-                configAction.configureTask { task ->
-                    val targetCompilerOptions = (compilation.target as KotlinJsIrTarget).compilerOptions
-                    KotlinJsCompilerOptionsHelper.syncOptionsAsConvention(
-                        targetCompilerOptions,
-                        task.compilerOptions
-                    )
-
-                    // Restoring already configured module name
-                    task.compilerOptions.moduleName.convention(
-                        project.provider { compilation.npmProject.name }
-                    )
-
-                    task.modeProperty.set(binary.mode)
-                    task.dependsOn(kotlinTask)
-                }
-
-                tasksProvider.registerKotlinJsIrTask(project, binary.linkTaskName, configAction)
-            }
-
         project.whenEvaluated {
             val subpluginEnvironment: SubpluginEnvironment = SubpluginEnvironment.loadSubplugins(project)
             /* Not supported in KPM, yet */

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

@@ -11,8 +11,8 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 import groovy.lang.Closure
 import org.gradle.api.Action
 import org.gradle.api.attributes.AttributeContainer
-import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.dsl.JsModuleKind
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptions
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
 import javax.inject.Inject
 
 open class KotlinJsCompilation @Inject internal constructor(
-    compilation: KotlinCompilationImpl
+    compilation: KotlinCompilationImpl,
 ) : AbstractKotlinCompilationToRunnableFiles<KotlinJsOptions>(compilation),
     HasBinaries<KotlinJsBinaryContainer> {
 
@@ -104,7 +104,7 @@ open class KotlinJsCompilation @Inject internal constructor(
     }
 }
 
-internal val KotlinJsCompilation.fileExtension: Provider<String>
+val KotlinJsCompilation.fileExtension: Provider<String>
     get() {
         val isWasm = platformType == KotlinPlatformType.wasm
         return compilerOptions.options.moduleKind.map { moduleKind ->

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

@@ -10,6 +10,7 @@ import org.gradle.work.DisableCachingByDefault
 import org.gradle.work.InputChanges
 import org.jetbrains.kotlin.gradle.targets.js.internal.RewriteSourceMapFilterReader
 import org.jetbrains.kotlin.gradle.tasks.IncrementalSyncTask
+import org.jetbrains.kotlin.gradle.utils.getFile
 import java.io.File
 import javax.inject.Inject
 

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

@@ -6,19 +6,27 @@
 package org.jetbrains.kotlin.gradle.targets.js.ir
 
 import org.gradle.api.Project
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptionsHelper
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
+import org.jetbrains.kotlin.gradle.plugin.mpp.fileExtension
+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.KotlinJsBinaryMode
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsBinaryContainer.Companion.generateBinaryName
+import org.jetbrains.kotlin.gradle.targets.js.npm.npmProject
 import org.jetbrains.kotlin.gradle.targets.js.subtargets.createDefaultDistribution
 import org.jetbrains.kotlin.gradle.targets.js.typescript.TypeScriptValidationTask
-import org.jetbrains.kotlin.gradle.tasks.IncrementalSyncTask
+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
 
 interface JsBinary {
     val compilation: KotlinJsCompilation
@@ -30,19 +38,69 @@ interface JsBinary {
 sealed class JsIrBinary(
     final override val compilation: KotlinJsIrCompilation,
     final override val name: String,
-    override val mode: KotlinJsBinaryMode
+    override val mode: KotlinJsBinaryMode,
 ) : JsBinary {
     override val distribution: Distribution =
         createDefaultDistribution(compilation.target.project, compilation.target.targetName, name)
 
     val linkTaskName: String = linkTaskName()
 
+    val linkSyncTaskName: String = linkSyncTaskName()
+
+    val validateGeneratedTsTaskName: String = validateTypeScriptTaskName()
+
     var generateTs: Boolean = false
 
-    val linkTask: TaskProvider<KotlinJsIrLink>
+    val linkTask: TaskProvider<KotlinJsIrLink> = project.registerTask(linkTaskName, KotlinJsIrLink::class.java, listOf(project))
-        get() = target.project.tasks
+
-            .withType(KotlinJsIrLink::class.java)
+    private val _linkSyncTask: TaskProvider<DefaultIncrementalSyncTask>? =
-            .named(linkTaskName)
+        if (target.wasmTargetType == KotlinWasmTargetType.WASI) {
+            null
+        } else {
+            project.registerTask<DefaultIncrementalSyncTask>(
+                linkSyncTaskName
+            ) { task ->
+                task.from.from(
+                    linkTask.flatMap { linkTask ->
+                        linkTask.destinationDirectory
+                    }
+                )
+
+                task.from.from(project.tasks.named(compilation.processResourcesTaskName))
+
+                task.destinationDirectory.set(compilation.npmProject.dist.mapToFile())
+            }
+        }
+
+    // Wasi target doesn't have sync task
+    // need to extract wasm related binaries
+    val linkSyncTask: TaskProvider<DefaultIncrementalSyncTask>
+        get() = if (target.wasmTargetType == KotlinWasmTargetType.WASI) {
+            throw IllegalStateException("Wasi target has no sync task")
+        } else {
+            _linkSyncTask!!
+        }
+
+    val mainFileName: Provider<String> = linkTask.flatMap {
+        it.compilerOptions.moduleName.zip(compilation.fileExtension) { moduleName, extension ->
+            "$moduleName.$extension"
+        }
+    }
+
+    val mainFile: Provider<RegularFile> = linkTask.flatMap {
+        it.destinationDirectory.file(mainFileName.get())
+    }
+
+    val mainFileSyncPath: Provider<RegularFile> =
+        if (target.wasmTargetType == KotlinWasmTargetType.WASI) {
+            project.objects.fileProperty()
+        } else {
+            project.objects.fileProperty().fileProvider(
+                linkSyncTask.map {
+                    it.destinationDirectory.get().resolve(mainFileName.get())
+                }
+            )
+        }
 
     private fun linkTaskName(): String =
         lowerCamelCaseName(
@@ -52,15 +110,6 @@ sealed class JsIrBinary(
             target.targetName
         )
 
-    val linkSyncTaskName: String = linkSyncTaskName()
-
-    val validateGeneratedTsTaskName: String = validateTypeScriptTaskName()
-
-    val linkSyncTask: TaskProvider<IncrementalSyncTask>
-        get() = target.project.tasks
-            .withType<IncrementalSyncTask>()
-            .named(linkSyncTaskName)
-
     private fun linkSyncTaskName(): String =
         lowerCamelCaseName(
             compilation.target.disambiguationClassifier,
@@ -77,17 +126,38 @@ sealed class JsIrBinary(
             TypeScriptValidationTask.NAME
         )
 
-    val target: KotlinTarget
+    val target: KotlinJsIrTarget
-        get() = compilation.target
+        get() = compilation.target as KotlinJsIrTarget
 
     val project: Project
         get() = target.project
+
+    companion object {
+        internal fun JsIrBinary.configLinkTask() {
+            val configAction = KotlinJsIrLinkConfig(this)
+            configAction.configureTask {
+                it.libraries.from(project.filesProvider { compilation.runtimeDependencyFiles })
+            }
+            configAction.configureTask { task ->
+                val targetCompilerOptions = (compilation.target as KotlinJsIrTarget).compilerOptions
+                KotlinJsCompilerOptionsHelper.syncOptionsAsConvention(
+                    targetCompilerOptions,
+                    task.compilerOptions
+                )
+
+                task.modeProperty.set(mode)
+                task.dependsOn(compilation.compileTaskProvider)
+            }
+
+            configAction.execute(linkTask)
+        }
+    }
 }
 
 open class Executable(
     compilation: KotlinJsIrCompilation,
     name: String,
-    mode: KotlinJsBinaryMode
+    mode: KotlinJsBinaryMode,
 ) : JsIrBinary(
     compilation,
     name,
@@ -111,7 +181,7 @@ open class Executable(
 open class ExecutableWasm(
     compilation: KotlinJsIrCompilation,
     name: String,
-    mode: KotlinJsBinaryMode
+    mode: KotlinJsBinaryMode,
 ) : Executable(
     compilation,
     name,
@@ -131,26 +201,11 @@ open class ExecutableWasm(
 class Library(
     compilation: KotlinJsIrCompilation,
     name: String,
-    mode: KotlinJsBinaryMode
+    mode: KotlinJsBinaryMode,
 ) : JsIrBinary(
     compilation,
     name,
     mode
-) {
+)
-    val executeTaskBaseName: String =
-        generateBinaryName(
-            compilation,
-            mode,
-            null
-        )
-}
-
-// Hack for legacy
-internal val JsBinary.executeTaskBaseName: String
-    get() = generateBinaryName(
-        compilation,
-        mode,
-        null
-    )
 
 internal const val COMPILE_SYNC = "compileSync"

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

@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.gradle.targets.js.ir
 import org.gradle.api.Action
 import org.gradle.api.DomainObjectSet
 import org.gradle.api.Task
+import org.gradle.api.file.Directory
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.Copy
@@ -15,7 +17,6 @@ import org.gradle.language.base.plugins.LifecycleBasePlugin
 import org.jetbrains.kotlin.gradle.dsl.JsModuleKind
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDce
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
-import org.jetbrains.kotlin.gradle.utils.archivesName
 import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalDceDsl
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBinaryMode
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBrowserDsl
@@ -29,8 +30,9 @@ import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig
 import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig.Mode
 import org.jetbrains.kotlin.gradle.targets.js.webpack.WebpackDevtool
 import org.jetbrains.kotlin.gradle.tasks.dependsOn
+import org.jetbrains.kotlin.gradle.utils.*
+import org.jetbrains.kotlin.gradle.utils.archivesName
 import org.jetbrains.kotlin.gradle.utils.doNotTrackStateCompat
-import org.jetbrains.kotlin.gradle.utils.newFileProperty
 import org.jetbrains.kotlin.gradle.utils.relativeOrAbsolute
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import java.io.File
@@ -156,7 +158,9 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
                     task.commonConfigure(
                         binary = binary,
                         mode = mode,
-                        inputFilesDirectory = task.project.provider { binary.linkSyncTask.get().destinationDirectory.get() },
+                        inputFilesDirectory = task.project.objects.directoryProperty().fileProvider(
+                            task.project.provider { binary.linkSyncTask.get().destinationDirectory.get() },
+                        ),
                         entryModuleName = binary.linkTask.flatMap { it.compilerOptions.moduleName },
                         configurationActions = runTaskConfigurations,
                         nodeJs = nodeJs,
@@ -209,7 +213,9 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
                     task.commonConfigure(
                         binary = binary,
                         mode = mode,
-                        inputFilesDirectory = task.project.provider { binary.linkSyncTask.get().destinationDirectory.get() },
+                        inputFilesDirectory = task.project.objects.directoryProperty().fileProvider(
+                            task.project.provider { binary.linkSyncTask.get().destinationDirectory.get() },
+                        ),
                         entryModuleName = binary.linkTask.flatMap { it.compilerOptions.moduleName },
                         configurationActions = webpackTaskConfigurations,
                         nodeJs = nodeJs,
@@ -257,7 +263,7 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
     private fun KotlinWebpack.commonConfigure(
         binary: JsIrBinary,
         mode: KotlinJsBinaryMode,
-        inputFilesDirectory: Provider<File>,
+        inputFilesDirectory: Provider<Directory>,
         entryModuleName: Provider<String>,
         configurationActions: DomainObjectSet<Action<KotlinWebpack>>,
         nodeJs: NodeJsRootExtension,
@@ -271,7 +277,7 @@ abstract class KotlinBrowserJsIr @Inject constructor(target: KotlinJsIrTarget) :
 
         configureOptimization(mode)
 
-        this.inputFilesDirectory.fileProvider(inputFilesDirectory)
+        this.inputFilesDirectory.set(inputFilesDirectory)
 
         val platformType = binary.compilation.platformType
         val moduleKind = binary.linkTask.flatMap { it.compilerOptions.moduleKind }

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

@@ -34,14 +34,8 @@ abstract class KotlinD8Ir @Inject constructor(target: KotlinJsIrTarget) :
         val runTaskHolder = D8Exec.create(binary.compilation, name) {
             group = taskGroupName
             dependsOn(binary.linkSyncTask)
-            inputFileProperty.fileProvider(
+            inputFileProperty.set(
-                binary.linkSyncTask.flatMap { linkSyncTask ->
+                binary.mainFileSyncPath
-                    binary.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
             )
         }
         target.runTask.dependsOn(runTaskHolder)

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
 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.targets.js.ir.JsIrBinary.Companion.configLinkTask
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import javax.inject.Inject
@@ -25,8 +26,8 @@ open class KotlinJsBinaryContainer
 @Inject
 constructor(
     val target: KotlinTargetWithBinaries<KotlinJsIrCompilation, KotlinJsBinaryContainer>,
-    backingContainer: DomainObjectSet<JsBinary>,
+    backingContainer: DomainObjectSet<JsIrBinary>,
-) : DomainObjectSet<JsBinary> by backingContainer {
+) : DomainObjectSet<JsIrBinary> by backingContainer {
     val project: Project
         get() = target.project
 
@@ -37,14 +38,14 @@ constructor(
 
     fun executable(
         compilation: KotlinJsIrCompilation,
-    ): List<JsBinary> {
+    ): List<JsIrBinary> {
         return executable(compilation as KotlinJsCompilation)
     }
 
     @JvmOverloads
     fun executable(
         compilation: KotlinJsCompilation = defaultCompilation,
-    ): List<JsBinary> {
+    ): List<JsIrBinary> {
         if (target is KotlinJsIrTarget) {
             target.whenBrowserConfigured {
                 (this as KotlinJsIrSubTarget).produceExecutable()
@@ -64,7 +65,7 @@ constructor(
         throw GradleException("Target should be KotlinJsIrTarget, but found $target")
     }
 
-    internal fun executableIrInternal(compilation: KotlinJsIrCompilation): List<JsBinary> = createBinaries(
+    internal fun executableIrInternal(compilation: KotlinJsIrCompilation): List<JsIrBinary> = createBinaries(
         compilation = compilation,
         jsBinaryType = KotlinJsBinaryType.EXECUTABLE,
         create = { compilation, name, mode ->
@@ -80,7 +81,7 @@ constructor(
     @JvmOverloads
     fun library(
         compilation: KotlinJsIrCompilation = defaultCompilation,
-    ): List<JsBinary> {
+    ): List<JsIrBinary> {
         if (target is KotlinJsIrTarget) {
             target.whenBrowserConfigured {
                 (this as KotlinJsIrSubTarget).produceLibrary()
@@ -115,7 +116,7 @@ constructor(
         withType(JsIrBinary::class.java)
             .matching { it.mode == mode }
 
-    private fun <T : JsBinary> createBinaries(
+    private fun <T : JsIrBinary> createBinaries(
         compilation: KotlinJsIrCompilation,
         modes: Collection<KotlinJsBinaryMode> = listOf(PRODUCTION, DEVELOPMENT),
         jsBinaryType: KotlinJsBinaryType,
@@ -130,12 +131,12 @@ constructor(
             )
         }
 
-    private fun <T : JsBinary> createBinary(
+    private fun <T : JsIrBinary> createBinary(
         compilation: KotlinJsIrCompilation,
         mode: KotlinJsBinaryMode,
         jsBinaryType: KotlinJsBinaryType,
         create: (compilation: KotlinJsIrCompilation, name: String, mode: KotlinJsBinaryMode) -> T,
-    ): JsBinary {
+    ): JsIrBinary {
         val name = generateBinaryName(
             compilation,
             mode,
@@ -148,7 +149,10 @@ constructor(
 
         binaryNames.add(name)
 
-        val binary = create(compilation, name, mode)
+        val binary = create(compilation, name, mode).also {
+            it.configLinkTask()
+        }
+
         add(binary)
         // Allow accessing binaries as properties of the container in Groovy DSL.
         if (this is ExtensionAware) {

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

@@ -32,7 +32,6 @@ 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.newFileProperty
 
 abstract class KotlinJsIrSubTarget(
     val target: KotlinJsIrTarget,
@@ -124,28 +123,20 @@ abstract class KotlinJsIrSubTarget(
 
             val inputFileProperty = if (target.wasmTargetType != KotlinWasmTargetType.WASI) {
                 testJs.dependsOn(binary.linkSyncTask)
-                binary.linkSyncTask.flatMap { linkSyncTask ->
+                binary.mainFileSyncPath
-                    binary.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
             } else {
                 if (project.locateTask<BinaryenExec>((binary as ExecutableWasm).optimizeTaskName) != null) {
                     testJs.dependsOn(binary.optimizeTask)
                     binary.optimizeTask.flatMap { optimizeTask ->
-                        optimizeTask.outputFileProperty.asFile
+                        optimizeTask.outputFileProperty
                     }
                 } else {
                     testJs.dependsOn(binary.linkTask)
-                    binary.linkTask.flatMap { linkTask ->
+                    binary.mainFile
-                        linkTask.outputFileProperty
-                    }
                 }
             }
 
-            testJs.inputFileProperty.fileProvider(
+            testJs.inputFileProperty.set(
                 inputFileProperty
             )
 

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

@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.gradle.targets.js.dsl.*
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTargetConfigurator.Companion.configureJsDefaultOptions
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin
 import org.jetbrains.kotlin.gradle.targets.js.npm.NpmResolverPlugin
-import org.jetbrains.kotlin.gradle.targets.js.npm.npmProject
 import org.jetbrains.kotlin.gradle.targets.js.typescript.TypeScriptValidationTask
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.utils.*
@@ -151,7 +150,7 @@ constructor(
             compilation.binaries
                 .withType(JsIrBinary::class.java)
                 .all { binary ->
-                    val syncTask = registerCompileSync(binary)
+                    val syncTask = binary.linkSyncTask
                     binaryenReplaceInput[binary]?.invoke()
                     val tsValidationTask = registerTypeScriptCheckTask(binary)
 
@@ -169,25 +168,6 @@ constructor(
 
     private val commonLazy by commonLazyDelegate
 
-    private fun registerCompileSync(binary: JsIrBinary): TaskProvider<DefaultIncrementalSyncTask> {
-        val compilation = binary.compilation
-        val npmProject = compilation.npmProject
-
-        return project.registerTask<DefaultIncrementalSyncTask>(
-            binary.linkSyncTaskName
-        ) { task ->
-            task.from.from(
-                binary.linkTask.flatMap { linkTask ->
-                    linkTask.destinationDirectory.map { it.asFile }
-                }
-            )
-
-            task.from.from(project.tasks.named(compilation.processResourcesTaskName))
-
-            task.destinationDirectory.set(npmProject.dist.mapToFile())
-        }
-    }
-
     private fun registerTypeScriptCheckTask(binary: JsIrBinary): TaskProvider<TypeScriptValidationTask> {
         val linkTask = binary.linkTask
         val compilation = binary.compilation
@@ -280,7 +260,7 @@ constructor(
 
             whenNodejsConfigured {
                 testTask {
-                    val name = binary.linkTask.flatMap { it.outputFileProperty.map { it.name } }
+                    val name = binary.mainFileName
                     it.inputFileProperty.fileProvider(
                         binaryenExec.flatMap { it.outputFileProperty.map { it.asFile.parentFile.resolve(name.get()) } }
                     )

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

@@ -45,20 +45,12 @@ abstract class KotlinNodeJsIr @Inject constructor(target: KotlinJsIrTarget) :
             val inputFile = if ((compilation.target as KotlinJsIrTarget).wasmTargetType == KotlinWasmTargetType.WASI) {
                 dependsOn(binary.linkTask)
                 sourceMapStackTraces = false
-                binary.linkTask.flatMap { linkTask ->
+                binary.mainFile
-                    linkTask.outputFileProperty
-                }
             } else {
                 dependsOn(binary.linkSyncTask)
-                binary.linkSyncTask.flatMap { linkSyncTask ->
+                binary.mainFileSyncPath
-                    binary.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
             }
-            inputFileProperty.fileProvider(
+            inputFileProperty.set(
                 inputFile
             )
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/NpmProject.kt

@@ -10,11 +10,10 @@ import org.gradle.api.file.Directory
 import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.Provider
 import org.gradle.process.ExecSpec
-import org.jetbrains.kotlin.gradle.dsl.JsModuleKind
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.disambiguateName
+import org.jetbrains.kotlin.gradle.plugin.mpp.fileExtension
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin.Companion.kotlinNodeJsExtension
@@ -40,12 +39,7 @@ val KotlinJsCompilation.npmProject: NpmProject
 open class NpmProject(@Transient val compilation: KotlinJsIrCompilation) : Serializable {
     val compilationName = compilation.disambiguatedName
 
-    private val extension by lazy {
+    private val extension: Provider<String> = compilation.fileExtension
-        if (
-            compilation.platformType == KotlinPlatformType.wasm ||
-            compilation.kotlinOptions.moduleKind == JsModuleKind.MODULE_ES.kind
-        ) ".mjs" else ".js"
-    }
 
     val name: String by lazy {
         buildNpmProjectName()
@@ -83,8 +77,7 @@ open class NpmProject(@Transient val compilation: KotlinJsIrCompilation) : Seria
     val dist: Provider<Directory>
         get() = dir.map { it.dir(DIST_FOLDER) }
 
-    val main: String
+    val main: Provider<String> = extension.map { "${DIST_FOLDER}/$name.$it" }
-        get() = "${DIST_FOLDER}/$name$extension"
 
     val publicPackageJsonTaskName: String
         get() = compilation.disambiguateName(PublicPackageJsonTask.NAME)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/PublicPackageJsonTask.kt

@@ -38,7 +38,7 @@ abstract class PublicPackageJsonTask :
     abstract val jsIrCompilation: Property<Boolean>
 
     @get:Input
-    abstract val esModules: Property<Boolean>
+    abstract val extension: Property<String>
 
     @get:Input
     abstract val npmProjectName: Property<String>
@@ -91,8 +91,7 @@ abstract class PublicPackageJsonTask :
             externalDependencies,
             packageJsonHandlers.get()
         ).let { packageJson ->
-            val extension = if (esModules.get()) "mjs" else "js"
+            packageJson.main = "${npmProjectName.get()}.${extension.get()}"
-            packageJson.main = "${npmProjectName.get()}.$extension"
 
             if (jsIrCompilation.get()) {
                 packageJson.types = "${npmProjectName.get()}.d.ts"

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/resolver/KotlinCompilationNpmResolution.kt

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.gradle.targets.js.npm.resolver
 
 import org.gradle.api.Action
-import org.gradle.api.file.Directory
-import org.gradle.api.file.RegularFile
 import org.gradle.api.logging.Logger
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Provider
@@ -27,7 +25,6 @@ class KotlinCompilationNpmResolution(
     val compilationDisambiguatedName: String,
     val npmProjectName: String,
     val npmProjectVersion: String,
-    val npmProjectMain: String,
     val tasksRequirements: TasksRequirements,
 ) : Serializable {
 
@@ -127,12 +124,13 @@ class KotlinCompilationNpmResolution(
 
     fun createPackageJson(
         resolution: PreparedKotlinCompilationNpmResolution,
+        npmProjectMain: Provider<String>,
         packageJsonHandlers: ListProperty<Action<PackageJson>>,
     ) {
         val packageJson = packageJson(
             npmProjectName,
             npmProjectVersion,
-            npmProjectMain,
+            npmProjectMain.get(),
             resolution.externalNpmDependencies,
             packageJsonHandlers.get()
         )

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/resolver/KotlinCompilationNpmResolver.kt

@@ -16,10 +16,10 @@ import org.gradle.api.attributes.Usage
 import org.gradle.api.internal.artifacts.DefaultProjectComponentIdentifier
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.Zip
-import org.jetbrains.kotlin.gradle.dsl.JsModuleKind
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.categoryByName
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
+import org.jetbrains.kotlin.gradle.plugin.mpp.fileExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
 import org.jetbrains.kotlin.gradle.plugin.sources.KotlinDependencyScope
 import org.jetbrains.kotlin.gradle.plugin.sources.compilationDependencyConfigurationByScope
@@ -79,7 +79,7 @@ class KotlinCompilationNpmResolver(
             it.jsIrCompilation.set(true)
             it.npmProjectName.set(npmProject.name)
             it.npmProjectMain.set(npmProject.main)
-            it.esModules.set(compilation.compilerOptions.options.moduleKind.get() == JsModuleKind.MODULE_ES)
+            it.extension.set(compilation.fileExtension)
         }.also { packageJsonTask ->
             project.dependencies.attributesSchema {
                 it.attribute(publicPackageJsonAttribute)
@@ -313,7 +313,6 @@ class KotlinCompilationNpmResolver(
             compilationDisambiguatedName,
             npmProject.name,
             npmVersion,
-            npmProject.main,
             rootResolver.tasksRequirements
         )
     }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/tasks/KotlinPackageJsonTask.kt

@@ -62,6 +62,9 @@ abstract class KotlinPackageJsonTask :
     @get:Internal
     abstract val packageJsonHandlers: ListProperty<Action<PackageJson>>
 
+    @get:Input
+    abstract val packageJsonMain: Property<String>
+
     @get:Input
     internal val packageJsonInputHandlers: Provider<PackageJson> by lazy {
         packageJsonHandlers.map { packageJsonHandlersList ->
@@ -120,7 +123,7 @@ abstract class KotlinPackageJsonTask :
                 logger = logger
             )
 
-        resolution.createPackageJson(preparedResolution, packageJsonHandlers)
+        resolution.createPackageJson(preparedResolution, packageJsonMain, packageJsonHandlers)
     }
 
     companion object {
@@ -147,6 +150,8 @@ abstract class KotlinPackageJsonTask :
                 task.gradleNodeModules.value(gradleNodeModules)
                     .disallowChanges()
 
+                task.packageJsonMain.set(compilation.npmProject.main)
+
                 task.packageJson.set(compilation.npmProject.packageJsonFile.mapToFile())
 
                 task.onlyIf {

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.gradle.tasks
 
-import org.gradle.api.InvalidUserDataException
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.FileCollection
@@ -37,7 +36,6 @@ import org.jetbrains.kotlin.gradle.targets.js.internal.LibraryFilterCachingServi
 import org.jetbrains.kotlin.gradle.targets.js.internal.UsesLibraryFilterCachingService
 import org.jetbrains.kotlin.gradle.tasks.internal.KotlinJsOptionsCompat
 import org.jetbrains.kotlin.gradle.utils.getFile
-import org.jetbrains.kotlin.gradle.utils.isParentOf
 import org.jetbrains.kotlin.gradle.utils.newInstance
 import org.jetbrains.kotlin.gradle.utils.toPathsArray
 import org.jetbrains.kotlin.incremental.ClasspathChanges
@@ -83,9 +81,15 @@ abstract class Kotlin2JsCompile @Inject constructor(
     @get:Internal
     internal abstract val defaultDestinationDirectory: DirectoryProperty
 
-    @Deprecated("Use destinationDirectory and moduleName instead")
+    // To be sure that outputFileProperty will be correct on transition period
     @get:Internal
-    abstract val outputFileProperty: Property<File>
+    internal abstract val _outputFileProperty: Property<File>
+
+    // hidden to keep ABI compatiblity, because we have plugins which still use outputFileProperty
+    @Deprecated("Use destinationDirectory and moduleName instead", level = DeprecationLevel.HIDDEN)
+    @get:Internal
+    val outputFileProperty: Property<File>
+        get() = _outputFileProperty
 
     // 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.
@@ -105,6 +109,13 @@ abstract class Kotlin2JsCompile @Inject constructor(
     @get:Internal
     internal var executionTimeFreeCompilerArgs: List<String>? = null
 
+    @get:Deprecated(
+        message = "Task.moduleName is not used in Kotlin/JS"
+    )
+    @get:Optional
+    @get:Input
+    abstract override val moduleName: Property<String>
+
     @get:Nested
     override val multiplatformStructure: K2MultiplatformStructure = objectFactory.newInstance()
 
@@ -128,15 +139,8 @@ abstract class Kotlin2JsCompile @Inject constructor(
 
             KotlinJsCompilerOptionsHelper.fillCompilerArguments(compilerOptions, args)
 
-            val outputFilePath: String? = compilerOptions.outputFile.orNull
+            args.outputDir = destinationDirectory.get().asFile.normalize().absolutePath
-            if (outputFilePath != null) {
+            args.moduleName = compilerOptions.moduleName.get()
-                val outputFile = File(outputFilePath)
-                args.outputDir = (if (outputFile.extension == "") outputFile else outputFile.parentFile).normalize().absolutePath
-                args.moduleName = outputFile.nameWithoutExtension
-            } else {
-                args.outputDir = destinationDirectory.get().asFile.normalize().absolutePath
-                args.moduleName = compilerOptions.moduleName.get()
-            }
 
             if (compilerOptions.usesK2.get()) {
                 args.fragments = multiplatformStructure.fragmentsCompilerArgs
@@ -234,8 +238,6 @@ abstract class Kotlin2JsCompile @Inject constructor(
     ) {
         logger.debug("Calling compiler")
 
-        validateOutputDirectory()
-
         val dependencies = libraries
             .filter { it.exists() && libraryFilter(it) }
             .map { it.normalize().absolutePath }
@@ -288,18 +290,4 @@ abstract class Kotlin2JsCompile @Inject constructor(
     }
 
     private val rootProjectDir = project.rootDir
-
-    private fun validateOutputDirectory() {
-        val outputFile = outputFileProperty.get()
-        val outputDir = outputFile.parentFile
-
-        if (outputDir.isParentOf(rootProjectDir)) {
-            throw InvalidUserDataException(
-                "The output directory '$outputDir' (defined by outputFile of ':$name') contains or " +
-                        "matches the project root directory '${rootProjectDir}'.\n" +
-                        "Gradle will not be able to build the project because of the root directory lock.\n" +
-                        "To fix this, consider using the default outputFile location instead of providing it explicitly."
-            )
-        }
-    }
 }

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

@@ -118,14 +118,6 @@ internal open class KotlinTasksProvider {
         }
     }
 
-    fun registerKotlinJsIrTask(
-        project: Project, taskName: String, configuration: KotlinJsIrLinkConfig
-    ): TaskProvider<out KotlinJsIrLink> {
-        return project.registerTask(taskName, KotlinJsIrLink::class.java, listOf(project)).also {
-            configuration.execute(it)
-        }
-    }
-
     fun registerKotlinCommonTask(
         project: Project,
         taskName: String,

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

@@ -9,12 +9,6 @@ import org.jetbrains.kotlin.compilerRunner.GradleCompilerRunner
 import org.jetbrains.kotlin.gradle.incremental.IncrementalModuleInfoBuildService
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationInfo
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
-import org.jetbrains.kotlin.gradle.plugin.getExtension
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.fileExtension
-import org.jetbrains.kotlin.gradle.plugin.tcs
-import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
 import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetType
 import org.jetbrains.kotlin.gradle.targets.js.internal.LibraryFilterCachingService
 import org.jetbrains.kotlin.gradle.targets.js.ir.*
@@ -43,33 +37,6 @@ internal open class BaseKotlin2JsCompileConfig<TASK : Kotlin2JsCompile>(
 
             configureAdditionalFreeCompilerArguments(task, compilation)
 
-            val binaryCompilation = compilation.tcs.compilation
-            val compilationTarget = binaryCompilation.target
-            if (compilationTarget is KotlinJsTarget ||
-                (compilationTarget is KotlinWithJavaTarget<*, *> && compilationTarget.platformType == KotlinPlatformType.js)
-            ) {
-                // JS v1 which does not configure module name via target compiler options
-                task.compilerOptions.moduleName.convention(compilation.moduleName)
-                task.moduleName.set(providers.provider { compilation.moduleName })
-            } else {
-                task.moduleName.set(task.compilerOptions.moduleName)
-            }
-
-            @Suppress("DEPRECATION")
-            task.outputFileProperty.value(
-                task.destinationDirectory.flatMap { dir ->
-                    if (task.compilerOptions.outputFile.orNull != null) {
-                        task.compilerOptions.outputFile.map { File(it) }
-                    } else {
-                        task.compilerOptions.moduleName.flatMap { name ->
-                            (binaryCompilation as KotlinJsCompilation).fileExtension.map {
-                                dir.file("$name.$it").asFile
-                            }
-                        }
-                    }
-                }
-            )
-
             task.destinationDirectory
                 .convention(
                     project.objects.directoryProperty().fileProvider(

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

@@ -49,7 +49,9 @@ internal open class KotlinJsIrLinkConfig(
                     .map { it.dir(binary.name) }
                     .map { it.dir(NpmProject.DIST_FOLDER) }
             )
-            task.compilerOptions.moduleName.convention(project.provider { compilation.npmProject.name })
+            task.compilerOptions.moduleName.set(project.provider { compilation.npmProject.name })
+
+            task._outputFileProperty.convention(binary.mainFile.map { it.asFile })
         }
     }