Gradle, js, npm: fix resolving transitive npm dependencies using yarn.lock

- already visited transitive npm dependencies should be stored in parent dependencies
- child NpmDependency should search resolved project data in parent NpmDependencies

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/NpmDependency.kt

@@ -31,6 +31,7 @@ data class NpmDependency(
 
     override fun getGroup(): String? = org
 
+    internal var parent: NpmDependency? = null
     internal val dependencies = mutableSetOf<NpmDependency>()
 
     override fun resolve(transitive: Boolean): MutableSet<File> {
@@ -64,7 +65,9 @@ data class NpmDependency(
     }
 
     override fun resolve(): MutableSet<File> {
-        val npmPackage = resolveProject() ?: return mutableSetOf()
+        val npmPackage = parent?.resolveProject()
+            ?: resolveProject()
+            ?: return mutableSetOf()
         return mutableSetOf(npmPackage.npmProject.resolve(key)!!)
     }
 
@@ -86,7 +89,8 @@ data class NpmDependency(
         return when (result) {
             null -> null
             is AlreadyInProgress -> null
-            is AlreadyResolved -> findIn(result.resolution) ?: error("Project hierarchy is already resolved in NPM without $this")
+            is AlreadyResolved -> findIn(result.resolution)
+                ?: error("Project hierarchy is already resolved in NPM without $this")
             is ResolvedNow -> findIn(result.resolution) ?: error("Cannot find $this after NPM project resolve")
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/yarn/YarnBasics.kt

@@ -42,29 +42,35 @@ abstract class YarnBasics : NpmApi {
         val yarnLock = nodeWorkDir.resolve("yarn.lock")
         if (yarnLock.isFile) {
             val byKey = YarnLock.parse(yarnLock).entries.associateBy { it.key }
-            val visited = mutableSetOf<NpmDependency>()
+            val visited = mutableMapOf<NpmDependency, NpmDependency>()
 
             fun resolveRecursively(src: NpmDependency): NpmDependency {
-                if (src in visited) return src
+                val copy = visited[src]
-                visited.add(src)
+                if (copy != null) {
+                    src.dependencies.addAll(copy.dependencies)
+                    return src
+                }
+                visited[src] = src
 
                 val key = YarnLock.key(src.key, src.version)
                 val deps = byKey[key]
                 if (deps != null) {
                     src.dependencies.addAll(deps.dependencies.map { dep ->
                         val scopedName = dep.scopedName
-
+                        val child = NpmDependency(
-                        resolveRecursively(
+                            src.project,
-                            NpmDependency(
+                            scopedName.scope,
-                                src.project,
+                            scopedName.name,
-                                scopedName.scope,
+                            dep.version ?: "*"
-                                scopedName.name,
-                                dep.version ?: "*"
-                            )
                         )
+                        child.parent = src
+
+                        resolveRecursively(child)
+
+                        child
                     })
                 } else {
-                    // todo: [WARN] cannot find $key in yarn.lock
+                    error("Cannot find $key in yarn.lock")
                 }
 
                 return src