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

^KT-63435 fixed
2023-12-20 12:36:28 +00:00
parent d3322d515f
commit 81efc8d7c7
23 changed files with 174 additions and 236 deletions
@@ -56,8 +56,7 @@ val nodeModules by configurations.registering {
 }

 val compileTestDevelopmentExecutableKotlinJs = tasks.named<KotlinJsIrLink>("compileTestDevelopmentExecutableKotlinJs") {
-    @Suppress("DEPRECATION")
-    kotlinOptions.outputFile = buildDir.resolve("compileSync/js/test/testDevelopmentExecutable/kotlin/kotlin-kotlin-test-js-ir-it-test.js").normalize().absolutePath
+    compilerOptions.moduleName = "kotlin-kotlin-test-js-ir-it-test"
 }

 val populateNodeModules = tasks.register<Copy>("populateNodeModules") {
@@ -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()
 }
@@ -37,7 +37,7 @@ class ExecutionStrategyJsIT : ExecutionStrategyIT() {
                    |
                    |afterEvaluate {
                    |    tasks.named('compileKotlinJs') {
-                    |        kotlinOptions.outputFile = "${'$'}{project.projectDir}/web/js/"
+                    |        destinationDirectory = new File(project.projectDir, "web/js/")
                    |    }
                    |}
                    |
@@ -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"
                |   }
                |}
                |
@@ -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 */
@@ -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 ->
@@ -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

@@ -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>
-        get() = target.project.tasks
-            .withType(KotlinJsIrLink::class.java)
-            .named(linkTaskName)
+    val linkTask: TaskProvider<KotlinJsIrLink> = project.registerTask(linkTaskName, KotlinJsIrLink::class.java, listOf(project))
+
+    private val _linkSyncTask: TaskProvider<DefaultIncrementalSyncTask>? =
+        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
-        get() = compilation.target
+    val target: KotlinJsIrTarget
+        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"
@@ -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 }
@@ -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(
-                binary.linkSyncTask.flatMap { linkSyncTask ->
-                    binary.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
+            inputFileProperty.set(
+                binary.mainFileSyncPath
            )
        }
        target.runTask.dependsOn(runTaskHolder)
@@ -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>,
-) : DomainObjectSet<JsBinary> by backingContainer {
+    backingContainer: DomainObjectSet<JsIrBinary>,
+) : 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) {
@@ -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.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
+                binary.mainFileSyncPath
            } 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 ->
-                        linkTask.outputFileProperty
-                    }
+                    binary.mainFile
                }
            }

-            testJs.inputFileProperty.fileProvider(
+            testJs.inputFileProperty.set(
                inputFileProperty
            )

@@ -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()) } }
                    )
@@ -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 ->
-                    linkTask.outputFileProperty
-                }
+                binary.mainFile
            } else {
                dependsOn(binary.linkSyncTask)
-                binary.linkSyncTask.flatMap { linkSyncTask ->
-                    binary.linkTask.flatMap { linkTask ->
-                        linkTask.outputFileProperty.map { file ->
-                            linkSyncTask.destinationDirectory.get().resolve(file.name)
-                        }
-                    }
-                }
+                binary.mainFileSyncPath
            }
-            inputFileProperty.fileProvider(
+            inputFileProperty.set(
                inputFile
            )
        }
@@ -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 {
-        if (
-            compilation.platformType == KotlinPlatformType.wasm ||
-            compilation.kotlinOptions.moduleKind == JsModuleKind.MODULE_ES.kind
-        ) ".mjs" else ".js"
-    }
+    private val extension: Provider<String> = compilation.fileExtension

    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
-        get() = "${DIST_FOLDER}/$name$extension"
+    val main: Provider<String> = extension.map { "${DIST_FOLDER}/$name.$it" }

    val publicPackageJsonTaskName: String
        get() = compilation.disambiguateName(PublicPackageJsonTask.NAME)
@@ -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"
+            packageJson.main = "${npmProjectName.get()}.${extension.get()}"

            if (jsIrCompilation.get()) {
                packageJson.types = "${npmProjectName.get()}.d.ts"
@@ -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()
        )
@@ -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
        )
    }
@@ -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 {
@@ -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
-            if (outputFilePath != null) {
-                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()
-            }
+            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."
-            )
-        }
-    }
 }
@@ -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,
@@ -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(
@@ -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 })
        }
    }