metro-file-map 0.80.8 → 0.80.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.80.8",
+  "version": "0.80.10",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "repository": {
@@ -16,6 +16,7 @@
     "anymatch": "^3.0.3",
     "debug": "^2.2.0",
     "fb-watchman": "^2.0.0",
+    "flow-enums-runtime": "^0.0.6",
     "graceful-fs": "^4.2.4",
     "invariant": "^2.2.4",
     "jest-worker": "^29.6.3",

package/src/Watcher.js

@@ -86,6 +86,7 @@ class Watcher extends _events.default {
     const crawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
+      console: options.console,
       includeSymlinks: options.enableSymlinks,
       extensions: options.extensions,
       forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,

package/src/Watcher.js.flow

@@ -103,6 +103,7 @@ export class Watcher extends EventEmitter {
     const crawlerOptions: CrawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
+      console: options.console,
       includeSymlinks: options.enableSymlinks,
       extensions: options.extensions,
       forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,

package/src/crawlers/node/index.js

@@ -52,7 +52,15 @@ function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
 }
 const debug = require("debug")("Metro:NodeCrawler");
-function find(roots, extensions, ignore, includeSymlinks, rootDir, callback) {
+function find(
+  roots,
+  extensions,
+  ignore,
+  includeSymlinks,
+  rootDir,
+  console,
+  callback
+) {
   const result = new Map();
   let activeCalls = 0;
   const pathUtils = new _RootPathUtils.RootPathUtils(rootDir);
@@ -66,43 +74,47 @@ function find(roots, extensions, ignore, includeSymlinks, rootDir, callback) {
       (err, entries) => {
         activeCalls--;
         if (err) {
-          callback(result);
-          return;
-        }
-        entries.forEach((entry) => {
-          const file = path.join(directory, entry.name.toString());
-          if (ignore(file)) {
-            return;
-          }
-          if (entry.isSymbolicLink() && !includeSymlinks) {
-            return;
-          }
-          if (entry.isDirectory()) {
-            search(file);
-            return;
-          }
-          activeCalls++;
-          fs.lstat(file, (err, stat) => {
-            activeCalls--;
-            if (!err && stat) {
-              const ext = path.extname(file).substr(1);
-              if (stat.isSymbolicLink() || extensions.includes(ext)) {
-                result.set(pathUtils.absoluteToNormal(file), [
-                  "",
-                  stat.mtime.getTime(),
-                  stat.size,
-                  0,
-                  "",
-                  null,
-                  stat.isSymbolicLink() ? 1 : 0,
-                ]);
-              }
+          console.warn(
+            `Error "${
+              err.code ?? err.message
+            }" reading contents of "${directory}", skipping. Add this directory to your ignore list to exclude it.`
+          );
+        } else {
+          entries.forEach((entry) => {
+            const file = path.join(directory, entry.name.toString());
+            if (ignore(file)) {
+              return;
+            }
+            if (entry.isSymbolicLink() && !includeSymlinks) {
+              return;
             }
-            if (activeCalls === 0) {
-              callback(result);
+            if (entry.isDirectory()) {
+              search(file);
+              return;
             }
+            activeCalls++;
+            fs.lstat(file, (err, stat) => {
+              activeCalls--;
+              if (!err && stat) {
+                const ext = path.extname(file).substr(1);
+                if (stat.isSymbolicLink() || extensions.includes(ext)) {
+                  result.set(pathUtils.absoluteToNormal(file), [
+                    "",
+                    stat.mtime.getTime(),
+                    stat.size,
+                    0,
+                    "",
+                    null,
+                    stat.isSymbolicLink() ? 1 : 0,
+                  ]);
+                }
+              }
+              if (activeCalls === 0) {
+                callback(result);
+              }
+            });
           });
-        });
+        }
         if (activeCalls === 0) {
           callback(result);
         }
@@ -121,6 +133,7 @@ function findNative(
   ignore,
   includeSymlinks,
   rootDir,
+  console,
   callback
 ) {
   const extensionClause = extensions.length
@@ -175,6 +188,7 @@ function findNative(
 }
 module.exports = async function nodeCrawl(options) {
   const {
+    console,
     previousState,
     extensions,
     forceNodeFilesystemAPI,
@@ -204,9 +218,25 @@ module.exports = async function nodeCrawl(options) {
       resolve(difference);
     };
     if (useNativeFind) {
-      findNative(roots, extensions, ignore, includeSymlinks, rootDir, callback);
+      findNative(
+        roots,
+        extensions,
+        ignore,
+        includeSymlinks,
+        rootDir,
+        console,
+        callback
+      );
     } else {
-      find(roots, extensions, ignore, includeSymlinks, rootDir, callback);
+      find(
+        roots,
+        extensions,
+        ignore,
+        includeSymlinks,
+        rootDir,
+        console,
+        callback
+      );
     }
   });
 };

package/src/crawlers/node/index.js.flow

@@ -11,6 +11,7 @@
 
 import type {
   CanonicalPath,
+  Console,
   CrawlerOptions,
   FileData,
   IgnoreMatcher,
@@ -33,6 +34,7 @@ function find(
   ignore: IgnoreMatcher,
   includeSymlinks: boolean,
   rootDir: string,
+  console: Console,
   callback: Callback,
 ): void {
   const result: FileData = new Map();
@@ -44,51 +46,52 @@ function find(
     fs.readdir(directory, {withFileTypes: true}, (err, entries) => {
       activeCalls--;
       if (err) {
-        callback(result);
-        return;
-      }
-
-      entries.forEach((entry: fs.Dirent) => {
-        const file = path.join(directory, entry.name.toString());
-
-        if (ignore(file)) {
-          return;
-        }
-
-        if (entry.isSymbolicLink() && !includeSymlinks) {
-          return;
-        }
-
-        if (entry.isDirectory()) {
-          search(file);
-          return;
-        }
+        console.warn(
+          `Error "${err.code ?? err.message}" reading contents of "${directory}", skipping. Add this directory to your ignore list to exclude it.`,
+        );
+      } else {
+        entries.forEach((entry: fs.Dirent) => {
+          const file = path.join(directory, entry.name.toString());
+
+          if (ignore(file)) {
+            return;
+          }
 
-        activeCalls++;
+          if (entry.isSymbolicLink() && !includeSymlinks) {
+            return;
+          }
 
-        fs.lstat(file, (err, stat) => {
-          activeCalls--;
+          if (entry.isDirectory()) {
+            search(file);
+            return;
+          }
 
-          if (!err && stat) {
-            const ext = path.extname(file).substr(1);
-            if (stat.isSymbolicLink() || extensions.includes(ext)) {
-              result.set(pathUtils.absoluteToNormal(file), [
-                '',
-                stat.mtime.getTime(),
-                stat.size,
-                0,
-                '',
-                null,
-                stat.isSymbolicLink() ? 1 : 0,
-              ]);
+          activeCalls++;
+
+          fs.lstat(file, (err, stat) => {
+            activeCalls--;
+
+            if (!err && stat) {
+              const ext = path.extname(file).substr(1);
+              if (stat.isSymbolicLink() || extensions.includes(ext)) {
+                result.set(pathUtils.absoluteToNormal(file), [
+                  '',
+                  stat.mtime.getTime(),
+                  stat.size,
+                  0,
+                  '',
+                  null,
+                  stat.isSymbolicLink() ? 1 : 0,
+                ]);
+              }
             }
-          }
 
-          if (activeCalls === 0) {
-            callback(result);
-          }
+            if (activeCalls === 0) {
+              callback(result);
+            }
+          });
         });
-      });
+      }
 
       if (activeCalls === 0) {
         callback(result);
@@ -109,6 +112,7 @@ function findNative(
   ignore: IgnoreMatcher,
   includeSymlinks: boolean,
   rootDir: string,
+  console: Console,
   callback: Callback,
 ): void {
   // Examples:
@@ -172,6 +176,7 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
   changedFiles: FileData,
 }> {
   const {
+    console,
     previousState,
     extensions,
     forceNodeFilesystemAPI,
@@ -194,7 +199,7 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
   debug('Using system find: %s', useNativeFind);
 
   return new Promise((resolve, reject) => {
-    const callback = (fileData: FileData) => {
+    const callback: Callback = fileData => {
       const difference = previousState.fileSystem.getDifference(fileData);
 
       perfLogger?.point('nodeCrawl_end');
@@ -209,9 +214,25 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
     };
 
     if (useNativeFind) {
-      findNative(roots, extensions, ignore, includeSymlinks, rootDir, callback);
+      findNative(
+        roots,
+        extensions,
+        ignore,
+        includeSymlinks,
+        rootDir,
+        console,
+        callback,
+      );
     } else {
-      find(roots, extensions, ignore, includeSymlinks, rootDir, callback);
+      find(
+        roots,
+        extensions,
+        ignore,
+        includeSymlinks,
+        rootDir,
+        console,
+        callback,
+      );
     }
   });
 };

package/src/flow-types.js.flow

@@ -88,6 +88,7 @@ export type Console = typeof global.console;
 export type CrawlerOptions = {
   abortSignal: ?AbortSignal,
   computeSha1: boolean,
+  console: Console,
   extensions: $ReadOnlyArray<string>,
   forceNodeFilesystemAPI: boolean,
   ignore: IgnoreMatcher,

package/src/lib/RootPathUtils.js

@@ -45,8 +45,9 @@ function _interopRequireWildcard(obj, nodeInterop) {
   }
   return newObj;
 }
-const UP_FRAGMENT = ".." + path.sep;
-const UP_FRAGMENT_LENGTH = UP_FRAGMENT.length;
+const UP_FRAGMENT_SEP = ".." + path.sep;
+const SEP_UP_FRAGMENT = path.sep + "..";
+const UP_FRAGMENT_SEP_LENGTH = UP_FRAGMENT_SEP.length;
 const CURRENT_FRAGMENT = "." + path.sep;
 class RootPathUtils {
   #rootDir;
@@ -70,6 +71,9 @@ class RootPathUtils {
       this.#rootParts.pop();
     }
   }
+  getBasenameOfNthAncestor(n) {
+    return this.#rootParts[this.#rootParts.length - 1 - n];
+  }
   absoluteToNormal(absolutePath) {
     let endOfMatchingPrefix = 0;
     let lastMatchingPartIdx = 0;
@@ -100,11 +104,11 @@ class RootPathUtils {
     let i = 0;
     let pos = 0;
     while (
-      normalPath.startsWith(UP_FRAGMENT, pos) ||
+      normalPath.startsWith(UP_FRAGMENT_SEP, pos) ||
       (normalPath.endsWith("..") && normalPath.length === 2 + pos)
     ) {
       left = this.#rootDirnames[i === this.#rootDepth ? this.#rootDepth : ++i];
-      pos += UP_FRAGMENT_LENGTH;
+      pos += UP_FRAGMENT_SEP_LENGTH;
     }
     const right = pos === 0 ? normalPath : normalPath.slice(pos);
     if (right.length === 0) {
@@ -121,13 +125,25 @@ class RootPathUtils {
       path.relative(this.#rootDir, path.join(this.#rootDir, relativePath))
     );
   }
+  joinNormalToRelative(normalPath, relativePath) {
+    if (normalPath === "") {
+      return relativePath;
+    }
+    if (relativePath === "") {
+      return normalPath;
+    }
+    if (normalPath === ".." || normalPath.endsWith(SEP_UP_FRAGMENT)) {
+      return this.relativeToNormal(normalPath + path.sep + relativePath);
+    }
+    return normalPath + path.sep + relativePath;
+  }
   #tryCollapseIndirectionsInSuffix(
     fullPath,
     startOfRelativePart,
     implicitUpIndirections
   ) {
     let totalUpIndirections = implicitUpIndirections;
-    for (let pos = startOfRelativePart; ; pos += UP_FRAGMENT_LENGTH) {
+    for (let pos = startOfRelativePart; ; pos += UP_FRAGMENT_SEP_LENGTH) {
       const nextIndirection = fullPath.indexOf(CURRENT_FRAGMENT, pos);
       if (nextIndirection === -1) {
         while (totalUpIndirections > 0) {
@@ -149,12 +165,12 @@ class RootPathUtils {
           right === "" ||
           (right === ".." && totalUpIndirections >= this.#rootParts.length - 1)
         ) {
-          return UP_FRAGMENT.repeat(totalUpIndirections).slice(0, -1);
+          return UP_FRAGMENT_SEP.repeat(totalUpIndirections).slice(0, -1);
         }
         if (totalUpIndirections === 0) {
           return right;
         }
-        return UP_FRAGMENT.repeat(totalUpIndirections) + right;
+        return UP_FRAGMENT_SEP.repeat(totalUpIndirections) + right;
       }
       if (totalUpIndirections < this.#rootParts.length - 1) {
         totalUpIndirections++;

package/src/lib/RootPathUtils.js.flow

@@ -34,8 +34,9 @@ import * as path from 'path';
  * back to `node:path` equivalents in those cases.
  */
 
-const UP_FRAGMENT = '..' + path.sep;
-const UP_FRAGMENT_LENGTH = UP_FRAGMENT.length;
+const UP_FRAGMENT_SEP = '..' + path.sep;
+const SEP_UP_FRAGMENT = path.sep + '..';
+const UP_FRAGMENT_SEP_LENGTH = UP_FRAGMENT_SEP.length;
 const CURRENT_FRAGMENT = '.' + path.sep;
 
 export class RootPathUtils {
@@ -66,6 +67,10 @@ export class RootPathUtils {
     }
   }
 
+  getBasenameOfNthAncestor(n: number): string {
+    return this.#rootParts[this.#rootParts.length - 1 - n];
+  }
+
   // absolutePath may be any well-formed absolute path.
   absoluteToNormal(absolutePath: string): string {
     let endOfMatchingPrefix = 0;
@@ -114,11 +119,11 @@ export class RootPathUtils {
     let i = 0;
     let pos = 0;
     while (
-      normalPath.startsWith(UP_FRAGMENT, pos) ||
+      normalPath.startsWith(UP_FRAGMENT_SEP, pos) ||
       (normalPath.endsWith('..') && normalPath.length === 2 + pos)
     ) {
       left = this.#rootDirnames[i === this.#rootDepth ? this.#rootDepth : ++i];
-      pos += UP_FRAGMENT_LENGTH;
+      pos += UP_FRAGMENT_SEP_LENGTH;
     }
     const right = pos === 0 ? normalPath : normalPath.slice(pos);
     if (right.length === 0) {
@@ -139,6 +144,22 @@ export class RootPathUtils {
     );
   }
 
+  // Takes a normal and relative path, and joins them efficiently into a normal
+  // path, including collapsing trailing '..' in the first part with leading
+  // project root segments in the relative part.
+  joinNormalToRelative(normalPath: string, relativePath: string): string {
+    if (normalPath === '') {
+      return relativePath;
+    }
+    if (relativePath === '') {
+      return normalPath;
+    }
+    if (normalPath === '..' || normalPath.endsWith(SEP_UP_FRAGMENT)) {
+      return this.relativeToNormal(normalPath + path.sep + relativePath);
+    }
+    return normalPath + path.sep + relativePath;
+  }
+
   // Internal: Tries to collapse sequences like `../root/foo` for root
   // `/project/root` down to the normal 'foo'.
   #tryCollapseIndirectionsInSuffix(
@@ -151,7 +172,7 @@ export class RootPathUtils {
     // unmatched suffix e.g /project/[../../foo], but bail out to Node's
     // path.relative if we find a possible indirection after any later segment,
     // or on any "./" that isn't a "../".
-    for (let pos = startOfRelativePart; ; pos += UP_FRAGMENT_LENGTH) {
+    for (let pos = startOfRelativePart; ; pos += UP_FRAGMENT_SEP_LENGTH) {
       const nextIndirection = fullPath.indexOf(CURRENT_FRAGMENT, pos);
       if (nextIndirection === -1) {
         // If we have any indirections, they may "collapse" if a subsequent
@@ -185,13 +206,13 @@ export class RootPathUtils {
         ) {
           // If we have no right side (or an indirection that would take us
           // below the root), just ensure we don't include a trailing separtor.
-          return UP_FRAGMENT.repeat(totalUpIndirections).slice(0, -1);
+          return UP_FRAGMENT_SEP.repeat(totalUpIndirections).slice(0, -1);
         }
         // Optimisation for the common case, saves a concatenation.
         if (totalUpIndirections === 0) {
           return right;
         }
-        return UP_FRAGMENT.repeat(totalUpIndirections) + right;
+        return UP_FRAGMENT_SEP.repeat(totalUpIndirections) + right;
       }
 
       // Cap the number of indirections at the total number of root segments.

package/src/lib/TreeFS.js

@@ -105,22 +105,20 @@ class TreeFS {
   }
   lookup(mixedPath) {
     const normalPath = this._normalizePath(mixedPath);
+    const links = new Set();
     const result = this._lookupByNormalPath(normalPath, {
+      collectLinkPaths: links,
       followLeaf: true,
     });
     if (!result.exists) {
-      const { canonicalMissingPath, canonicalLinkPaths } = result;
+      const { canonicalMissingPath } = result;
       return {
         exists: false,
-        links: new Set(
-          canonicalLinkPaths.map((canonicalPath) =>
-            this.#pathUtils.normalToAbsolute(canonicalPath)
-          )
-        ),
+        links,
         missing: this.#pathUtils.normalToAbsolute(canonicalMissingPath),
       };
     }
-    const { canonicalPath, canonicalLinkPaths, node } = result;
+    const { canonicalPath, node } = result;
     const type =
       node instanceof Map
         ? "d"
@@ -135,11 +133,7 @@ class TreeFS {
     );
     return {
       exists: true,
-      links: new Set(
-        canonicalLinkPaths.map((canonicalPath) =>
-          this.#pathUtils.normalToAbsolute(canonicalPath)
-        )
-      ),
+      links,
       realPath: this.#pathUtils.normalToAbsolute(canonicalPath),
       type,
     };
@@ -180,8 +174,12 @@ class TreeFS {
     if (!contextRootResult.exists) {
       return;
     }
-    const { canonicalPath: rootRealPath, node: contextRoot } =
-      contextRootResult;
+    const {
+      ancestorOfRootIdx,
+      canonicalPath: rootRealPath,
+      node: contextRoot,
+      parentNode: contextRootParent,
+    } = contextRootResult;
     if (!(contextRoot instanceof Map)) {
       return;
     }
@@ -194,13 +192,18 @@ class TreeFS {
       filterComparePosix && _path.default.sep !== "/"
         ? contextRootAbsolutePath.replaceAll(_path.default.sep, "/")
         : contextRootAbsolutePath;
-    for (const relativePathForComparison of this._pathIterator(contextRoot, {
-      alwaysYieldPosix: filterComparePosix,
-      canonicalPathOfRoot: rootRealPath,
-      follow,
-      recursive,
-      subtreeOnly: rootDir != null,
-    })) {
+    for (const relativePathForComparison of this._pathIterator(
+      contextRoot,
+      contextRootParent,
+      ancestorOfRootIdx,
+      {
+        alwaysYieldPosix: filterComparePosix,
+        canonicalPathOfRoot: rootRealPath,
+        follow,
+        recursive,
+        subtreeOnly: rootDir != null,
+      }
+    )) {
       if (
         filter == null ||
         filter.test(
@@ -295,10 +298,10 @@ class TreeFS {
     }
   ) {
     let targetNormalPath = requestedNormalPath;
-    const canonicalLinkPaths = [];
     let seen;
     let fromIdx = 0;
     let parentNode = this.#rootNode;
+    let ancestorOfRootIdx = null;
     while (targetNormalPath.length > fromIdx) {
       const nextSepIdx = targetNormalPath.indexOf(_path.default.sep, fromIdx);
       const isLastSegment = nextSepIdx === -1;
@@ -310,10 +313,15 @@ class TreeFS {
         continue;
       }
       let segmentNode = parentNode.get(segmentName);
+      if (segmentName === "..") {
+        ancestorOfRootIdx =
+          ancestorOfRootIdx == null ? 1 : ancestorOfRootIdx + 1;
+      } else if (segmentNode != null) {
+        ancestorOfRootIdx = null;
+      }
       if (segmentNode == null) {
         if (opts.makeDirectories !== true && segmentName !== "..") {
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: isLastSegment
               ? targetNormalPath
               : targetNormalPath.slice(0, fromIdx - 1),
@@ -332,7 +340,7 @@ class TreeFS {
           opts.followLeaf === false)
       ) {
         return {
-          canonicalLinkPaths,
+          ancestorOfRootIdx,
           canonicalPath: targetNormalPath,
           exists: true,
           node: segmentNode,
@@ -347,7 +355,6 @@ class TreeFS {
           : targetNormalPath.slice(0, fromIdx - 1);
         if (segmentNode[_constants.default.SYMLINK] === 0) {
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: currentPath,
             exists: false,
           };
@@ -356,18 +363,22 @@ class TreeFS {
           segmentNode,
           currentPath
         );
-        canonicalLinkPaths.push(currentPath);
+        if (opts.collectLinkPaths) {
+          opts.collectLinkPaths.add(
+            this.#pathUtils.normalToAbsolute(currentPath)
+          );
+        }
         targetNormalPath = isLastSegment
           ? normalSymlinkTarget
-          : normalSymlinkTarget +
-            _path.default.sep +
-            targetNormalPath.slice(fromIdx);
+          : this.#pathUtils.joinNormalToRelative(
+              normalSymlinkTarget,
+              targetNormalPath.slice(fromIdx)
+            );
         if (seen == null) {
           seen = new Set([requestedNormalPath]);
         }
         if (seen.has(targetNormalPath)) {
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: targetNormalPath,
             exists: false,
           };
@@ -382,7 +393,7 @@ class TreeFS {
       "Unexpectedly escaped traversal"
     );
     return {
-      canonicalLinkPaths,
+      ancestorOfRootIdx: null,
       canonicalPath: targetNormalPath,
       exists: true,
       node: this.#rootNode,
@@ -422,10 +433,30 @@ class TreeFS {
       ? this.#pathUtils.absoluteToNormal(relativeOrAbsolutePath)
       : this.#pathUtils.relativeToNormal(relativeOrAbsolutePath);
   }
-  *_pathIterator(rootNode, opts, pathPrefix = "", followedLinks = new Set()) {
+  *#directoryNodeIterator(node, parent, ancestorOfRootIdx) {
+    if (ancestorOfRootIdx != null && parent) {
+      yield [
+        this.#pathUtils.getBasenameOfNthAncestor(ancestorOfRootIdx - 1),
+        parent,
+      ];
+    }
+    yield* node.entries();
+  }
+  *_pathIterator(
+    iterationRootNode,
+    iterationRootParentNode,
+    ancestorOfRootIdx,
+    opts,
+    pathPrefix = "",
+    followedLinks = new Set()
+  ) {
     const pathSep = opts.alwaysYieldPosix ? "/" : _path.default.sep;
     const prefixWithSep = pathPrefix === "" ? pathPrefix : pathPrefix + pathSep;
-    for (const [name, node] of rootNode ?? this.#rootNode) {
+    for (const [name, node] of this.#directoryNodeIterator(
+      iterationRootNode,
+      iterationRootParentNode,
+      ancestorOfRootIdx
+    )) {
       if (opts.subtreeOnly && name === "..") {
         continue;
       }
@@ -458,6 +489,8 @@ class TreeFS {
           ) {
             yield* this._pathIterator(
               target,
+              resolved.parentNode,
+              resolved.ancestorOfRootIdx,
               opts,
               nodePath,
               new Set([...followedLinks, node])
@@ -465,7 +498,16 @@ class TreeFS {
           }
         }
       } else if (opts.recursive) {
-        yield* this._pathIterator(node, opts, nodePath, followedLinks);
+        yield* this._pathIterator(
+          node,
+          iterationRootParentNode,
+          ancestorOfRootIdx != null && ancestorOfRootIdx > 1
+            ? ancestorOfRootIdx - 1
+            : null,
+          opts,
+          nodePath,
+          followedLinks
+        );
       }
     }
   }

package/src/lib/TreeFS.js.flow

@@ -142,20 +142,20 @@ export default class TreeFS implements MutableFileSystem {
 
   lookup(mixedPath: Path): LookupResult {
     const normalPath = this._normalizePath(mixedPath);
-    const result = this._lookupByNormalPath(normalPath, {followLeaf: true});
+    const links = new Set<string>();
+    const result = this._lookupByNormalPath(normalPath, {
+      collectLinkPaths: links,
+      followLeaf: true,
+    });
     if (!result.exists) {
-      const {canonicalMissingPath, canonicalLinkPaths} = result;
+      const {canonicalMissingPath} = result;
       return {
         exists: false,
-        links: new Set(
-          canonicalLinkPaths.map(canonicalPath =>
-            this.#pathUtils.normalToAbsolute(canonicalPath),
-          ),
-        ),
+        links,
         missing: this.#pathUtils.normalToAbsolute(canonicalMissingPath),
       };
     }
-    const {canonicalPath, canonicalLinkPaths, node} = result;
+    const {canonicalPath, node} = result;
     const type = node instanceof Map ? 'd' : node[H.SYMLINK] === 0 ? 'f' : 'l';
     invariant(
       type !== 'l',
@@ -165,11 +165,7 @@ export default class TreeFS implements MutableFileSystem {
     );
     return {
       exists: true,
-      links: new Set(
-        canonicalLinkPaths.map(canonicalPath =>
-          this.#pathUtils.normalToAbsolute(canonicalPath),
-        ),
-      ),
+      links,
       realPath: this.#pathUtils.normalToAbsolute(canonicalPath),
       type,
     };
@@ -229,7 +225,12 @@ export default class TreeFS implements MutableFileSystem {
     if (!contextRootResult.exists) {
       return;
     }
-    const {canonicalPath: rootRealPath, node: contextRoot} = contextRootResult;
+    const {
+      ancestorOfRootIdx,
+      canonicalPath: rootRealPath,
+      node: contextRoot,
+      parentNode: contextRootParent,
+    } = contextRootResult;
     if (!(contextRoot instanceof Map)) {
       return;
     }
@@ -245,13 +246,18 @@ export default class TreeFS implements MutableFileSystem {
         ? contextRootAbsolutePath.replaceAll(path.sep, '/')
         : contextRootAbsolutePath;
 
-    for (const relativePathForComparison of this._pathIterator(contextRoot, {
-      alwaysYieldPosix: filterComparePosix,
-      canonicalPathOfRoot: rootRealPath,
-      follow,
-      recursive,
-      subtreeOnly: rootDir != null,
-    })) {
+    for (const relativePathForComparison of this._pathIterator(
+      contextRoot,
+      contextRootParent,
+      ancestorOfRootIdx,
+      {
+        alwaysYieldPosix: filterComparePosix,
+        canonicalPathOfRoot: rootRealPath,
+        follow,
+        recursive,
+        subtreeOnly: rootDir != null,
+      },
+    )) {
       if (
         filter == null ||
         filter.test(
@@ -357,6 +363,9 @@ export default class TreeFS implements MutableFileSystem {
   _lookupByNormalPath(
     requestedNormalPath: string,
     opts: {
+      // Mutable Set into which absolute real paths of traversed symlinks will
+      // be added. Omit for performance if not needed.
+      collectLinkPaths?: ?Set<string>,
       // Like lstat vs stat, whether to follow a symlink at the basename of
       // the given path, or return the details of the symlink itself.
       followLeaf?: boolean,
@@ -364,28 +373,25 @@ export default class TreeFS implements MutableFileSystem {
     } = {followLeaf: true, makeDirectories: false},
   ):
     | {
-        canonicalLinkPaths: Array<string>,
+        ancestorOfRootIdx: ?number,
         canonicalPath: string,
         exists: true,
         node: MixedNode,
         parentNode: DirectoryNode,
       }
     | {
-        canonicalLinkPaths: Array<string>,
+        ancestorOfRootIdx: ?number,
         canonicalPath: string,
         exists: true,
         node: DirectoryNode,
         parentNode: null,
       }
     | {
-        canonicalLinkPaths: Array<string>,
         canonicalMissingPath: string,
         exists: false,
       } {
     // We'll update the target if we hit a symlink.
     let targetNormalPath = requestedNormalPath;
-    // Set of traversed symlink paths to return.
-    const canonicalLinkPaths: Array<string> = [];
     // Lazy-initialised set of seen target paths, to detect symlink cycles.
     let seen: ?Set<string>;
     // Pointer to the first character of the current path segment in
@@ -393,6 +399,9 @@ export default class TreeFS implements MutableFileSystem {
     let fromIdx = 0;
     // The parent of the current segment
     let parentNode = this.#rootNode;
+    // If a returned node is a strict ancestor of the root, this is the number
+    // of levels below the root, i.e. '..' is 1, '../..' is 2, otherwise null.
+    let ancestorOfRootIdx: ?number = null;
 
     while (targetNormalPath.length > fromIdx) {
       const nextSepIdx = targetNormalPath.indexOf(path.sep, fromIdx);
@@ -408,10 +417,18 @@ export default class TreeFS implements MutableFileSystem {
 
       let segmentNode = parentNode.get(segmentName);
 
+      // In normal paths all indirections are at the prefix, so we are at the
+      // nth ancestor of the root iff the path so far is n '..' segments.
+      if (segmentName === '..') {
+        ancestorOfRootIdx =
+          ancestorOfRootIdx == null ? 1 : ancestorOfRootIdx + 1;
+      } else if (segmentNode != null) {
+        ancestorOfRootIdx = null;
+      }
+
       if (segmentNode == null) {
         if (opts.makeDirectories !== true && segmentName !== '..') {
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: isLastSegment
               ? targetNormalPath
               : targetNormalPath.slice(0, fromIdx - 1),
@@ -433,7 +450,7 @@ export default class TreeFS implements MutableFileSystem {
           opts.followLeaf === false)
       ) {
         return {
-          canonicalLinkPaths,
+          ancestorOfRootIdx,
           canonicalPath: targetNormalPath,
           exists: true,
           node: segmentNode,
@@ -452,7 +469,6 @@ export default class TreeFS implements MutableFileSystem {
         if (segmentNode[H.SYMLINK] === 0) {
           // Regular file in a directory path
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: currentPath,
             exists: false,
           };
@@ -463,13 +479,21 @@ export default class TreeFS implements MutableFileSystem {
           segmentNode,
           currentPath,
         );
-        canonicalLinkPaths.push(currentPath);
+        if (opts.collectLinkPaths) {
+          opts.collectLinkPaths.add(
+            this.#pathUtils.normalToAbsolute(currentPath),
+          );
+        }
 
         // Append any subsequent path segments to the symlink target, and reset
         // with our new target.
         targetNormalPath = isLastSegment
           ? normalSymlinkTarget
-          : normalSymlinkTarget + path.sep + targetNormalPath.slice(fromIdx);
+          : this.#pathUtils.joinNormalToRelative(
+              normalSymlinkTarget,
+              targetNormalPath.slice(fromIdx),
+            );
+
         if (seen == null) {
           // Optimisation: set this lazily only when we've encountered a symlink
           seen = new Set([requestedNormalPath]);
@@ -477,7 +501,6 @@ export default class TreeFS implements MutableFileSystem {
         if (seen.has(targetNormalPath)) {
           // TODO: Warn `Symlink cycle detected: ${[...seen, node].join(' -> ')}`
           return {
-            canonicalLinkPaths,
             canonicalMissingPath: targetNormalPath,
             exists: false,
           };
@@ -489,7 +512,7 @@ export default class TreeFS implements MutableFileSystem {
     }
     invariant(parentNode === this.#rootNode, 'Unexpectedly escaped traversal');
     return {
-      canonicalLinkPaths,
+      ancestorOfRootIdx: null,
       canonicalPath: targetNormalPath,
       exists: true,
       node: this.#rootNode,
@@ -540,12 +563,28 @@ export default class TreeFS implements MutableFileSystem {
       : this.#pathUtils.relativeToNormal(relativeOrAbsolutePath);
   }
 
+  *#directoryNodeIterator(
+    node: DirectoryNode,
+    parent: ?DirectoryNode,
+    ancestorOfRootIdx: ?number,
+  ): Iterator<[string, MixedNode]> {
+    if (ancestorOfRootIdx != null && parent) {
+      yield [
+        this.#pathUtils.getBasenameOfNthAncestor(ancestorOfRootIdx - 1),
+        parent,
+      ];
+    }
+    yield* node.entries();
+  }
+
   /**
    * Enumerate paths under a given node, including symlinks and through
    * symlinks (if `follow` is enabled).
    */
   *_pathIterator(
-    rootNode: DirectoryNode,
+    iterationRootNode: DirectoryNode,
+    iterationRootParentNode: ?DirectoryNode,
+    ancestorOfRootIdx: ?number,
     opts: $ReadOnly<{
       alwaysYieldPosix: boolean,
       canonicalPathOfRoot: string,
@@ -558,7 +597,11 @@ export default class TreeFS implements MutableFileSystem {
   ): Iterable<Path> {
     const pathSep = opts.alwaysYieldPosix ? '/' : path.sep;
     const prefixWithSep = pathPrefix === '' ? pathPrefix : pathPrefix + pathSep;
-    for (const [name, node] of rootNode ?? this.#rootNode) {
+    for (const [name, node] of this.#directoryNodeIterator(
+      iterationRootNode,
+      iterationRootParentNode,
+      ancestorOfRootIdx,
+    )) {
       if (opts.subtreeOnly && name === '..') {
         continue;
       }
@@ -608,6 +651,8 @@ export default class TreeFS implements MutableFileSystem {
             // the path where we found the symlink as a prefix.
             yield* this._pathIterator(
               target,
+              resolved.parentNode,
+              resolved.ancestorOfRootIdx,
               opts,
               nodePath,
               new Set([...followedLinks, node]),
@@ -615,7 +660,16 @@ export default class TreeFS implements MutableFileSystem {
           }
         }
       } else if (opts.recursive) {
-        yield* this._pathIterator(node, opts, nodePath, followedLinks);
+        yield* this._pathIterator(
+          node,
+          iterationRootParentNode,
+          ancestorOfRootIdx != null && ancestorOfRootIdx > 1
+            ? ancestorOfRootIdx - 1
+            : null,
+          opts,
+          nodePath,
+          followedLinks,
+        );
       }
     }
   }

package/src/watchers/RecrawlWarning.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 class RecrawlWarning {
   static RECRAWL_WARNINGS = [];
   static REGEXP =
-    /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/;
+    /Recrawled this watch (\d+) times?, most recently because:\n([^:]+)/;
   constructor(root, count) {
     this.root = root;
     this.count = count;

package/src/watchers/RecrawlWarning.js.flow

@@ -19,7 +19,7 @@
 export default class RecrawlWarning {
   static RECRAWL_WARNINGS: Array<RecrawlWarning> = [];
   static REGEXP: RegExp =
-    /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/;
+    /Recrawled this watch (\d+) times?, most recently because:\n([^:]+)/;
 
   root: string;
   count: number;