vfs: fix lint errors

Fixes the JS lint warnings on the VFS subsystem and tests:
primordial alphabetical ordering, em-dash → hyphen, error-codes
multiline destructuring, removal of unused JSDoc @returns, and the
test-side mustSucceed / async-iife-no-unused-result rules.

Assisted-by: Claude-Opus4.7

Author: mcollina

lib/internal/vfs/dir.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const {
-  SymbolAsyncIterator,
   SymbolAsyncDispose,
+  SymbolAsyncIterator,
   SymbolDispose,
 } = primordials;
 

lib/internal/vfs/file_handle.js

@@ -236,31 +236,31 @@ class VirtualFileHandle {
   }
 
   /**
-   * No-op chmod — VFS files don't have real permissions.
+   * No-op chmod - VFS files don't have real permissions.
    * @returns {Promise<void>}
    */
   async chmod() {}
 
   /**
-   * No-op chown — VFS files don't have real ownership.
+   * No-op chown - VFS files don't have real ownership.
    * @returns {Promise<void>}
    */
   async chown() {}
 
   /**
-   * No-op utimes — timestamps are handled by the provider.
+   * No-op utimes - timestamps are handled by the provider.
    * @returns {Promise<void>}
    */
   async utimes() {}
 
   /**
-   * No-op datasync — VFS is in-memory.
+   * No-op datasync - VFS is in-memory.
    * @returns {Promise<void>}
    */
   async datasync() {}
 
   /**
-   * No-op sync — VFS is in-memory.
+   * No-op sync - VFS is in-memory.
    * @returns {Promise<void>}
    */
   async sync() {}
@@ -316,30 +316,18 @@ class VirtualFileHandle {
     await this.write(buffer, 0, buffer.length, null);
   }
 
-  /**
-   * @returns {Promise<ReadableStream>}
-   */
   readableWebStream() {
     throw new ERR_METHOD_NOT_IMPLEMENTED('readableWebStream');
   }
 
-  /**
-   * @returns {AsyncIterable}
-   */
   readLines() {
     throw new ERR_METHOD_NOT_IMPLEMENTED('readLines');
   }
 
-  /**
-   * @returns {ReadStream}
-   */
   createReadStream() {
     throw new ERR_METHOD_NOT_IMPLEMENTED('createReadStream');
   }
 
-  /**
-   * @returns {WriteStream}
-   */
   createWriteStream() {
     throw new ERR_METHOD_NOT_IMPLEMENTED('createWriteStream');
   }

lib/internal/vfs/file_system.js

@@ -36,7 +36,7 @@ class VirtualFileSystem {
   /**
    * @param {VirtualProvider|object} [providerOrOptions] The provider to use, or options
    * @param {object} [options] Configuration options
-   * @param {boolean} [options.emitExperimentalWarning] Whether to emit the public VFS experimental warning (default: true)
+   * @param {boolean} [options.emitExperimentalWarning] Emit the experimental warning (default: true)
    */
   constructor(providerOrOptions, options = kEmptyObject) {
 

lib/internal/vfs/providers/real.js

@@ -420,7 +420,7 @@ class RealFSProvider extends VirtualProvider {
     if (StringPrototypeStartsWith(resolved, rootWithSep)) {
       return '/' + resolved.slice(rootWithSep.length).replace(/\\/g, '/');
     }
-    // Path escaped root via symlink — deny access
+    // Path escaped root via symlink - deny access
     throw createEACCES('realpath', vfsPath);
   }
 
@@ -435,7 +435,7 @@ class RealFSProvider extends VirtualProvider {
     if (StringPrototypeStartsWith(resolved, rootWithSep)) {
       return '/' + resolved.slice(rootWithSep.length).replace(/\\/g, '/');
     }
-    // Path escaped root via symlink — deny access
+    // Path escaped root via symlink - deny access
     throw createEACCES('realpath', vfsPath);
   }
 

lib/internal/vfs/streams.js

@@ -10,7 +10,9 @@ const { createEBADF } = require('internal/vfs/errors');
 const { getLazy, kEmptyObject } = require('internal/util');
 const { validateInteger } = require('internal/validators');
 const {
-  codes: { ERR_OUT_OF_RANGE },
+  codes: {
+    ERR_OUT_OF_RANGE,
+  },
 } = require('internal/errors');
 
 // Lazy-load fd module to avoid circular dependency

lib/internal/vfs/watcher.js

@@ -587,7 +587,7 @@ class VFSWatchAsyncIterable {
    * @param {object} [options] Options
    */
   constructor(provider, path, options = {}) {
-    // Strip signal from options passed to VFSWatcher — we handle abort
+    // Strip signal from options passed to VFSWatcher - we handle abort
     // at the iterable level to reject pending next() with AbortError
     // instead of resolving with done:true via the 'close' event.
     const signal = options.signal;
@@ -615,7 +615,7 @@ class VFSWatchAsyncIterable {
       }
     });
 
-    // Handle abort signal — reject pending next() with AbortError
+    // Handle abort signal - reject pending next() with AbortError
     if (signal) {
       const onAbort = () => {
         this.#closed = true;

test/parallel/test-vfs-access-modes.js

@@ -37,5 +37,5 @@ assert.rejects(myVfs.promises.access('/no-x.txt', X_OK),
 // F_OK (mode 0) is an existence-only check and does not require permission
 myVfs.accessSync('/no-r.txt', 0);
 
-// mode passed as null also exits early (existence-only)
+// Mode passed as null also exits early (existence-only)
 myVfs.accessSync('/no-r.txt', null);

test/parallel/test-vfs-callback-api.js

@@ -13,116 +13,93 @@ myVfs.writeFileSync('/dir/file.txt', 'hello');
 myVfs.writeFileSync('/dir/other.txt', 'other');
 
 // readFile (no options)
-myVfs.readFile('/dir/file.txt', common.mustCall((err, data) => {
-  assert.ifError(err);
+myVfs.readFile('/dir/file.txt', common.mustSucceed((data) => {
   assert.ok(Buffer.isBuffer(data));
 }));
 
 // writeFile + appendFile (no options) -> readFile
-myVfs.writeFile('/cb-write.txt', 'a', common.mustCall((err) => {
-  assert.ifError(err);
-  myVfs.readFile('/cb-write.txt', 'utf8', common.mustCall((err2, data) => {
-    assert.ifError(err2);
+myVfs.writeFile('/cb-write.txt', 'a', common.mustSucceed(() => {
+  myVfs.readFile('/cb-write.txt', 'utf8', common.mustSucceed((data) => {
     assert.strictEqual(data, 'a');
   }));
 }));
 
 // stat / lstat (with and without options)
-myVfs.stat('/dir/file.txt', common.mustCall((err, st) => {
-  assert.ifError(err);
+myVfs.stat('/dir/file.txt', common.mustSucceed((st) => {
   assert.strictEqual(st.size, 5);
 }));
-myVfs.stat('/dir/file.txt', { bigint: true }, common.mustCall((err, st) => {
-  assert.ifError(err);
+myVfs.stat('/dir/file.txt', { bigint: true }, common.mustSucceed((st) => {
   assert.strictEqual(typeof st.size, 'bigint');
 }));
-myVfs.lstat('/dir/file.txt', common.mustCall((err, st) => {
-  assert.ifError(err);
+myVfs.lstat('/dir/file.txt', common.mustSucceed((st) => {
   assert.ok(st.isFile());
 }));
 
 // readdir
-myVfs.readdir('/dir', common.mustCall((err, names) => {
-  assert.ifError(err);
+myVfs.readdir('/dir', common.mustSucceed((names) => {
   assert.ok(names.includes('file.txt'));
 }));
 
 // realpath
-myVfs.realpath('/dir/file.txt', common.mustCall((err, p) => {
-  assert.ifError(err);
+myVfs.realpath('/dir/file.txt', common.mustSucceed((p) => {
   assert.strictEqual(p, '/dir/file.txt');
 }));
 
 // access (with and without mode)
-myVfs.access('/dir/file.txt', common.mustCall((err) => {
-  assert.ifError(err);
-}));
-myVfs.access('/dir/file.txt', 0, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+myVfs.access('/dir/file.txt', common.mustSucceed());
+myVfs.access('/dir/file.txt', 0, common.mustSucceed());
 myVfs.access('/missing.txt', common.mustCall((err) => {
   assert.strictEqual(err.code, 'ENOENT');
 }));
 
 // open / read / write / close cb chain
-myVfs.open('/dir/file.txt', common.mustCall((err, fd) => {
-  assert.ifError(err);
+myVfs.open('/dir/file.txt', common.mustSucceed((fd) => {
   const buf = Buffer.alloc(5);
-  myVfs.read(fd, buf, 0, 5, 0, common.mustCall((err2, bytesRead) => {
-    assert.ifError(err2);
+  myVfs.read(fd, buf, 0, 5, 0, common.mustSucceed((bytesRead) => {
     assert.strictEqual(bytesRead, 5);
     assert.strictEqual(buf.toString(), 'hello');
-    myVfs.close(fd, common.mustCall((err3) => assert.ifError(err3)));
+    myVfs.close(fd, common.mustSucceed());
   }));
 }));
 
-// open with explicit flags / mode
-myVfs.open('/dir/new1.txt', 'w', common.mustCall((err, fd) => {
-  assert.ifError(err);
+// Open with explicit flags / mode
+myVfs.open('/dir/new1.txt', 'w', common.mustSucceed((fd) => {
   const buf = Buffer.from('xyz');
-  myVfs.write(fd, buf, 0, 3, 0, common.mustCall((err2, bytesWritten) => {
-    assert.ifError(err2);
+  myVfs.write(fd, buf, 0, 3, 0, common.mustSucceed((bytesWritten) => {
     assert.strictEqual(bytesWritten, 3);
-    myVfs.fstat(fd, common.mustCall((err3, st) => {
-      assert.ifError(err3);
+    myVfs.fstat(fd, common.mustSucceed((st) => {
       assert.strictEqual(st.size, 3);
-      myVfs.ftruncate(fd, 1, common.mustCall((err5) => {
-        assert.ifError(err5);
+      myVfs.ftruncate(fd, 1, common.mustSucceed(() => {
         myVfs.close(fd, common.mustCall());
       }));
     }));
   }));
 }));
 
-// open with explicit flags, no mode arg form
-myVfs.open('/dir/new2.txt', 'w', 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
+// Open with explicit flags, no mode arg form
+myVfs.open('/dir/new2.txt', 'w', 0o644, common.mustSucceed((fd) => {
   myVfs.close(fd, common.mustCall());
 }));
 
 // rm callback (file)
 myVfs.writeFileSync('/cb-rm.txt', 'x');
-myVfs.rm('/cb-rm.txt', common.mustCall((err) => {
-  assert.ifError(err);
+myVfs.rm('/cb-rm.txt', common.mustSucceed(() => {
   assert.strictEqual(myVfs.existsSync('/cb-rm.txt'), false);
 }));
 
-// rm callback with options (recursive)
+// Rm callback with options (recursive)
 myVfs.mkdirSync('/cb-rm-dir/sub', { recursive: true });
 myVfs.writeFileSync('/cb-rm-dir/sub/f.txt', 'x');
-myVfs.rm('/cb-rm-dir', { recursive: true }, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+myVfs.rm('/cb-rm-dir', { recursive: true }, common.mustSucceed());
 
-// rm callback failure path
+// Rm callback failure path
 myVfs.rm('/missing-rm', common.mustCall((err) => {
   assert.strictEqual(err.code, 'ENOENT');
 }));
 
 // truncate / ftruncate cb
 myVfs.writeFileSync('/cb-tr.txt', 'abcdef');
-myVfs.truncate('/cb-tr.txt', 3, common.mustCall((err) => {
-  assert.ifError(err);
+myVfs.truncate('/cb-tr.txt', 3, common.mustSucceed(() => {
   assert.strictEqual(myVfs.readFileSync('/cb-tr.txt', 'utf8'), 'abc');
 }));
 myVfs.truncate('/missing-tr.txt', common.mustCall((err) => {
@@ -134,26 +111,21 @@ myVfs.ftruncate(0xFFFFFFF /* invalid fd */, common.mustCall((err) => {
 
 // link cb
 myVfs.writeFileSync('/cb-link-src.txt', 'x');
-myVfs.link('/cb-link-src.txt', '/cb-link-dst.txt', common.mustCall((err) => {
-  assert.ifError(err);
-}));
+myVfs.link('/cb-link-src.txt', '/cb-link-dst.txt', common.mustSucceed());
 myVfs.link('/missing-src.txt', '/cb-bad-link.txt', common.mustCall((err) => {
   assert.ok(err);
 }));
 
 // mkdtemp cb
-myVfs.mkdtemp('/tmp-', common.mustCall((err, p) => {
-  assert.ifError(err);
+myVfs.mkdtemp('/tmp-', common.mustSucceed((p) => {
   assert.ok(p.startsWith('/tmp-'));
 }));
-myVfs.mkdtemp('/tmp-', {}, common.mustCall((err, p) => {
-  assert.ifError(err);
+myVfs.mkdtemp('/tmp-', {}, common.mustSucceed((p) => {
   assert.ok(p.startsWith('/tmp-'));
 }));
 
 // opendir cb
-myVfs.opendir('/dir', common.mustCall((err, dir) => {
-  assert.ifError(err);
+myVfs.opendir('/dir', common.mustSucceed((dir) => {
   assert.strictEqual(dir.path, '/dir');
   dir.closeSync();
 }));
@@ -177,7 +149,6 @@ myVfs.fstat(0xFFFFFFF, common.mustCall((err) => {
 
 // readlink cb
 myVfs.symlinkSync('/dir/file.txt', '/cb-link');
-myVfs.readlink('/cb-link', common.mustCall((err, target) => {
-  assert.ifError(err);
+myVfs.readlink('/cb-link', common.mustSucceed((target) => {
   assert.strictEqual(target, '/dir/file.txt');
 }));

test/parallel/test-vfs-copyfile-mode.js

@@ -5,7 +5,7 @@
 // - COPYFILE_EXCL throws when destination exists
 // - Without COPYFILE_EXCL, copy overwrites destination
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const vfs = require('node:vfs');
@@ -49,4 +49,4 @@ const { COPYFILE_EXCL } = fs.constants;
 
   await myVfs.promises.copyFile('/src.txt', '/dst.txt');
   assert.strictEqual(myVfs.readFileSync('/dst.txt', 'utf8'), 's');
-})();
+})().then(common.mustCall());