fs: fix glob early return skipping sibling entries

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.

lib/internal/fs/glob.js

@@ -435,9 +435,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);
@@ -645,9 +642,6 @@ class Glob {
  const nSymlinks = new SafeSet();
  for (const index of pattern.indexes) {
  // For each child, check potential patterns
- if (this.#cache.seen(entryPath, pattern, index) || this.#cache.seen(entryPath, pattern, index + 1)) {
- return;
- }
  const current = pattern.at(index);
  const nextIndex = index + 1;
  const next = pattern.at(nextIndex);

test/parallel/test-fs-glob.mjs

@@ -1,5 +1,6 @@
 import * as common from '../common/index.mjs';
 import tmpdir from '../common/tmpdir.js';
+import { spawnSync } from 'node:child_process';
 import { resolve, dirname, sep, relative, join, isAbsolute } from 'node:path';
 import { mkdir, writeFile, symlink, glob as asyncGlob } from 'node:fs/promises';
 import { glob, globSync, Dirent, chmodSync, writeFileSync, rmSync } from 'node:fs';
@@ -377,6 +378,76 @@ describe('fsPromises.glob - with file: URL as cwd', function() {
  }
 });
 
+test('glob handles seen children without aborting sibling processing', () => {
+ const script = `
+ const assert = require('node:assert');
+ const fs = require('node:fs');
+ const fsPromises = require('node:fs/promises');
+ const os = require('node:os');
+ const path = require('node:path');
+
+ const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-seen-'));
+ const a = path.join(cwd, 'a');
+ fs.mkdirSync(path.join(a, 'b', 'c', 'd'), { recursive: true });
+ fs.mkdirSync(path.join(a, 'c', 'd', 'c'), { recursive: true });
+ fs.writeFileSync(path.join(a, 'x'), '');
+ fs.writeFileSync(path.join(a, 'z'), '');
+
+ const originalReaddirSync = fs.readdirSync;
+ const originalReaddir = fsPromises.readdir;
+
+ const reorder = (target, entries) => {
+ if (!Array.isArray(entries)) return entries;
+ if (target === a) {
+ const names = ['c', 'b', 'x', 'z'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ if (target === path.join(a, 'c', 'd')) {
+ const names = ['c'];
+ return names.map((name) => entries.find((entry) => entry.name === name)).filter(Boolean);
+ }
+ return entries;
+ };
+
+ fs.readdirSync = function(target, options) {
+ return reorder(target, originalReaddirSync.call(this, target, options));
+ };
+ fsPromises.readdir = async function(target, options) {
+ return reorder(target, await originalReaddir.call(this, target, options));
+ };
+
+ const { Glob } = require('internal/fs/glob');
+ const expected = ['a/b', 'a/c', 'a/x', 'a/z'];
+
+ (async () => {
+ const syncResults = new Glob('a/**/../*', { cwd }).globSync().sort();
+ for (const item of expected) {
+ assert.ok(syncResults.includes(item), \`missing \${item} from \${syncResults}\`);
+ }
+
+ const asyncResults = [];
+ for await (const item of new Glob('a/**/../*', { cwd }).glob()) asyncResults.push(item);
+ asyncResults.sort();
+ for (const item of expected) {
+ assert.ok(asyncResults.includes(item), \`missing \${item} from \${asyncResults}\`);
+ }
+
+ fs.rmSync(cwd, { recursive: true, force: true });
+ })().catch((err) => {
+ console.error(err);
+ fs.rmSync(cwd, { recursive: true, force: true });
+ process.exitCode = 1;
+ });
+ `;
+
+ const child = spawnSync(process.execPath, ['--expose-internals', '-e', script], {
+ cwd: fixtureDir,
+ encoding: 'utf8',
+ });
+
+ assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+});
+
 const normalizeDirent = (dirent) => relative(fixtureDir, join(dirent.parentPath, dirent.name));
 // The call to `join()` with only one argument is important, as
 // it ensures that the proper path seperators are applied.