fix(permission): do not reuse lstat across dot segments

A successful lstat of sub/dang was stored under path.resolve, so
sub/dang/. read back as that symlink. dangling follow then called
readlink on the dotted path and returned unresolvable instead of
sub/missing-target/missing. Relative keys that contain . or .. no
longer share the collapsed path. A failed lstat of the dotted form
still does not mark the symlink absent. Resolved paths are not
reused across calls.

Author: TheGreatAxios

src/permission/realpath-cache.test.ts

@@ -93,6 +93,24 @@ test("a failed dot lstat is not reused for the symlink it collapses onto", async
   }
 });
 
+test("a dot segment does not reuse the dangling symlink lstat", async () => {
+  scratch = await mkdtemp(join(tmpdir(), "corbits-realpath-dang-dot-"));
+  const sub = join(scratch, "sub");
+  await mkdir(sub);
+  await symlink("missing-target", join(sub, "dang"));
+  const previous = process.cwd();
+  process.chdir(scratch);
+  try {
+    const target = join(process.cwd(), "sub", "missing-target");
+    expect(realpathFollowingDangling("sub/dang/.")).toBe(target);
+    expect(realpathFollowingDangling("sub/dang/./missing")).toBe(
+      join(target, "missing"),
+    );
+  } finally {
+    process.chdir(previous);
+  }
+});
+
 test("a later check of the same path lstats and realpaths again", async () => {
   scratch = await mkdtemp(join(tmpdir(), "corbits-realpath-once-"));
   const ancestorA = join(scratch, "a");

src/permission/realpath-cache.ts

@@ -25,21 +25,24 @@ export function enterPathResolution<T>(fn: () => T): T {
   }
 }
 
-function cacheKey(path: string): string {
-  return isAbsolute(path) ? path : resolve(path);
-}
-
-// `path.resolve` drops `.` and `..`, so `sub/link/.` and `sub/link` share a key.
-// A failed lstat of the dotted path is not "absent" for the symlink it collapses
-// onto (`..` through a symlink is a different node than the lexical parent).
-function failureCollapsesOntoAnotherPath(path: string): boolean {
-  if (isAbsolute(path)) return false;
+function hasDotSegment(path: string): boolean {
   for (const segment of path.split(sep)) {
     if (segment === "." || segment === "..") return true;
   }
   return false;
 }
 
+function cacheKey(path: string): string {
+  // path.resolve drops `.` and `..`, so a successful lstat of `sub/dang` would
+  // be reused for `sub/dang/.`. That path is not the symlink: readlink of the
+  // dotted form throws, and a failed lstat of it must not be stored as absence
+  // of `sub/dang` either. Absolute paths are already uncollapsed.
+  if (!isAbsolute(path) && hasDotSegment(path)) {
+    return `${resolve(".")}${sep}${path}`;
+  }
+  return isAbsolute(path) ? path : resolve(path);
+}
+
 function errorCode(error: unknown): string | undefined {
   if (typeof error !== "object" || error === null || !("code" in error)) {
     return undefined;
@@ -58,12 +61,7 @@ function readLstat(path: string): LstatMemoEntry {
   } catch (error) {
     entry = { stats: undefined, code: errorCode(error) };
   }
-  if (
-    memo !== undefined &&
-    !(entry.stats === undefined && failureCollapsesOntoAnotherPath(path))
-  ) {
-    memo.set(key, entry);
-  }
+  memo?.set(key, entry);
   return entry;
 }