@yarnpkg/nm 3.0.0-rc.9 → 3.0.1-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

@@ -73,7 +73,15 @@ const buildLocatorMap = (nodeModulesTree) => {
         val.locations = val.locations.sort((loc1, loc2) => {
             const len1 = loc1.split(fslib_1.ppath.delimiter).length;
             const len2 = loc2.split(fslib_1.ppath.delimiter).length;
-            return len1 !== len2 ? len2 - len1 : loc2.localeCompare(loc1);
+            if (loc2 === loc1) {
+                return 0;
+            }
+            else if (len1 !== len2) {
+                return len2 - len1;
+            }
+            else {
+                return loc2 > loc1 ? 1 : -1;
+            }
         });
     }
     return map;
@@ -84,88 +92,120 @@ 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;
+};
 /**
- * Traverses PnP tree and produces input for the `RawHoister`
- *
- * @param pnp PnP API
- *
- * @returns package tree, packages info and locators
+ * Builds a map representing layout of nested workspaces and internal portals on the file system.
  */
-const buildPackageTree = (pnp, options) => {
-    const pnpRoots = pnp.getDependencyTreeRoots();
-    const errors = [];
-    let preserveSymlinksRequired = false;
-    const hoistingLimits = new Map();
-    const workspaceDependenciesMap = new Map();
+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);
-    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);
+    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, parentLocator) => {
+        const locatorKey = stringifyLocator(locator);
+        if (seen.has(locatorKey))
+            return;
+        seen.add(locatorKey);
+        const pkg = pnp.getPackageInformation(locator);
+        if (pkg) {
+            const parentLocatorKey = parentLocator ? stringifyLocator(parentLocator) : ``;
+            if (stringifyLocator(locator) !== parentLocatorKey && pkg.linkType === LinkType.SOFT && !isExternalSoftLink(pkg, locator, pnp, topPkgPortableLocation)) {
+                const location = getRealPackageLocation(pkg, locator, pnp);
+                const prevLocator = workspaceLikeLocators.get(location);
+                // Give workspaces a priority over portals and other protocols pointing to the same location
+                // The devDependencies are not installed for portals, but installed for workspaces
+                if (!prevLocator || locator.reference.startsWith(`workspace:`)) {
+                    workspaceLikeLocators.set(location, locator);
                 }
-                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);
+            for (const [name, referencish] of pkg.packageDependencies) {
+                if (referencish !== null) {
+                    if (!pkg.packagePeers.has(name)) {
+                        visit(pnp.getLocator(name, referencish), locator);
+                    }
                 }
-                dependencies.add(node.workspaceLocator);
             }
-            for (const child of node.children.values()) {
-                addWorkspace(child, node.workspaceLocator || parentWorkspaceLocator);
+        }
+    };
+    for (const locator of pnpRoots)
+        visit(locator, null);
+    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);
             }
-        };
-        for (const child of workspaceTree.children.values()) {
-            addWorkspace(child, workspaceTree.workspaceLocator);
+            node = nextNode;
         }
+        node.workspaceLocator = locator;
     }
-    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 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`
+ *
+ * @param pnp PnP API
+ *
+ * @returns package tree, packages info and locators
+ */
+const buildPackageTree = (pnp, options) => {
+    const errors = [];
+    let preserveSymlinksRequired = false;
+    const hoistingLimits = 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.slice(0, -1));
     const packageTree = {
         name: topLocator.name,
         identName: topLocator.name,
         reference: topLocator.reference,
         peerNames: topPkg.packagePeers,
         dependencies: new Set(),
+        dependencyKind: hoist_1.HoisterDependencyKind.WORKSPACE,
     };
     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, parentPkg, parentDependencies, parentRelativeCwd, isHoistBorder) => {
         var _a, _b;
         const nodeKey = getNodeKey(name, locator);
@@ -175,18 +215,26 @@ const buildPackageTree = (pnp, options) => {
             node = packageTree;
             nodes.set(nodeKey, packageTree);
         }
+        const isExternalSoftLinkPackage = isExternalSoftLink(pkg, locator, pnp, topPkgPortableLocation);
         if (!node) {
+            let dependencyKind = hoist_1.HoisterDependencyKind.REGULAR;
+            if (isExternalSoftLinkPackage)
+                dependencyKind = hoist_1.HoisterDependencyKind.EXTERNAL_SOFT_LINK;
+            else if (pkg.linkType === LinkType.SOFT && locator.name.endsWith(WORKSPACE_NAME_SUFFIX))
+                dependencyKind = hoist_1.HoisterDependencyKind.WORKSPACE;
             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: dependencyKind === hoist_1.HoisterDependencyKind.WORKSPACE ? new Set() : pkg.packagePeers,
+                dependencyKind,
             };
             nodes.set(nodeKey, node);
         }
         let hoistPriority;
-        const isExternalSoftLinkPackage = isExternalSoftLink(pkg, locator);
         if (isExternalSoftLinkPackage)
             // External soft link dependencies have the highest priority - we don't want to install inside them
             hoistPriority = 2;
@@ -218,15 +266,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) {
@@ -235,7 +285,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;
@@ -287,7 +337,7 @@ 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, pkg, allDependencies, relativeDepCwd, isHoistBorder);
+                    addPackageToTree(depName, depPkg, depLocator, node, pkg, allDependencies, relativeDepCwd, isHoistBorder);
                 }
             }
         }
@@ -295,6 +345,12 @@ const buildPackageTree = (pnp, options) => {
     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);
@@ -312,10 +368,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 };
@@ -371,7 +424,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) {

package/lib/hoist.d.ts

@@ -46,6 +46,11 @@
  * until you run out of candidates for current tree root.
  */
 declare type PackageName = string;
+export declare enum HoisterDependencyKind {
+    REGULAR = 0,
+    WORKSPACE = 1,
+    EXTERNAL_SOFT_LINK = 2
+}
 export declare type HoisterTree = {
     name: PackageName;
     identName: PackageName;
@@ -53,6 +58,7 @@ export declare type HoisterTree = {
     dependencies: Set<HoisterTree>;
     peerNames: Set<PackageName>;
     hoistPriority?: number;
+    dependencyKind?: HoisterDependencyKind;
 };
 export declare type HoisterResult = {
     name: PackageName;

package/lib/hoist.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hoist = void 0;
+exports.hoist = exports.HoisterDependencyKind = void 0;
+var HoisterDependencyKind;
+(function (HoisterDependencyKind) {
+    HoisterDependencyKind[HoisterDependencyKind["REGULAR"] = 0] = "REGULAR";
+    HoisterDependencyKind[HoisterDependencyKind["WORKSPACE"] = 1] = "WORKSPACE";
+    HoisterDependencyKind[HoisterDependencyKind["EXTERNAL_SOFT_LINK"] = 2] = "EXTERNAL_SOFT_LINK";
+})(HoisterDependencyKind = exports.HoisterDependencyKind || (exports.HoisterDependencyKind = {}));
 var Hoistable;
 (function (Hoistable) {
     Hoistable[Hoistable["YES"] = 0] = "YES";
@@ -134,7 +140,7 @@ const getUsedDependencies = (rootNodePath) => {
 const decoupleGraphNode = (parent, node) => {
     if (node.decoupled)
         return node;
-    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder, hoistPriority } = node;
+    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder, hoistPriority, dependencyKind, 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 +157,9 @@ const decoupleGraphNode = (parent, node) => {
         decoupled: true,
         isHoistBorder,
         hoistPriority,
-        hoistedFrom: [],
+        dependencyKind,
+        hoistedFrom: new Map(hoistedFrom),
+        hoistedTo: new Map(hoistedTo),
     };
     const selfDep = clone.dependencies.get(name);
     if (selfDep && selfDep.ident == clone.ident)
@@ -308,7 +316,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();
@@ -320,6 +328,35 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
     let isHoistable = !isSelfReference;
     if (outputReason && !isHoistable)
         reason = `- self-reference`;
+    if (isHoistable) {
+        isHoistable = node.dependencyKind !== HoisterDependencyKind.WORKSPACE;
+        if (outputReason && !isHoistable) {
+            reason = `- workspace`;
+        }
+    }
+    if (isHoistable) {
+        isHoistable = node.dependencyKind !== HoisterDependencyKind.EXTERNAL_SOFT_LINK || node.dependencies.size === 0;
+        if (outputReason && !isHoistable) {
+            reason = `- external soft link with unhoisted dependencies`;
+        }
+    }
+    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.dependencyKind !== HoisterDependencyKind.WORKSPACE || 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) {
@@ -388,6 +425,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 };
     }
@@ -416,7 +464,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) {
@@ -449,25 +497,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);
-                        }
                     }
                 }
             }
@@ -512,7 +562,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);
@@ -532,23 +582,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`);
 };
 /**
@@ -571,14 +626,16 @@ const cloneTree = (tree, options) => {
         decoupled: true,
         isHoistBorder: true,
         hoistPriority: 0,
-        hoistedFrom: [],
+        dependencyKind: HoisterDependencyKind.WORKSPACE,
+        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, hoistPriority } = node;
+            const { name, identName, reference, peerNames, hoistPriority, dependencyKind } = node;
             const dependenciesNmHoistingLimits = options.hoistingLimits.get(parentNode.locator);
             workNode = {
                 name,
@@ -593,7 +650,9 @@ const cloneTree = (tree, options) => {
                 decoupled: true,
                 isHoistBorder: dependenciesNmHoistingLimits ? dependenciesNmHoistingLimits.has(name) : false,
                 hoistPriority: hoistPriority || 0,
-                hoistedFrom: [],
+                dependencyKind: dependencyKind || HoisterDependencyKind.REGULAR,
+                hoistedFrom: new Map(),
+                hoistedTo: new Map(),
             };
             seenNodes.set(node, workNode);
         }
@@ -713,6 +772,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$`))
@@ -752,7 +813,14 @@ const dumpDepTree = (tree) => {
         if (nodeCount > MAX_NODES_TO_DUMP || parents.has(pkg))
             return ``;
         nodeCount++;
-        const dependencies = Array.from(pkg.dependencies.values()).sort((n1, n2) => n1.name.localeCompare(n2.name));
+        const dependencies = Array.from(pkg.dependencies.values()).sort((n1, n2) => {
+            if (n1.name === n2.name) {
+                return 0;
+            }
+            else {
+                return n1.name > n2.name ? 1 : -1;
+            }
+        });
         let str = ``;
         parents.add(pkg);
         for (let idx = 0; idx < dependencies.length; idx++) {
@@ -760,7 +828,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": "3.0.0-rc.9",
+  "version": "3.0.1-rc.11",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "@yarnpkg/core": "^3.1.0-rc.9",
-    "@yarnpkg/fslib": "^2.6.0-rc.8"
+    "@yarnpkg/core": "^3.2.0-rc.11",
+    "@yarnpkg/fslib": "^2.6.1-rc.6"
   },
   "devDependencies": {
-    "@yarnpkg/pnp": "^3.1.0-rc.5"
+    "@yarnpkg/pnp": "^3.1.1-rc.11"
   },
   "scripts": {
     "postpack": "rm -rf lib",
@@ -33,5 +33,5 @@
   "engines": {
     "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
   },
-  "stableVersion": "2.4.1"
+  "stableVersion": "3.0.0"
 }