@yarnpkg/nm 2.4.1-rc.4 → 3.0.0-rc.11

package/lib/buildNodeModulesTree.d.ts

@@ -39,6 +39,7 @@ export interface NodeModulesTreeOptions {
     pnpifyFs?: boolean;
     validateExternalSoftLinks?: boolean;
     hoistingLimitsByCwd?: Map<PortablePath, NodeModulesHoistingLimits>;
+    selfReferencesByCwd?: Map<PortablePath, Boolean>;
     project?: Project;
 }
 /** Package locator key for usage inside maps */

package/lib/buildNodeModulesTree.js

@@ -49,7 +49,7 @@ const buildNodeModulesTree = (pnp, options) => {
     const { packageTree, hoistingLimits, errors, preserveSymlinksRequired } = buildPackageTree(pnp, options);
     let tree = null;
     if (errors.length === 0) {
-        const hoistedTree = hoist_1.hoist(packageTree, { hoistingLimits });
+        const hoistedTree = (0, hoist_1.hoist)(packageTree, { hoistingLimits });
         tree = populateNodeModulesTree(pnp, hoistedTree, options);
     }
     return { tree, errors, preserveSymlinksRequired };
@@ -84,6 +84,83 @@ const areRealLocatorsEqual = (a, b) => {
     const realB = core_1.structUtils.isVirtualLocator(b) ? core_1.structUtils.devirtualizeLocator(b) : b;
     return core_1.structUtils.areLocatorsEqual(realA, realB);
 };
+const isExternalSoftLink = (pkg, locator, pnp, topPkgPortableLocation) => {
+    if (pkg.linkType !== LinkType.SOFT)
+        return false;
+    const realSoftLinkPath = fslib_1.npath.toPortablePath(pnp.resolveVirtual && locator.reference && locator.reference.startsWith(`virtual:`) ? pnp.resolveVirtual(pkg.packageLocation) : pkg.packageLocation);
+    return fslib_1.ppath.contains(topPkgPortableLocation, realSoftLinkPath) === null;
+};
+/**
+ * Builds a map representing layout of nested workspaces and internal portals on the file system.
+ */
+const buildWorkspaceMap = (pnp) => {
+    const topPkg = pnp.getPackageInformation(pnp.topLevel);
+    if (topPkg === null)
+        throw new Error(`Assertion failed: Expected the top-level package to have been registered`);
+    const topLocator = pnp.findPackageLocator(topPkg.packageLocation);
+    if (topLocator === null)
+        throw new Error(`Assertion failed: Expected the top-level package to have a physical locator`);
+    const topPkgPortableLocation = fslib_1.npath.toPortablePath(topPkg.packageLocation.slice(0, -1));
+    const workspaceMap = new Map();
+    const workspaceTree = { children: new Map() };
+    const pnpRoots = pnp.getDependencyTreeRoots();
+    // Workspace and internal portal locations to locators map
+    const workspaceLikeLocators = new Map();
+    const seen = new Set();
+    const visit = (locator) => {
+        const locatorKey = stringifyLocator(locator);
+        if (seen.has(locatorKey))
+            return;
+        seen.add(locatorKey);
+        const pkg = pnp.getPackageInformation(locator);
+        if (pkg) {
+            if (pkg.linkType === LinkType.SOFT && !isExternalSoftLink(pkg, locator, pnp, topPkgPortableLocation))
+                workspaceLikeLocators.set(getRealPackageLocation(pkg, locator, pnp), locator);
+            for (const [name, referencish] of pkg.packageDependencies) {
+                if (referencish !== null) {
+                    if (!pkg.packagePeers.has(name)) {
+                        visit(pnp.getLocator(name, referencish));
+                    }
+                }
+            }
+        }
+    };
+    for (const locator of pnpRoots)
+        visit(locator);
+    const cwdSegments = topPkgPortableLocation.split(fslib_1.ppath.sep);
+    for (const locator of workspaceLikeLocators.values()) {
+        const pkg = pnp.getPackageInformation(locator);
+        const location = fslib_1.npath.toPortablePath(pkg.packageLocation.slice(0, -1));
+        const segments = location.split(fslib_1.ppath.sep).slice(cwdSegments.length);
+        let node = workspaceTree;
+        for (const segment of segments) {
+            let nextNode = node.children.get(segment);
+            if (!nextNode) {
+                nextNode = { children: new Map() };
+                node.children.set(segment, nextNode);
+            }
+            node = nextNode;
+        }
+        node.workspaceLocator = locator;
+    }
+    const addWorkspace = (node, parentWorkspaceLocator) => {
+        if (node.workspaceLocator) {
+            const parentLocatorKey = stringifyLocator(parentWorkspaceLocator);
+            let dependencies = workspaceMap.get(parentLocatorKey);
+            if (!dependencies) {
+                dependencies = new Set();
+                workspaceMap.set(parentLocatorKey, dependencies);
+            }
+            dependencies.add(node.workspaceLocator);
+        }
+        for (const child of node.children.values()) {
+            addWorkspace(child, node.workspaceLocator || parentWorkspaceLocator);
+        }
+    };
+    for (const child of workspaceTree.children.values())
+        addWorkspace(child, workspaceTree.workspaceLocator);
+    return workspaceMap;
+};
 /**
  * Traverses PnP tree and produces input for the `RawHoister`
  *
@@ -92,81 +169,28 @@ const areRealLocatorsEqual = (a, b) => {
  * @returns package tree, packages info and locators
  */
 const buildPackageTree = (pnp, options) => {
-    const pnpRoots = pnp.getDependencyTreeRoots();
     const errors = [];
     let preserveSymlinksRequired = false;
     const hoistingLimits = new Map();
-    const workspaceDependenciesMap = new Map();
+    const workspaceMap = buildWorkspaceMap(pnp);
     const topPkg = pnp.getPackageInformation(pnp.topLevel);
     if (topPkg === null)
         throw new Error(`Assertion failed: Expected the top-level package to have been registered`);
     const topLocator = pnp.findPackageLocator(topPkg.packageLocation);
     if (topLocator === null)
         throw new Error(`Assertion failed: Expected the top-level package to have a physical locator`);
-    const topPkgPortableLocation = fslib_1.npath.toPortablePath(topPkg.packageLocation);
-    const topLocatorKey = stringifyLocator(topLocator);
-    if (options.project) {
-        const workspaceTree = { children: new Map() };
-        const cwdSegments = options.project.cwd.split(fslib_1.ppath.sep);
-        for (const [cwd, workspace] of options.project.workspacesByCwd) {
-            const segments = cwd.split(fslib_1.ppath.sep).slice(cwdSegments.length);
-            let node = workspaceTree;
-            for (const segment of segments) {
-                let nextNode = node.children.get(segment);
-                if (!nextNode) {
-                    nextNode = { children: new Map() };
-                    node.children.set(segment, nextNode);
-                }
-                node = nextNode;
-            }
-            node.workspaceLocator = { name: core_1.structUtils.stringifyIdent(workspace.anchoredLocator), reference: workspace.anchoredLocator.reference };
-        }
-        const addWorkspace = (node, parentWorkspaceLocator) => {
-            if (node.workspaceLocator) {
-                const parentLocatorKey = stringifyLocator(parentWorkspaceLocator);
-                let dependencies = workspaceDependenciesMap.get(parentLocatorKey);
-                if (!dependencies) {
-                    dependencies = new Set();
-                    workspaceDependenciesMap.set(parentLocatorKey, dependencies);
-                }
-                dependencies.add(node.workspaceLocator);
-            }
-            for (const child of node.children.values()) {
-                addWorkspace(child, node.workspaceLocator || parentWorkspaceLocator);
-            }
-        };
-        for (const child of workspaceTree.children.values()) {
-            addWorkspace(child, workspaceTree.workspaceLocator);
-        }
-    }
-    else {
-        for (const locator of pnpRoots) {
-            if (locator.name !== topLocator.name || locator.reference !== topLocator.reference) {
-                let dependencies = workspaceDependenciesMap.get(topLocatorKey);
-                if (!dependencies) {
-                    dependencies = new Set();
-                    workspaceDependenciesMap.set(topLocatorKey, dependencies);
-                }
-                dependencies.add(locator);
-            }
-        }
-    }
+    const topPkgPortableLocation = fslib_1.npath.toPortablePath(topPkg.packageLocation.slice(0, -1));
     const packageTree = {
         name: topLocator.name,
         identName: topLocator.name,
         reference: topLocator.reference,
         peerNames: topPkg.packagePeers,
         dependencies: new Set(),
+        isWorkspace: true,
     };
     const nodes = new Map();
     const getNodeKey = (name, locator) => `${stringifyLocator(locator)}:${name}`;
-    const isExternalSoftLink = (pkg, locator) => {
-        if (pkg.linkType !== LinkType.SOFT || !options.project)
-            return false;
-        const realSoftLinkPath = fslib_1.npath.toPortablePath(pnp.resolveVirtual && locator.reference && locator.reference.startsWith(`virtual:`) ? pnp.resolveVirtual(pkg.packageLocation) : pkg.packageLocation);
-        return fslib_1.ppath.contains(options.project.cwd, realSoftLinkPath) === null;
-    };
-    const addPackageToTree = (name, pkg, locator, parent, parentDependencies, parentRelativeCwd, isHoistBorder) => {
+    const addPackageToTree = (name, pkg, locator, parent, parentPkg, parentDependencies, parentRelativeCwd, isHoistBorder) => {
         var _a, _b;
         const nodeKey = getNodeKey(name, locator);
         let node = nodes.get(nodeKey);
@@ -175,17 +199,32 @@ const buildPackageTree = (pnp, options) => {
             node = packageTree;
             nodes.set(nodeKey, packageTree);
         }
+        const isExternalSoftLinkPackage = isExternalSoftLink(pkg, locator, pnp, topPkgPortableLocation);
         if (!node) {
+            const isWorkspace = pkg.linkType === LinkType.SOFT && locator.name.endsWith(WORKSPACE_NAME_SUFFIX);
             node = {
                 name,
                 identName: locator.name,
                 reference: locator.reference,
                 dependencies: new Set(),
-                peerNames: pkg.packagePeers,
+                // View peer dependencies as regular dependencies for workspaces
+                // (meeting workspace peer dependency constraints is sometimes hard, sometimes impossible for the nm linker)
+                peerNames: isWorkspace ? new Set() : pkg.packagePeers,
+                isWorkspace,
             };
             nodes.set(nodeKey, node);
         }
-        if (isHoistBorder && !isExternalSoftLink(pkg, locator)) {
+        let hoistPriority;
+        if (isExternalSoftLinkPackage)
+            // External soft link dependencies have the highest priority - we don't want to install inside them
+            hoistPriority = 2;
+        else if (parentPkg.linkType === LinkType.SOFT)
+            // Internal soft link dependencies should have priority over transitive dependencies - to maximize chances having only one top-level node_modules
+            hoistPriority = 1;
+        else
+            hoistPriority = 0;
+        node.hoistPriority = Math.max(node.hoistPriority || 0, hoistPriority);
+        if (isHoistBorder && !isExternalSoftLinkPackage) {
             const parentLocatorKey = stringifyLocator({ name: parent.identName, reference: parent.reference });
             const dependencyBorders = hoistingLimits.get(parentLocatorKey) || new Set();
             hoistingLimits.set(parentLocatorKey, dependencyBorders);
@@ -207,15 +246,17 @@ const buildPackageTree = (pnp, options) => {
                 }
             }
         }
-        const locatorKey = stringifyLocator(locator);
-        const workspaceDependencies = workspaceDependenciesMap.get(locatorKey);
-        if (workspaceDependencies) {
-            for (const workspaceLocator of workspaceDependencies) {
+        const locatorKey = stringifyLocator({ name: locator.name.replace(WORKSPACE_NAME_SUFFIX, ``), reference: locator.reference });
+        const innerWorkspaces = workspaceMap.get(locatorKey);
+        if (innerWorkspaces) {
+            for (const workspaceLocator of innerWorkspaces) {
                 allDependencies.set(`${workspaceLocator.name}${WORKSPACE_NAME_SUFFIX}`, workspaceLocator.reference);
             }
         }
-        parent.dependencies.add(node);
-        if (!isSeen) {
+        if (pkg !== parentPkg || pkg.linkType !== LinkType.SOFT || !options.selfReferencesByCwd || options.selfReferencesByCwd.get(parentRelativeCwd))
+            parent.dependencies.add(node);
+        const isWorkspaceDependency = locator !== topLocator && pkg.linkType === LinkType.SOFT && !locator.name.endsWith(WORKSPACE_NAME_SUFFIX) && !isExternalSoftLinkPackage;
+        if (!isSeen && !isWorkspaceDependency) {
             const siblingPortalDependencyMap = new Map();
             for (const [depName, referencish] of allDependencies) {
                 if (referencish !== null) {
@@ -224,7 +265,7 @@ const buildPackageTree = (pnp, options) => {
                     const depPkg = pnp.getPackageInformation(pkgLocator);
                     if (depPkg === null)
                         throw new Error(`Assertion failed: Expected the package to have been registered`);
-                    const isExternalSoftLinkDep = isExternalSoftLink(depPkg, depLocator);
+                    const isExternalSoftLinkDep = isExternalSoftLink(depPkg, depLocator, pnp, topPkgPortableLocation);
                     if (options.validateExternalSoftLinks && options.project && isExternalSoftLinkDep) {
                         if (depPkg.packageDependencies.size > 0)
                             preserveSymlinksRequired = true;
@@ -276,14 +317,20 @@ const buildPackageTree = (pnp, options) => {
                     const isHoistBorder = parentHoistingLimits === NodeModulesHoistingLimits.DEPENDENCIES
                         || depHoistingLimits === NodeModulesHoistingLimits.DEPENDENCIES
                         || depHoistingLimits === NodeModulesHoistingLimits.WORKSPACES;
-                    addPackageToTree(stringifyLocator(depLocator) === stringifyLocator(locator) ? name : depName, depPkg, depLocator, node, allDependencies, relativeDepCwd, isHoistBorder);
+                    addPackageToTree(stringifyLocator(depLocator) === stringifyLocator(locator) ? name : depName, depPkg, depLocator, node, pkg, allDependencies, relativeDepCwd, isHoistBorder);
                 }
             }
         }
     };
-    addPackageToTree(topLocator.name, topPkg, topLocator, packageTree, topPkg.packageDependencies, fslib_2.PortablePath.dot, false);
+    addPackageToTree(topLocator.name, topPkg, topLocator, packageTree, topPkg, topPkg.packageDependencies, fslib_2.PortablePath.dot, false);
     return { packageTree, hoistingLimits, errors, preserveSymlinksRequired };
 };
+function getRealPackageLocation(pkg, locator, pnp) {
+    const realPath = pnp.resolveVirtual && locator.reference && locator.reference.startsWith(`virtual:`)
+        ? pnp.resolveVirtual(pkg.packageLocation)
+        : pkg.packageLocation;
+    return fslib_1.npath.toPortablePath(realPath || pkg.packageLocation);
+}
 function getTargetLocatorPath(locator, pnp, options) {
     const pkgLocator = pnp.getLocator(locator.name.replace(WORKSPACE_NAME_SUFFIX, ``), locator.reference);
     const info = pnp.getPackageInformation(pkgLocator);
@@ -301,10 +348,7 @@ function getTargetLocatorPath(locator, pnp, options) {
         linkType = LinkType.SOFT;
     }
     else {
-        const truePath = pnp.resolveVirtual && locator.reference && locator.reference.startsWith(`virtual:`)
-            ? pnp.resolveVirtual(info.packageLocation)
-            : info.packageLocation;
-        target = fslib_1.npath.toPortablePath(truePath || info.packageLocation);
+        target = getRealPackageLocation(info, locator, pnp);
         linkType = info.linkType;
     }
     return { linkType, target };
@@ -334,11 +378,11 @@ const populateNodeModulesTree = (pnp, hoistedTree, options) => {
     const getPackageName = (identName) => {
         const [nameOrScope, name] = identName.split(`/`);
         return name ? {
-            scope: fslib_1.toFilename(nameOrScope),
-            name: fslib_1.toFilename(name),
+            scope: (0, fslib_1.toFilename)(nameOrScope),
+            name: (0, fslib_1.toFilename)(name),
         } : {
             scope: null,
-            name: fslib_1.toFilename(nameOrScope),
+            name: (0, fslib_1.toFilename)(nameOrScope),
         };
     };
     const seenNodes = new Set();
@@ -360,7 +404,13 @@ const populateNodeModulesTree = (pnp, hoistedTree, options) => {
             const nodeModulesLocation = fslib_1.ppath.join(nodeModulesDirPath, ...packageNameParts);
             const nodePath = `${parentNodePath}/${locator.name}`;
             const leafNode = makeLeafNode(locator, parentNodePath, references.slice(1));
-            if (!dep.name.endsWith(WORKSPACE_NAME_SUFFIX)) {
+            // We don't want to create self-referencing symlinks for anonymous workspaces
+            let isAnonymousWorkspace = false;
+            if (leafNode.linkType === LinkType.SOFT && options.project) {
+                const workspace = options.project.workspacesByCwd.get(leafNode.target.slice(0, -1));
+                isAnonymousWorkspace = !!(workspace && !workspace.manifest.name);
+            }
+            if (!dep.name.endsWith(WORKSPACE_NAME_SUFFIX) && !isAnonymousWorkspace) {
                 const prevNode = tree.get(nodeModulesLocation);
                 if (prevNode) {
                     if (prevNode.dirList) {
@@ -382,7 +432,7 @@ const populateNodeModulesTree = (pnp, hoistedTree, options) => {
                 let segCount = segments.length - 1;
                 while (nodeModulesIdx >= 0 && segCount > nodeModulesIdx) {
                     const dirPath = fslib_1.npath.toPortablePath(segments.slice(0, segCount).join(fslib_1.ppath.sep));
-                    const targetDir = fslib_1.toFilename(segments[segCount]);
+                    const targetDir = (0, fslib_1.toFilename)(segments[segCount]);
                     const subdirs = tree.get(dirPath);
                     if (!subdirs) {
                         tree.set(dirPath, { dirList: new Set([targetDir]) });
@@ -422,7 +472,7 @@ const benchmarkRawHoisting = (packageTree) => {
     const iterCount = 10;
     const startTime = Date.now();
     for (let iter = 0; iter < iterCount; iter++)
-        hoist_1.hoist(packageTree);
+        (0, hoist_1.hoist)(packageTree);
     const endTime = Date.now();
     return (endTime - startTime) / iterCount;
 };
@@ -442,7 +492,7 @@ const benchmarkBuildTree = (pnp, options) => {
     const startTime = Date.now();
     for (let iter = 0; iter < iterCount; iter++) {
         const { packageTree, hoistingLimits } = buildPackageTree(pnp, options);
-        const hoistedTree = hoist_1.hoist(packageTree, { hoistingLimits });
+        const hoistedTree = (0, hoist_1.hoist)(packageTree, { hoistingLimits });
         populateNodeModulesTree(pnp, hoistedTree, options);
     }
     const endTime = Date.now();

package/lib/hoist.d.ts

@@ -52,6 +52,8 @@ export declare type HoisterTree = {
     reference: string;
     dependencies: Set<HoisterTree>;
     peerNames: Set<PackageName>;
+    hoistPriority?: number;
+    isWorkspace?: boolean;
 };
 export declare type HoisterResult = {
     name: PackageName;

package/lib/hoist.js

@@ -88,10 +88,6 @@ const getUsedDependencies = (rootNodePath) => {
     const rootNode = rootNodePath[rootNodePath.length - 1];
     const usedDependencies = new Map();
     const seenNodes = new Set();
-    const reachableDependencies = new Map();
-    for (const node of rootNodePath)
-        for (const dep of node.dependencies.values())
-            reachableDependencies.set(dep.name, dep);
     const hiddenDependencies = new Set();
     const addUsedDependencies = (node, hiddenDependencies) => {
         if (seenNodes.has(node))
@@ -99,9 +95,12 @@ const getUsedDependencies = (rootNodePath) => {
         seenNodes.add(node);
         for (const dep of node.hoistedDependencies.values()) {
             if (!hiddenDependencies.has(dep.name)) {
-                const reachableDependency = reachableDependencies.get(dep.name);
-                if (reachableDependency) {
-                    usedDependencies.set(reachableDependency.name, reachableDependency);
+                let reachableDependency;
+                for (const node of rootNodePath) {
+                    reachableDependency = node.dependencies.get(dep.name);
+                    if (reachableDependency) {
+                        usedDependencies.set(reachableDependency.name, reachableDependency);
+                    }
                 }
             }
         }
@@ -135,7 +134,7 @@ const getUsedDependencies = (rootNodePath) => {
 const decoupleGraphNode = (parent, node) => {
     if (node.decoupled)
         return node;
-    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder } = node;
+    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder, hoistPriority, isWorkspace, hoistedFrom, hoistedTo } = node;
     // To perform node hoisting from parent node we must clone parent nodes up to the root node,
     // because some other package in the tree might depend on the parent package where hoisting
     // cannot be performed
@@ -151,7 +150,10 @@ const decoupleGraphNode = (parent, node) => {
         reasons: new Map(reasons),
         decoupled: true,
         isHoistBorder,
-        hoistedFrom: [],
+        hoistPriority,
+        isWorkspace,
+        hoistedFrom: new Map(hoistedFrom),
+        hoistedTo: new Map(hoistedTo),
     };
     const selfDep = clone.dependencies.get(name);
     if (selfDep && selfDep.ident == clone.ident)
@@ -181,7 +183,10 @@ const getHoistIdentMap = (rootNode, preferenceMap) => {
     keyList.sort((key1, key2) => {
         const entry1 = preferenceMap.get(key1);
         const entry2 = preferenceMap.get(key2);
-        if (entry2.peerDependents.size !== entry1.peerDependents.size) {
+        if (entry2.hoistPriority !== entry1.hoistPriority) {
+            return entry2.hoistPriority - entry1.hoistPriority;
+        }
+        else if (entry2.peerDependents.size !== entry1.peerDependents.size) {
             return entry2.peerDependents.size - entry1.peerDependents.size;
         }
         else {
@@ -305,7 +310,7 @@ const hoistTo = (tree, rootNodePath, rootNodePathLocators, parentShadowedNodes,
     }
     return { anotherRoundNeeded, isGraphChanged };
 };
-const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDependencies, hoistIdents, hoistIdentMap, shadowedNodes, { outputReason }) => {
+const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDependencies, hoistIdents, hoistIdentMap, shadowedNodes, { outputReason, fastLookupPossible }) => {
     let reasonRoot;
     let reason = null;
     let dependsOn = new Set();
@@ -317,6 +322,29 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
     let isHoistable = !isSelfReference;
     if (outputReason && !isHoistable)
         reason = `- self-reference`;
+    if (isHoistable) {
+        isHoistable = !node.isWorkspace;
+        if (outputReason && !isHoistable) {
+            reason = `- workspace`;
+        }
+    }
+    if (isHoistable) {
+        // Direct workspace dependencies must be hoisted to any common ancestor workspace of all the
+        // graph paths that include the dependency, because otherwise running app with
+        // `--preserve-symlinks` will become broken (without this flag the Node.js will pick dependency
+        // from the ancestor on the file system and with this flag it will pick ancestor from the graph
+        // and if these ancestors are different, the behavious of the application will be different).
+        // Another problem, which is prevented - is a creation of multiple hoisting layouts
+        // for the same workspace, because different dependencies of the same workspace might be hoisted
+        // differently, depending on the recepient workspace.
+        // It is difficult to find all common ancestors, but there is one easy to find common ancestor -
+        // the root workspace, so, for now, we either hoist direct dependencies into the root workspace, or we keep them
+        // unhoisted, thus we are safe from various pathological cases with `--preserve-symlinks`
+        isHoistable = !parentNode.isWorkspace || parentNode.hoistedFrom.has(node.name) || rootNodePathLocators.size === 1;
+        if (outputReason && !isHoistable) {
+            reason = parentNode.reasons.get(node.name);
+        }
+    }
     if (isHoistable) {
         isHoistable = !rootNode.peerNames.has(node.name);
         if (outputReason && !isHoistable) {
@@ -385,6 +413,17 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
         }
         isHoistable = arePeerDepsSatisfied;
     }
+    if (isHoistable && !fastLookupPossible) {
+        for (const origDep of node.hoistedDependencies.values()) {
+            const usedDep = usedDependencies.get(origDep.name);
+            if (!usedDep || origDep.ident !== usedDep.ident) {
+                isHoistable = false;
+                if (outputReason)
+                    reason = `- previously hoisted dependency mismatch, needed: ${prettyPrintLocator(origDep.locator)}, available: ${prettyPrintLocator(usedDep === null || usedDep === void 0 ? void 0 : usedDep.locator)}`;
+                break;
+            }
+        }
+    }
     if (dependsOn !== null && dependsOn.size > 0) {
         return { isHoistable: Hoistable.DEPENDS, dependsOn, reason };
     }
@@ -413,7 +452,7 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
         const dependantTree = new Map();
         const hoistInfos = new Map();
         for (const subDependency of getSortedRegularDependencies(parentNode)) {
-            const hoistInfo = getNodeHoistInfo(rootNode, rootNodePathLocators, [rootNode, ...nodePath, parentNode], subDependency, usedDependencies, hoistIdents, hoistIdentMap, shadowedNodes, { outputReason: options.debugLevel >= DebugLevel.REASONS });
+            const hoistInfo = getNodeHoistInfo(rootNode, rootNodePathLocators, [rootNode, ...nodePath, parentNode], subDependency, usedDependencies, hoistIdents, hoistIdentMap, shadowedNodes, { outputReason: options.debugLevel >= DebugLevel.REASONS, fastLookupPossible: options.fastLookupPossible });
             hoistInfos.set(subDependency, hoistInfo);
             if (hoistInfo.isHoistable === Hoistable.DEPENDS) {
                 for (const node of hoistInfo.dependsOn) {
@@ -446,25 +485,27 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
                 parentNode.hoistedDependencies.set(node.name, node);
                 parentNode.reasons.delete(node.name);
                 const hoistedNode = rootNode.dependencies.get(node.name);
-                let hoistedFrom = null;
-                if (options.debugLevel >= DebugLevel.REASONS)
-                    hoistedFrom = Array.from(locatorPath).concat([parentNode.locator]).map(x => prettyPrintLocator(x)).join(`→`);
+                if (options.debugLevel >= DebugLevel.REASONS) {
+                    const hoistedFrom = Array.from(locatorPath).concat([parentNode.locator]).map(x => prettyPrintLocator(x)).join(`→`);
+                    let hoistedFromArray = rootNode.hoistedFrom.get(node.name);
+                    if (!hoistedFromArray) {
+                        hoistedFromArray = [];
+                        rootNode.hoistedFrom.set(node.name, hoistedFromArray);
+                    }
+                    hoistedFromArray.push(hoistedFrom);
+                    parentNode.hoistedTo.set(node.name, Array.from(rootNodePath).map(x => prettyPrintLocator(x.locator)).join(`→`));
+                }
                 // Add hoisted node to root node, in case it is not already there
                 if (!hoistedNode) {
                     // Avoid adding other version of root node to itself
                     if (rootNode.ident !== node.ident) {
                         rootNode.dependencies.set(node.name, node);
-                        if (options.debugLevel >= DebugLevel.REASONS)
-                            node.hoistedFrom.push(hoistedFrom);
                         newNodes.add(node);
                     }
                 }
                 else {
                     for (const reference of node.references) {
                         hoistedNode.references.add(reference);
-                        if (options.debugLevel >= DebugLevel.REASONS) {
-                            hoistedNode.hoistedFrom.push(hoistedFrom);
-                        }
                     }
                 }
             }
@@ -509,7 +550,7 @@ const selfCheck = (tree) => {
     const log = [];
     const seenNodes = new Set();
     const parents = new Set();
-    const checkNode = (node, parentDeps) => {
+    const checkNode = (node, parentDeps, parent) => {
         if (seenNodes.has(node))
             return;
         seenNodes.add(node);
@@ -529,23 +570,28 @@ const selfCheck = (tree) => {
                 }
             }
             else {
+                const hoistedFrom = parent.hoistedFrom.get(node.name);
+                const originalHoistedTo = node.hoistedTo.get(origDep.name);
+                const prettyHoistedFrom = `${hoistedFrom ? ` hoisted from ${hoistedFrom.join(`, `)}` : ``}`;
+                const prettyOriginalHoistedTo = `${originalHoistedTo ? ` hoisted to ${originalHoistedTo}` : ``}`;
+                const prettyNodePath = `${prettyPrintTreePath()}${prettyHoistedFrom}`;
                 if (!dep) {
-                    log.push(`${prettyPrintTreePath()} - broken require promise: no required dependency ${origDep.locator} found`);
+                    log.push(`${prettyNodePath} - broken require promise: no required dependency ${origDep.name}${prettyOriginalHoistedTo} found`);
                 }
                 else if (dep.ident !== origDep.ident) {
-                    log.push(`${prettyPrintTreePath()} - broken require promise for ${origDep.name}: expected ${origDep.ident}, but found: ${dep.ident}`);
+                    log.push(`${prettyNodePath} - broken require promise for ${origDep.name}${prettyOriginalHoistedTo}: expected ${origDep.ident}, but found: ${dep.ident}`);
                 }
             }
         }
         parents.add(node);
         for (const dep of node.dependencies.values()) {
             if (!node.peerNames.has(dep.name)) {
-                checkNode(dep, dependencies);
+                checkNode(dep, dependencies, node);
             }
         }
         parents.delete(node);
     };
-    checkNode(tree, tree.dependencies);
+    checkNode(tree, tree.dependencies, tree);
     return log.join(`\n`);
 };
 /**
@@ -567,14 +613,17 @@ const cloneTree = (tree, options) => {
         reasons: new Map(),
         decoupled: true,
         isHoistBorder: true,
-        hoistedFrom: [],
+        hoistPriority: 0,
+        isWorkspace: true,
+        hoistedFrom: new Map(),
+        hoistedTo: new Map(),
     };
     const seenNodes = new Map([[tree, treeCopy]]);
     const addNode = (node, parentNode) => {
         let workNode = seenNodes.get(node);
         const isSeen = !!workNode;
         if (!workNode) {
-            const { name, identName, reference, peerNames } = node;
+            const { name, identName, reference, peerNames, hoistPriority, isWorkspace } = node;
             const dependenciesNmHoistingLimits = options.hoistingLimits.get(parentNode.locator);
             workNode = {
                 name,
@@ -588,7 +637,10 @@ const cloneTree = (tree, options) => {
                 reasons: new Map(),
                 decoupled: true,
                 isHoistBorder: dependenciesNmHoistingLimits ? dependenciesNmHoistingLimits.has(name) : false,
-                hoistedFrom: [],
+                hoistPriority: hoistPriority || 0,
+                isWorkspace: isWorkspace || false,
+                hoistedFrom: new Map(),
+                hoistedTo: new Map(),
             };
             seenNodes.set(node, workNode);
         }
@@ -679,7 +731,7 @@ const buildPreferenceMap = (rootNode) => {
         const key = getPreferenceKey(node);
         let entry = preferenceMap.get(key);
         if (!entry) {
-            entry = { dependents: new Set(), peerDependents: new Set() };
+            entry = { dependents: new Set(), peerDependents: new Set(), hoistPriority: 0 };
             preferenceMap.set(key, entry);
         }
         return entry;
@@ -691,8 +743,9 @@ const buildPreferenceMap = (rootNode) => {
         if (!isSeen) {
             seenNodes.add(node);
             for (const dep of node.dependencies.values()) {
+                const entry = getOrCreatePreferenceEntry(dep);
+                entry.hoistPriority = Math.max(entry.hoistPriority, dep.hoistPriority);
                 if (node.peerNames.has(dep.name)) {
-                    const entry = getOrCreatePreferenceEntry(dep);
                     entry.peerDependents.add(node.ident);
                 }
                 else {
@@ -707,6 +760,8 @@ const buildPreferenceMap = (rootNode) => {
     return preferenceMap;
 };
 const prettyPrintLocator = (locator) => {
+    if (!locator)
+        return `none`;
     const idx = locator.indexOf(`@`, 1);
     let name = locator.substring(0, idx);
     if (name.endsWith(`$wsroot$`))
@@ -754,7 +809,8 @@ const dumpDepTree = (tree) => {
             if (!pkg.peerNames.has(dep.name) && dep !== pkg) {
                 const reason = pkg.reasons.get(dep.name);
                 const identName = getIdentName(dep.locator);
-                str += `${prefix}${idx < dependencies.length - 1 ? `├─` : `└─`}${(parents.has(dep) ? `>` : ``) + (identName !== dep.name ? `a:${dep.name}:` : ``) + prettyPrintLocator(dep.locator) + (reason ? ` ${reason}` : ``) + (dep !== pkg && dep.hoistedFrom.length > 0 ? `, hoisted from: ${dep.hoistedFrom.join(`, `)}` : ``)}\n`;
+                const hoistedFrom = pkg.hoistedFrom.get(dep.name) || [];
+                str += `${prefix}${idx < dependencies.length - 1 ? `├─` : `└─`}${(parents.has(dep) ? `>` : ``) + (identName !== dep.name ? `a:${dep.name}:` : ``) + prettyPrintLocator(dep.locator) + (reason ? ` ${reason}` : ``) + (dep !== pkg && hoistedFrom.length > 0 ? `, hoisted from: ${hoistedFrom.join(`, `)}` : ``)}\n`;
                 str += dumpPackage(dep, parents, `${prefix}${idx < dependencies.length - 1 ? `│ ` : `  `}`);
             }
         }

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@yarnpkg/nm",
-  "version": "2.4.1-rc.4",
+  "version": "3.0.0-rc.11",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "@yarnpkg/core": "^3.0.0-rc.13",
-    "@yarnpkg/fslib": "^2.5.0-rc.13"
+    "@yarnpkg/core": "^3.1.0-rc.11",
+    "@yarnpkg/fslib": "^2.6.0-rc.10"
   },
   "devDependencies": {
-    "@yarnpkg/pnp": "3.0.0-rc.13"
+    "@yarnpkg/pnp": "^3.1.0-rc.7"
   },
   "scripts": {
     "postpack": "rm -rf lib",
@@ -33,5 +33,5 @@
   "engines": {
     "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
   },
-  "stableVersion": "2.4.0"
+  "stableVersion": "2.4.1"
 }