[Gradle, JS] Fix npm resolution manager declaring

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

@@ -89,8 +89,6 @@ open class NodeJsRootPlugin : Plugin<Project> {
 
         project.registerTask<Task>(PACKAGE_JSON_UMBRELLA_TASK_NAME)
 
-        YarnPlugin.apply(project)
-
         nodeJs.resolver = KotlinRootNpmResolver(
             project.name,
             project.version.toString(),
@@ -102,19 +100,27 @@ open class NodeJsRootPlugin : Plugin<Project> {
 
         val objectFactory = project.objects
 
-        val npmResolutionManager = KotlinNpmResolutionManager.registerIfAbsent(
+        val npmResolutionManager = project.gradle.sharedServices.registerIfAbsent(
-            project,
+            KotlinNpmResolutionManager::class.java.name,
-            objectFactory.providerWithLazyConvention {
+            KotlinNpmResolutionManager::class.java
-                nodeJs.resolver.close()
+        ) {
-            },
+            it.parameters.resolution.set(
-            objectFactory.providerWithLazyConvention {
+                objectFactory.providerWithLazyConvention {
-                nodeJs.resolver.compilations.associate { compilation ->
+                    nodeJs.resolver.close()
-                    "${compilation.project.path}:${compilation.disambiguatedName}" to compilation.packageJsonHandlers
                 }
-            },
+            )
-            gradleNodeModulesProvider,
+            it.parameters.packageJsonHandlers.set(
-            compositeNodeModulesProvider
+                objectFactory.providerWithLazyConvention {
-        )
+                    nodeJs.resolver.compilations.associate { compilation ->
+                        "${compilation.project.path}:${compilation.disambiguatedName}" to compilation.packageJsonHandlers
+                    }
+                }
+            )
+            it.parameters.gradleNodeModulesProvider.set(gradleNodeModulesProvider)
+            it.parameters.compositeNodeModulesProvider.set(compositeNodeModulesProvider)
+        }
+
+        YarnPlugin.apply(project)
 
         npmInstall.configure {
             it.npmResolutionManager.set(npmResolutionManager)
@@ -140,27 +146,16 @@ open class NodeJsRootPlugin : Plugin<Project> {
         val Project.kotlinNodeJsExtension: NodeJsRootExtension
             get() = extensions.getByName(NodeJsRootExtension.EXTENSION_NAME).castIsolatedKotlinPluginClassLoaderAware()
 
-        private val Project.gradleNodeModules
+        val Project.kotlinNpmResolutionManager: Provider<KotlinNpmResolutionManager>
-            get() = GradleNodeModulesCache.registerIfAbsent(
+            get() {
-                this,
+                val npmResolutionManager = project.gradle.sharedServices.registerIfAbsent(
-                null,
+                    KotlinNpmResolutionManager::class.java.name,
-                null
+                    KotlinNpmResolutionManager::class.java
-            )
+                ) {
+                    error("Must be already registered")
+                }
 
-        private val Project.compositeNodeModules
+                return npmResolutionManager
-            get() = CompositeNodeModulesCache.registerIfAbsent(
+            }
-                this,
-                null,
-                null
-            )
-
-        val Project.kotlinNpmResolutionManager
-            get() = KotlinNpmResolutionManager.registerIfAbsent(
-                this,
-                null,
-                null,
-                gradleNodeModules,
-                compositeNodeModules
-            )
     }
 }

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

@@ -5,20 +5,16 @@
 
 package org.jetbrains.kotlin.gradle.targets.js.npm
 
-import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.logging.Logger
 import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
-import org.gradle.api.provider.Provider
 import org.gradle.api.services.BuildService
 import org.gradle.api.services.BuildServiceParameters
 import org.gradle.api.tasks.Internal
 import org.gradle.internal.service.ServiceRegistry
 import org.jetbrains.kotlin.gradle.targets.js.npm.resolved.Installation
 import org.jetbrains.kotlin.gradle.targets.js.npm.resolved.KotlinRootNpmResolution
-import org.jetbrains.kotlin.gradle.tasks.withType
-import org.jetbrains.kotlin.gradle.utils.SingleActionPerProject
 
 internal interface UsesKotlinNpmResolutionManager : Task {
     @get:Internal
@@ -130,58 +126,4 @@ abstract class KotlinNpmResolutionManager : BuildService<KotlinNpmResolutionMana
             is ResolutionState.Error -> throw state0.wrappedException
         }
     }
-
-    companion object {
-        private val serviceClass = KotlinNpmResolutionManager::class.java
-        private val serviceName = serviceClass.name
-
-        private fun registerIfAbsentImpl(
-            project: Project,
-            resolution: Provider<KotlinRootNpmResolution>?,
-            packageJsonHandlers: Provider<Map<String, MutableList<PackageJson.() -> Unit>>>?,
-            gradleNodeModulesProvider: Provider<GradleNodeModulesCache>,
-            compositeNodeModulesProvider: Provider<CompositeNodeModulesCache>
-        ): Provider<KotlinNpmResolutionManager> {
-            project.gradle.sharedServices.registrations.findByName(serviceName)?.let {
-                @Suppress("UNCHECKED_CAST")
-                return it.service as Provider<KotlinNpmResolutionManager>
-            }
-
-            val message = {
-                "Build service KotlinNpmResolutionManager should be already registered"
-            }
-
-            requireNotNull(resolution, message)
-            requireNotNull(packageJsonHandlers, message)
-
-            return project.gradle.sharedServices.registerIfAbsent(serviceName, serviceClass) {
-                it.parameters.resolution.set(resolution)
-                it.parameters.packageJsonHandlers.set(packageJsonHandlers)
-                it.parameters.gradleNodeModulesProvider.set(gradleNodeModulesProvider)
-                it.parameters.compositeNodeModulesProvider.set(compositeNodeModulesProvider)
-            }
-        }
-
-        fun registerIfAbsent(
-            project: Project,
-            resolution: Provider<KotlinRootNpmResolution>?,
-            packageJsonHandlers: Provider<Map<String, MutableList<PackageJson.() -> Unit>>>?,
-            gradleNodeModulesProvider: Provider<GradleNodeModulesCache>,
-            compositeNodeModulesProvider: Provider<CompositeNodeModulesCache>
-        ) = registerIfAbsentImpl(
-            project,
-            resolution,
-            packageJsonHandlers,
-            gradleNodeModulesProvider,
-            compositeNodeModulesProvider
-        ).also { serviceProvider ->
-            SingleActionPerProject.run(project, UsesKotlinNpmResolutionManager::class.java.name) {
-                project.tasks.withType<UsesKotlinNpmResolutionManager>().configureEach { task ->
-                    task.usesService(serviceProvider)
-                    task.usesService(gradleNodeModulesProvider)
-                    task.usesService(compositeNodeModulesProvider)
-                }
-            }
-        }
-    }
 }

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

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockCopyTask.Companion.ST
 import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockCopyTask.Companion.UPGRADE_YARN_LOCK
 import org.jetbrains.kotlin.gradle.tasks.CleanDataTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
-import org.jetbrains.kotlin.gradle.utils.providerWithLazyConvention
 
 open class YarnPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
@@ -49,20 +48,13 @@ open class YarnPlugin : Plugin<Project> {
             }
         }
 
-        val objectFactory = project.objects
-
         val rootPackageJson = tasks.register(RootPackageJsonTask.NAME, RootPackageJsonTask::class.java) { task ->
             task.dependsOn(nodeJsTaskProviders.npmCachesSetupTaskProvider)
             task.group = NodeJsRootPlugin.TASKS_GROUP_NAME
             task.description = "Create root package.json"
 
             task.npmResolutionManager.apply {
-                // npmResolutionManager is initialised inside NodeJsRootPlugin after YarnPlugin applied
+                set(project.kotlinNpmResolutionManager)
-                set(
-                    objectFactory.providerWithLazyConvention {
-                        project.kotlinNpmResolutionManager.get()
-                    }
-                )
                 disallowChanges()
             }