vfs: address review feedback on path utilities and providers

- Remove redundant #getBaseName/#getParentPath from MemoryProvider,
  use pathPosix.basename/dirname directly
- Remove redundant getBaseName/getParentPath/splitPath from router.js,
  keep only functions with non-trivial VFS-specific logic
- Convert RealFSProvider constant getters (readonly, supportsSymlinks)
  to readonly properties via ObjectDefineProperty
- Fix joinVFSPath/normalizeVFSPath to detect Windows drive-letter paths
  by checking for ':' at position 1 instead of checking for leading '/',
  so bare '/' is always treated as a POSIX VFS path
- Update test-vfs-internals.js to match router.js export changes

Author: mcollina

lib/internal/vfs/file_system.js

@@ -18,31 +18,39 @@ const pathPosix = path.posix;
 const { isAbsolute, resolve: resolvePath } = path;
 
 /**
- * Normalizes a VFS path. Uses POSIX normalization for Unix-style paths (starting with /)
- * and platform normalization for Windows drive letter paths.
+ * Normalizes a VFS path. Uses POSIX normalization for all paths except
+ * Windows drive-letter paths (e.g. C:\), which use platform normalization.
+ *
+ * On Windows, a bare '/' prefix is treated as a POSIX VFS path, not as the
+ * current-drive root.
  * @param {string} inputPath The path to normalize
  * @returns {string} The normalized path
  */
 function normalizeVFSPath(inputPath) {
-  // If path starts with / (Unix-style), use posix normalization to preserve forward slashes
-  if (inputPath.startsWith('/')) {
-    return pathPosix.normalize(inputPath);
+  if (inputPath.length >= 3 && inputPath[1] === ':') {
+    // Windows drive-letter path (e.g. C:\app)
+    return path.normalize(inputPath);
   }
-  // Otherwise use platform normalization (for Windows drive letters like C:\)
-  return path.normalize(inputPath);
+  return pathPosix.normalize(inputPath);
 }
 
 /**
- * Joins VFS paths. Uses POSIX join for Unix-style base paths.
+ * Joins VFS paths. Uses POSIX join for Unix-style base paths and platform
+ * join for Windows drive-letter paths (e.g. C:\).
+ *
+ * On Windows, a bare '/' prefix is treated as a POSIX VFS path, not as the
+ * current-drive root.  Only explicit drive-letter paths like 'C:\app' use
+ * platform path.join.
  * @param {string} base The base path
  * @param {string} part The path part to join
  * @returns {string} The joined path
  */
 function joinVFSPath(base, part) {
-  if (base.startsWith('/')) {
-    return pathPosix.join(base, part);
+  if (base.length >= 3 && base[1] === ':') {
+    // Windows drive-letter path (e.g. C:\app)
+    return path.join(base, part);
   }
-  return path.join(base, part);
+  return pathPosix.join(base, part);
 }
 const {
   isUnderMountPoint,

lib/internal/vfs/providers/memory.js

@@ -195,26 +195,6 @@ class MemoryProvider extends VirtualProvider {
     return path.slice(1).split('/');
   }
 
-  /**
-   * Gets the parent path.
-   * @param {string} path Normalized path
-   * @returns {string|null} Parent path or null for root
-   */
-  #getParentPath(path) {
-    if (path === '/') {
-      return null;
-    }
-    return pathPosix.dirname(path);
-  }
-
-  /**
-   * Gets the base name.
-   * @param {string} path Normalized path
-   * @returns {string} Base name
-   */
-  #getBaseName(path) {
-    return pathPosix.basename(path);
-  }
 
   /**
    * Resolves a symlink target to an absolute path.
@@ -227,7 +207,7 @@ class MemoryProvider extends VirtualProvider {
       return this.#normalizePath(target);
     }
     // Relative target: resolve against symlink's parent directory
-    const parentPath = this.#getParentPath(symlinkPath) || '/';
+    const parentPath = pathPosix.dirname(symlinkPath);
     return this.#normalizePath(pathPosix.join(parentPath, target));
   }
 
@@ -323,10 +303,10 @@ class MemoryProvider extends VirtualProvider {
    * @returns {MemoryEntry} The parent directory entry
    */
   #ensureParent(path, create, syscall) {
-    const parentPath = this.#getParentPath(path);
-    if (parentPath === null) {
+    if (path === '/') {
       return this[kRoot];
     }
+    const parentPath = pathPosix.dirname(path);
 
     const segments = this.#splitPath(parentPath);
     let current = this[kRoot];
@@ -458,7 +438,7 @@ class MemoryProvider extends VirtualProvider {
       if (err.code !== 'ENOENT' || !isCreate) throw err;
       // Create the file
       const parent = this.#ensureParent(normalized, true, 'open');
-      const name = this.#getBaseName(normalized);
+      const name = pathPosix.basename(normalized);
       entry = new MemoryEntry(TYPE_FILE, { mode });
       entry.content = Buffer.alloc(0);
       parent.children.set(name, entry);
@@ -570,7 +550,7 @@ class MemoryProvider extends VirtualProvider {
       }
     } else {
       const parent = this.#ensureParent(normalized, false, 'mkdir');
-      const name = this.#getBaseName(normalized);
+      const name = pathPosix.basename(normalized);
       const entry = new MemoryEntry(TYPE_DIR, { mode: options?.mode });
       entry.children = new SafeMap();
       parent.children.set(name, entry);
@@ -600,7 +580,7 @@ class MemoryProvider extends VirtualProvider {
     }
 
     const parent = this.#ensureParent(normalized, false, 'rmdir');
-    const name = this.#getBaseName(normalized);
+    const name = pathPosix.basename(normalized);
     parent.children.delete(name);
   }
 
@@ -621,7 +601,7 @@ class MemoryProvider extends VirtualProvider {
     }
 
     const parent = this.#ensureParent(normalized, false, 'unlink');
-    const name = this.#getBaseName(normalized);
+    const name = pathPosix.basename(normalized);
     parent.children.delete(name);
   }
 
@@ -642,12 +622,12 @@ class MemoryProvider extends VirtualProvider {
 
     // Remove from old location
     const oldParent = this.#ensureParent(normalizedOld, false, 'rename');
-    const oldName = this.#getBaseName(normalizedOld);
+    const oldName = pathPosix.basename(normalizedOld);
     oldParent.children.delete(oldName);
 
     // Add to new location
     const newParent = this.#ensureParent(normalizedNew, true, 'rename');
-    const newName = this.#getBaseName(normalizedNew);
+    const newName = pathPosix.basename(normalizedNew);
     newParent.children.set(newName, entry);
   }
 
@@ -684,7 +664,7 @@ class MemoryProvider extends VirtualProvider {
     }
 
     const parent = this.#ensureParent(normalized, true, 'symlink');
-    const name = this.#getBaseName(normalized);
+    const name = pathPosix.basename(normalized);
     const entry = new MemoryEntry(TYPE_SYMLINK);
     entry.target = target;
     parent.children.set(name, entry);

lib/internal/vfs/providers/real.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ObjectDefineProperty,
   Promise,
   StringPrototypeStartsWith,
 } = primordials;
@@ -172,6 +173,8 @@ class RealFSProvider extends VirtualProvider {
     }
     // Resolve to absolute path and normalize
     this.#rootPath = path.resolve(rootPath);
+    ObjectDefineProperty(this, 'readonly', { __proto__: null, value: false });
+    ObjectDefineProperty(this, 'supportsSymlinks', { __proto__: null, value: true });
   }
 
   /**
@@ -182,14 +185,6 @@ class RealFSProvider extends VirtualProvider {
     return this.#rootPath;
   }
 
-  get readonly() {
-    return false;
-  }
-
-  get supportsSymlinks() {
-    return true;
-  }
-
   /**
    * Resolves a VFS path to a real filesystem path.
    * Ensures the path doesn't escape the root directory.

lib/internal/vfs/router.js

@@ -2,47 +2,10 @@
 
 const {
   StringPrototypeSlice,
-  StringPrototypeSplit,
   StringPrototypeStartsWith,
 } = primordials;
 
-const { isAbsolute, posix: pathPosix } = require('path');
-
-/**
- * Splits a path into segments.
- * VFS paths are always normalized to use forward slashes.
- * @param {string} normalizedPath A normalized absolute path
- * @returns {string[]} Path segments
- */
-function splitPath(normalizedPath) {
-  if (normalizedPath === '/') {
-    return [];
-  }
-  // Remove leading slash and split by forward slash (VFS internal format)
-  return StringPrototypeSplit(StringPrototypeSlice(normalizedPath, 1), '/');
-}
-
-/**
- * Gets the parent path of a normalized path.
- * VFS paths are always normalized to use forward slashes.
- * @param {string} normalizedPath A normalized absolute path
- * @returns {string|null} The parent path, or null if at root
- */
-function getParentPath(normalizedPath) {
-  if (normalizedPath === '/') {
-    return null;
-  }
-  return pathPosix.dirname(normalizedPath);
-}
-
-/**
- * Gets the base name from a normalized path.
- * @param {string} normalizedPath A normalized absolute path
- * @returns {string} The base name
- */
-function getBaseName(normalizedPath) {
-  return pathPosix.basename(normalizedPath);
-}
+const { isAbsolute } = require('path');
 
 /**
  * Checks if a path is under a mount point.
@@ -84,9 +47,6 @@ function getRelativePath(normalizedPath, mountPoint) {
 }
 
 module.exports = {
-  splitPath,
-  getParentPath,
-  getBaseName,
   isUnderMountPoint,
   getRelativePath,
   isAbsolutePath: isAbsolute,

test/parallel/test-vfs-internals.js

@@ -8,31 +8,11 @@ const assert = require('assert');
 
 // === Router utility functions ===
 const {
-  splitPath,
-  getParentPath,
-  getBaseName,
   isUnderMountPoint,
   getRelativePath,
   isAbsolutePath,
 } = require('internal/vfs/router');
 
-// splitPath
-assert.deepStrictEqual(splitPath('/'), []);
-assert.deepStrictEqual(splitPath('/foo'), ['foo']);
-assert.deepStrictEqual(splitPath('/foo/bar'), ['foo', 'bar']);
-assert.deepStrictEqual(splitPath('/a/b/c/d'), ['a', 'b', 'c', 'd']);
-
-// getParentPath
-assert.strictEqual(getParentPath('/'), null);
-assert.strictEqual(getParentPath('/foo'), '/');
-assert.strictEqual(getParentPath('/foo/bar'), '/foo');
-assert.strictEqual(getParentPath('/a/b/c'), '/a/b');
-
-// getBaseName
-assert.strictEqual(getBaseName('/foo'), 'foo');
-assert.strictEqual(getBaseName('/foo/bar'), 'bar');
-assert.strictEqual(getBaseName('/a/b/c.txt'), 'c.txt');
-
 // isAbsolutePath
 assert.strictEqual(isAbsolutePath('/foo'), true);
 assert.strictEqual(isAbsolutePath('foo'), false);