Link task producing jar with sources to dukat tasks.

This required by Gradle 7 task validation.
Though in some cases sourcesJar task should not depend in some cases on Dukat tasks.

^KT-44949 In Progress

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

@@ -22,11 +22,22 @@ import org.gradle.api.internal.component.SoftwareComponentInternal
 import org.gradle.api.internal.component.UsageContext
 import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.jvm.tasks.Jar
 import org.gradle.util.ConfigureUtil
 import org.gradle.util.WrapUtil
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsSubTargetContainerDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsSubTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dukat.DukatCompilationResolverPlugin
+import org.jetbrains.kotlin.gradle.targets.js.dukat.DukatCompilationResolverPlugin.Companion.shouldDependOnDukatIntegrationTask
+import org.jetbrains.kotlin.gradle.targets.js.dukat.DukatCompilationResolverPlugin.Companion.shouldLegacyUseIrTargetDukatIntegrationTask
+import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
+import org.jetbrains.kotlin.gradle.targets.js.npm.npmProject
+import org.jetbrains.kotlin.gradle.tasks.dependsOn
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 
@@ -183,8 +194,13 @@ abstract class AbstractKotlinTarget(
         classifierPrefix: String? = null
     ): PublishArtifact {
         val sourcesJarTask = sourcesJarTask(producingCompilation, componentName, artifactNameAppendix)
+        linkToSourcesProducedByDukatTasks(
+            producingCompilation,
+            sourcesJarTask
+        )
         val sourceArtifactConfigurationName = producingCompilation.disambiguateName("sourceArtifacts")
-        return producingCompilation.target.project.run {
+
+        return with(producingCompilation.target.project) {
             (configurations.findByName(sourceArtifactConfigurationName) ?: run {
                 val configuration = configurations.create(sourceArtifactConfigurationName) {
                     it.isCanBeResolved = false
@@ -199,6 +215,45 @@ abstract class AbstractKotlinTarget(
         }
     }
 
+    private fun linkToSourcesProducedByDukatTasks(
+        producingCompilation: KotlinCompilation<*>,
+        sourcesJarTask: TaskProvider<Jar>
+    ) {
+        if (producingCompilation is KotlinJsCompilation) {
+            val configAction: (KotlinJsSubTargetDsl) -> Unit = {
+                val dukatGenerateExternalsTaskName = producingCompilation.npmProject.compilation
+                    .disambiguateName(
+                        DukatCompilationResolverPlugin.GENERATE_EXTERNALS_INTEGRATED_TASK_SIMPLE_NAME
+                    )
+                producingCompilation.target.project.afterEvaluate {
+                    sourcesJarTask.dependsOn(
+                        producingCompilation.target.project.tasks.named(dukatGenerateExternalsTaskName)
+                    )
+                }
+            }
+
+            // See DukatCompilationResolverPlugin for details
+            if (producingCompilation.shouldDependOnDukatIntegrationTask()) {
+                (producingCompilation.target as KotlinJsSubTargetContainerDsl)
+                    .whenNodejsConfigured(configAction)
+                (producingCompilation.target as KotlinJsSubTargetContainerDsl)
+                    .whenBrowserConfigured(configAction)
+            } else if (producingCompilation.shouldLegacyUseIrTargetDukatIntegrationTask()) {
+                (producingCompilation.target as KotlinJsIrTarget)
+                    .legacyTarget
+                    ?.compilations
+                    ?.named(producingCompilation.name) {
+                        if (it.externalsOutputFormat == ExternalsOutputFormat.SOURCE) {
+                            (producingCompilation.target as KotlinJsSubTargetContainerDsl)
+                                .whenNodejsConfigured(configAction)
+                            (producingCompilation.target as KotlinJsSubTargetContainerDsl)
+                                .whenBrowserConfigured(configAction)
+                        }
+                    }
+            }
+        }
+    }
+
     @Suppress("UNCHECKED_CAST")
     internal val publicationConfigureActions =
         WrapUtil.toDomainObjectSet(Action::class.java) as DomainObjectSet<Action<MavenPublication>>

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

@@ -5,8 +5,9 @@
 
 package org.jetbrains.kotlin.gradle.targets.js.dukat
 
-import org.gradle.api.artifacts.FileCollectionDependency
 import org.gradle.api.internal.project.ProjectInternal
+import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.disambiguateName
 import org.jetbrains.kotlin.gradle.targets.js.KotlinJsTarget
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
@@ -36,36 +37,37 @@ internal class DukatCompilationResolverPlugin(
     val externalsOutputFormat by lazy {
         compilation.externalsOutputFormat
     }
-    val integratedTaskName = npmProject.compilation.disambiguateName("generateExternalsIntegrated")
+    val integratedTaskName = npmProject.compilation.disambiguateName(GENERATE_EXTERNALS_INTEGRATED_TASK_SIMPLE_NAME)
-    val separateTaskName = npmProject.compilation.disambiguateName("generateExternals")
+    val separateTaskName = npmProject.compilation.disambiguateName(GENERATE_EXTERNALS_TASK_SIMPLE_NAME)
+
+    private fun registerIntegratedTask(): TaskProvider<IntegratedDukatTask> {
+        return project.registerTask(
+            integratedTaskName,
+            listOf(compilation)
+        ) {
+            it.group = DUKAT_TASK_GROUP
+            it.description = "Integrated generation Kotlin/JS external declarations for .d.ts files in $compilation"
+            it.externalsOutputFormat = externalsOutputFormat
+            it.dependsOn(nodeJs.npmInstallTaskProvider, npmProject.packageJsonTask)
+        }
+    }
 
     init {
         val externalsOutputFormat = compilation.externalsOutputFormat
 
         gradleModelPostProcess(externalsOutputFormat, npmProject)
 
-        val integratedTask = project.registerTask<IntegratedDukatTask>(
+        var integratedTask: TaskProvider<IntegratedDukatTask>? = null
-            integratedTaskName,
+        if (compilation.shouldDependOnDukatIntegrationTask()) {
-            listOf(compilation)
+            val task = integratedTask ?: registerIntegratedTask().also { integratedTask = it }
-        ) {
+            compilation.compileKotlinTaskProvider.dependsOn(task)
-            it.group = DUKAT_TASK_GROUP
-            it.description = "Integrated generation Kotlin/JS external declarations for .d.ts files in ${compilation}"
-            it.externalsOutputFormat = externalsOutputFormat
-            it.dependsOn(nodeJs.npmInstallTaskProvider, npmProject.packageJsonTask)
         }
 
-        val target = compilation.target
+        if (compilation.shouldLegacyUseIrTargetDukatIntegrationTask()) {
-
+            (compilation.target as KotlinJsIrTarget).legacyTarget?.compilations?.named(compilation.name) {
-        val legacyTargetNotReuseIrTask =
+                val task = integratedTask ?: registerIntegratedTask()
-            target is KotlinJsTarget && (target.irTarget == null || externalsOutputFormat != ExternalsOutputFormat.SOURCE)
-        if (target is KotlinJsIrTarget || legacyTargetNotReuseIrTask) {
-            compilation.compileKotlinTaskProvider.dependsOn(integratedTask)
-        }
-
-        if (target is KotlinJsIrTarget && target.legacyTarget != null) {
-            target.legacyTarget?.compilations?.named(compilation.name) {
                 if (it.externalsOutputFormat == ExternalsOutputFormat.SOURCE) {
-                    it.compileKotlinTaskProvider.dependsOn(integratedTask)
+                    it.compileKotlinTaskProvider.dependsOn(task)
                 }
             }
         }
@@ -117,6 +119,20 @@ internal class DukatCompilationResolverPlugin(
 
     companion object {
         const val VERSION = "3"
+        internal const val GENERATE_EXTERNALS_INTEGRATED_TASK_SIMPLE_NAME = "generateExternalsIntegrated"
+        internal const val GENERATE_EXTERNALS_TASK_SIMPLE_NAME = "generateExternals"
+
+        internal fun KotlinJsCompilation.shouldDependOnDukatIntegrationTask(): Boolean = with(target) {
+            this is KotlinJsIrTarget ||
+                (this is KotlinJsTarget &&
+                    (irTarget == null || externalsOutputFormat != ExternalsOutputFormat.SOURCE)
+                    )
+        }
+
+        internal fun KotlinJsCompilation.shouldLegacyUseIrTargetDukatIntegrationTask(): Boolean =
+            with(target) {
+                this is KotlinJsIrTarget && legacyTarget != null
+            }
     }
 }