fs: remove race condition for recursive watch on Linux

lib/internal/fs/promises.js

@@ -1254,7 +1254,7 @@ async function* _watch(filename, options = kEmptyObject) {
     // e.g. Linux due to the limitations of inotify.
     if (options.recursive && !isOSX && !isWindows) {
       const watcher = new nonNativeWatcher.FSWatcher(options);
-      await watcher[kFSWatchStart](filename);
+      watcher[kFSWatchStart](filename);
       yield* watcher;
       return;
     }

lib/internal/fs/recursive_watch.js

@@ -1,10 +1,7 @@
 'use strict';
 
 const {
-  ArrayPrototypePush,
-  SafePromiseAllReturnVoid,
   Promise,
-  PromisePrototypeThen,
   SafeMap,
   SafeSet,
   StringPrototypeStartsWith,
@@ -31,42 +28,13 @@ const {
 } = require('path');
 
 let internalSync;
-let internalPromises;
-
-function lazyLoadFsPromises() {
-  internalPromises ??= require('fs/promises');
-  return internalPromises;
-}
 
 function lazyLoadFsSync() {
   internalSync ??= require('fs');
   return internalSync;
 }
-let kResistStopPropagation;
-
-async function traverse(dir, files = new SafeMap(), symbolicLinks = new SafeSet()) {
-  const { opendir } = lazyLoadFsPromises();
-
-  const filenames = await opendir(dir);
-  const subdirectories = [];
-
-  for await (const file of filenames) {
-    const f = pathJoin(dir, file.name);
-
-    files.set(f, file);
 
-    // Do not follow symbolic links
-    if (file.isSymbolicLink()) {
-      symbolicLinks.add(f);
-    } else if (file.isDirectory()) {
-      ArrayPrototypePush(subdirectories, traverse(f, files));
-    }
-  }
-
-  await SafePromiseAllReturnVoid(subdirectories);
-
-  return files;
-}
+let kResistStopPropagation;
 
 class FSWatcher extends EventEmitter {
   #options = null;
@@ -135,13 +103,15 @@ class FSWatcher extends EventEmitter {
     }
   }
 
-  async #watchFolder(folder) {
-    const { opendir } = lazyLoadFsPromises();
+  #watchFolder(folder) {
+    const { readdirSync } = lazyLoadFsSync();
 
     try {
-      const files = await opendir(folder);
+      const files = readdirSync(folder, {
+        withFileTypes: true,
+      });
 
-      for await (const file of files) {
+      for (const file of files) {
         if (this.#closed) {
           break;
         }
@@ -159,7 +129,7 @@ class FSWatcher extends EventEmitter {
           if (file.isFile()) {
             this.#watchFile(f);
           } else if (file.isDirectory() && !file.isSymbolicLink()) {
-            await this.#watchFolder(f);
+            this.#watchFolder(f);
           }
         }
       }
@@ -220,14 +190,10 @@ class FSWatcher extends EventEmitter {
       if (file.isDirectory()) {
         this.#files.set(filename, file);
 
-        PromisePrototypeThen(
-          traverse(filename, this.#files, this.#symbolicFiles),
-          () => {
-            for (const f of this.#files.keys()) {
-              this.#watchFile(f);
-            }
-          },
-        );
+        this.#watchFolder(filename);
+        for (const f of this.#files.keys()) {
+          this.#watchFile(f);
+        }
       } else {
         this.#watchFile(filename);
       }

test/parallel/test-fs-recursive-sync-write.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const { mkdtempSync, watch, writeFileSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const tmpDir = mkdtempSync(join(tmpdir(), 'repro-test-'));
+const filename = join(tmpDir, 'test.file');
+const assert = require('assert');
+
+const keepalive = setTimeout(() => {
+  throw new Error('timed out');
+}, common.platformTimeout(30_0000));
+
+const watcher = watch(tmpDir, { recursive: true }, common.mustCall((eventType, _filename) => {
+  clearTimeout(keepalive);
+  watcher.close();
+  assert.strictEqual(eventType, 'rename');
+  assert.strictEqual(join(tmpDir, _filename), filename);
+  console.log(eventType, filename);
+}));
+
+writeFileSync(filename, 'foobar2');