fs: add to Dir support for explicit resource management

Author: aduh95

doc/api/fs.md

@@ -6740,6 +6740,26 @@ provided by the operating system's underlying directory mechanisms.
 Entries added or removed while iterating over the directory might not be
 included in the iteration results.
 
+#### `dir[Symbol.asyncDispose]()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+An alias for `dir.close()`.
+
+#### `dir[Symbol.Dispose]()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+An alias for `dir.closeSync()`.
+
 ### Class: `fs.Dirent`
 
 <!-- YAML

lib/internal/fs/dir.js

@@ -4,9 +4,11 @@ const {
   ArrayPrototypePush,
   ArrayPrototypeShift,
   FunctionPrototypeBind,
-  ObjectDefineProperty,
+  ObjectDefineProperties,
   PromiseReject,
+  SymbolAsyncDispose,
   SymbolAsyncIterator,
+  SymbolDispose,
 } = primordials;
 
 const pathModule = require('path');
@@ -94,7 +96,7 @@ class Dir {
   }
 
   read(callback) {
-    return this.#readImpl(true, callback);
+    return arguments.length === 0 ? this.#readPromisified() : this.#readImpl(true, callback);
   }
 
   #readImpl(maybeSync, callback) {
@@ -293,13 +295,27 @@ class Dir {
   }
 }
 
-ObjectDefineProperty(Dir.prototype, SymbolAsyncIterator, {
-  __proto__: null,
-  value: Dir.prototype.entries,
+const nonEnumerableDescriptor = {
   enumerable: false,
   writable: true,
   configurable: true,
-});
+};
+ObjectDefineProperties(Dir.prototype, { __proto__: null,
+                                        [SymbolDispose]: {
+                                          __proto__: null,
+                                          ...nonEnumerableDescriptor,
+                                          value: Dir.prototype.closeSync,
+                                        },
+                                        [SymbolAsyncDispose]: {
+                                          __proto__: null,
+                                          ...nonEnumerableDescriptor,
+                                          value: Dir.prototype.close,
+                                        },
+                                        [SymbolAsyncIterator]: {
+                                          __proto__: null,
+                                          ...nonEnumerableDescriptor,
+                                          value: Dir.prototype.entries,
+                                        } });
 
 function opendir(path, options, callback) {
   callback = typeof options === 'function' ? options : callback;

test/parallel/test-fs-promises-file-handle-dispose.js

@@ -1,12 +1,22 @@
 'use strict';
 
 const common = require('../common');
-const { promises: fs } = require('fs');
+const assert = require('assert');
+const { opendirSync, promises: fs } = require('fs');
 
-async function doOpen() {
+async function explicitCall() {
   const fh = await fs.open(__filename);
   fh.on('close', common.mustCall());
   await fh[Symbol.asyncDispose]();
+
+  const dh = await fs.opendir(__dirname);
+  await dh[Symbol.asyncDispose]();
+  await assert.rejects(dh.read(), { code: 'ERR_DIR_CLOSED' });
+
+  const dhSync = opendirSync(__dirname);
+  dhSync[Symbol.dispose]();
+  assert.throws(() => dhSync.readSync(), { code: 'ERR_DIR_CLOSED' });
 }
 
-doOpen().then(common.mustCall());
+explicitCall().then(common.mustCall());
+// TODO(aduh95): add test for implicit calls, with `await using` syntax.