fs: keep lexical realpath semantics on Windows

Windows applies `..` lexically, both in the path being opened and in
symlink targets, so `fs.realpathSync.native()` resolves `link\..` to
the directory holding the link. Resolving the link first made the JS
implementation disagree with the operating system there.

Only keep `.` and `..` during the walk on POSIX, and normalize the
input and link targets up front on Windows as before. Skip the new
test on Windows, where `d -> c\..\d` points at itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Jason Zhang <xzha4350@gmail.com>

Author: jazelly

lib/fs.js

@@ -3339,18 +3339,23 @@ if (isWindows) {
   };
 }
 
-function toAbsolutePathPreservingDots(p) {
-  if (!pathModule.isAbsolute(p)) {
-    const root = splitRoot(p);
-    if (isWindows && root.length === 2) {
-      return `${pathModule.resolve(root)}${pathModule.sep}${StringPrototypeSlice(p, root.length)}`;
-    }
-    return `${pathModule.resolve()}${pathModule.sep}${p}`;
-  }
-  if (isWindows && splitRoot(p).length === 1) {
-    return `${pathModule.parse(pathModule.resolve()).root}${StringPrototypeSlice(p, 1)}`;
-  }
-  return p;
+// realpath(3) applies `..` to the resolved parent, so on POSIX `.` and `..`
+// are kept in the path while walking it. Windows applies `..` lexically, both
+// in the path being opened and in symlink targets, so the path and the link
+// targets are normalized up front there, matching `fs.realpathSync.native()`.
+function toRealpathInput(p) {
+  if (isWindows) return pathModule.resolve(p);
+  return pathModule.isAbsolute(p) ? p : `${pathModule.resolve()}/${p}`;
+}
+
+function joinRealpathLink(previous, linkTarget) {
+  if (isWindows) return pathModule.resolve(previous, linkTarget);
+  return pathModule.isAbsolute(linkTarget) ? linkTarget : `${previous}${linkTarget}`;
+}
+
+function joinRealpathRemainder(resolvedLink, remainder) {
+  if (isWindows) return pathModule.resolve(resolvedLink, remainder);
+  return remainder.length === 0 ? resolvedLink : `${resolvedLink}/${remainder}`;
 }
 
 /**
@@ -3371,7 +3376,7 @@ function realpathSync(p, options) {
     p += '';
   }
   validatePath(p);
-  p = toAbsolutePathPreservingDots(p);
+  p = toRealpathInput(p);
 
   // Check the resolved input path up front so that the lstat walk below cannot
   // be used to probe the existence of paths outside the granted set.
@@ -3501,30 +3506,18 @@ function realpathSync(p, options) {
           isFileType(targetStats, S_IFSOCK);
         linkTarget = binding.readlink(base, undefined);
       }
-      const linkRoot = splitRoot(linkTarget);
-      if (pathModule.isAbsolute(linkTarget)) {
-        resolvedLink = isWindows && linkRoot.length === 1 ?
-          pathModule.resolve(previous, linkRoot) +
-            StringPrototypeSlice(linkTarget, linkRoot.length) :
-          linkTarget;
-      } else if (isWindows && linkRoot.length === 2) {
-        resolvedLink = pathModule.resolve(linkRoot) +
-          pathModule.sep + StringPrototypeSlice(linkTarget, linkRoot.length);
-      } else {
-        resolvedLink = `${previous}${linkTarget}`;
-      }
+      resolvedLink = joinRealpathLink(previous, linkTarget);
 
-      if (StringPrototypeIndexOf(linkTarget, '..') === -1) {
+      // On POSIX, a target containing `..` resolves relative to the path
+      // walked before it, so it cannot be cached by the link alone.
+      if (isWindows || StringPrototypeIndexOf(linkTarget, '..') === -1) {
         cache?.set(base, pathModule.resolve(resolvedLink));
       }
       if (!isWindows) seenLinks.set(id, linkTarget);
     }
 
     // Resolve the link, then start over
-    const remainder = StringPrototypeSlice(p, pos);
-    p = remainder.length === 0 ?
-      resolvedLink :
-      `${resolvedLink}${pathModule.sep}${remainder}`;
+    p = joinRealpathRemainder(resolvedLink, StringPrototypeSlice(p, pos));
 
     // Skip over roots
     current = base = splitRoot(p);
@@ -3594,7 +3587,7 @@ function realpath(p, options, callback) {
     p += '';
   }
   validatePath(p);
-  p = toAbsolutePathPreservingDots(p);
+  p = toRealpathInput(p);
 
   const seenLinks = new SafeMap();
   const knownHard = new SafeSet();
@@ -3712,28 +3705,12 @@ function realpath(p, options, callback) {
   function gotTarget(err, target) {
     if (err) return callback(err);
 
-    const linkRoot = splitRoot(target);
-    let resolvedLink;
-    if (pathModule.isAbsolute(target)) {
-      resolvedLink = isWindows && linkRoot.length === 1 ?
-        pathModule.resolve(previous, linkRoot) +
-          StringPrototypeSlice(target, linkRoot.length) :
-        target;
-    } else if (isWindows && linkRoot.length === 2) {
-      resolvedLink = pathModule.resolve(linkRoot) +
-        pathModule.sep + StringPrototypeSlice(target, linkRoot.length);
-    } else {
-      resolvedLink = `${previous}${target}`;
-    }
-    gotResolvedLink(resolvedLink);
+    gotResolvedLink(joinRealpathLink(previous, target));
   }
 
   function gotResolvedLink(resolvedLink) {
     // Resolve the link, then start over
-    const remainder = StringPrototypeSlice(p, pos);
-    p = remainder.length === 0 ?
-      resolvedLink :
-      `${resolvedLink}${pathModule.sep}${remainder}`;
+    p = joinRealpathRemainder(resolvedLink, StringPrototypeSlice(p, pos));
     current = base = splitRoot(p);
     pos = current.length;
 

test/parallel/test-fs-realpath-symlink-dot-dot.js

@@ -19,6 +19,10 @@ if (process.argv[2] === 'child') {
     process.stdout.write(fs.realpathSync(process.argv[3]));
   }
 } else {
+  // Windows applies `..` in symlink targets lexically, so `d -> c\..\d` points
+  // at itself there and the walk fails with ELOOP, like the operating system.
+  if (common.isWindows)
+    common.skip('symlink targets are normalized lexically on Windows');
   if (!common.canCreateSymLink())
     common.skip('insufficient privileges');