glob: honour trailing '/' as 'directories only' throughout scan()

src/glob/GlobWalker.rs

@@ -697,9 +697,14 @@
                 };
                 self.close_disallowing_cwd(fd);
                 let mode = stat_result.st_mode as u32;
-                let matches = (S::ISDIR(mode) && !self.walker.only_files)
-                    || S::ISREG(mode)
-                    || !self.walker.only_files;
+                let trailing_sep = self.walker.pattern_components[idx as usize].trailing_sep;
+                let matches = if trailing_sep {
+                    S::ISDIR(mode) && !self.walker.only_files
+                } else {
+                    (S::ISDIR(mode) && !self.walker.only_files)
+                        || S::ISREG(mode)
+                        || !self.walker.only_files
+                };
                 if matches {
                     if let Some(path) = self
                         .walker
@@ -1761,10 +1766,12 @@
 
         // Handle case b)
         if !is_last {
+            let next = next_pattern.unwrap();
             return pattern.syntax_hint == SyntaxHint::Double
                 && (component_idx + 1) as usize == self.pattern_components.len().saturating_sub(1)
-                && next_pattern.unwrap().syntax_hint != SyntaxHint::Double
-                && self.match_pattern_impl(next_pattern.unwrap(), entry_name);
+                && next.syntax_hint != SyntaxHint::Double
+                && !next.trailing_sep
+                && self.match_pattern_impl(next, entry_name);
         }
 
         // Handle case a)
@@ -2081,9 +2088,24 @@
             return None;
         }
 
+        // The final component of a pattern may carry its trailing `/` inside
+        // `len`. Classify the syntax hint on the same slice `pattern_slice()`
+        // returns (i.e. without that separator) so `**/` is recognized as a
+        // globstar and recurses like `**` during scan().
+        let last_idx = (component.start + component.len - 1) as usize;
+        if pattern[last_idx] == b'/' {
+            component.trailing_sep = true;
+        } else {
+            #[cfg(windows)]
+            {
+                component.trailing_sep = pattern[last_idx] == b'\\';
+            }
+        }
+        let effective_len = component.len - u32::from(component.trailing_sep);
+
         'out: {
             let comp_slice =
-                &pattern[component.start as usize..(component.start + component.len) as usize];
+                &pattern[component.start as usize..(component.start + effective_len) as usize];
             if comp_slice == b"." {
                 component.syntax_hint = SyntaxHint::Dot;
                 break 'out;
@@ -2098,7 +2120,7 @@
                 break 'out;
             }
 
-            match component.len {
+            match effective_len {
                 1 => {
                     if pattern[component.start as usize] == b'*' {
                         component.syntax_hint = SyntaxHint::Single;
@@ -2147,16 +2169,6 @@
             }
         }
 
-        let last_idx = (component.start + component.len).saturating_sub(1) as usize;
-        if pattern[last_idx] == b'/' {
-            component.trailing_sep = true;
-        } else {
-            #[cfg(windows)]
-            {
-                component.trailing_sep = pattern[last_idx] == b'\\';
-            }
-        }
-
         Some(component)
     }
 

test/js/bun/glob/scan.test.ts

@@ -637,6 +637,84 @@ describe("trailing directory separator", async () => {
     const entries = await Array.fromAsync(glob.scan({ onlyFiles: false, cwd: tmpdir }));
     expect(entries.sort()).toEqual(files.slice(2, 3).sort());
   });
+
+  describe("globstar recurses into nested directories", () => {
+    const files = {
+      "d1/d2/d3/deep.txt": "x",
+      "d1/f.txt": "x",
+      "e1/g.txt": "x",
+    };
+    const j = (...p: string[]) => p.join(path.sep);
+    const scan = (dir: string, p: string) => [...new Glob(p).scanSync({ cwd: dir, onlyFiles: false })].sort();
+
+    test("**/ yields every directory at every depth and no files", () => {
+      using dir = tempDir("glob-trailing-globstar", files);
+      expect(scan(String(dir), "**/")).toEqual(["d1", j("d1", "d2"), j("d1", "d2", "d3"), "e1"]);
+    });
+
+    test("prefix/**/ yields every directory under prefix", () => {
+      using dir = tempDir("glob-trailing-globstar-prefix", files);
+      expect(scan(String(dir), "d1/**/")).toEqual([j("d1", "d2"), j("d1", "d2", "d3")]);
+    });
+
+    test("**/ and match() agree on nested directory paths", () => {
+      using dir = tempDir("glob-trailing-globstar-match", files);
+      const g = new Glob("d1/**/");
+      const entries = scan(String(dir), "d1/**/");
+      expect(entries).toEqual([j("d1", "d2"), j("d1", "d2", "d3")]);
+      for (const e of entries) {
+        expect(g.match(e.replaceAll(path.sep, "/") + "/")).toBe(true);
+      }
+    });
+
+    test("async scan agrees with sync", async () => {
+      using dir = tempDir("glob-trailing-globstar-async", files);
+      const entries = (await Array.fromAsync(new Glob("**/").scan({ cwd: String(dir), onlyFiles: false }))).sort();
+      expect(entries).toEqual(["d1", j("d1", "d2"), j("d1", "d2", "d3"), "e1"]);
+    });
+  });
+
+  describe("excludes files when the final component carries a trailing separator", () => {
+    const files = {
+      "foo": "x",
+      "file.txt": "x",
+      "sub/foo": "x",
+      "bar/placeholder": "x",
+    };
+    const j = (...p: string[]) => p.join(path.sep);
+    const scan = (dir: string, p: string) => [...new Glob(p).scanSync({ cwd: dir, onlyFiles: false })].sort();
+
+    test("**/foo/ does not yield a file named foo", () => {
+      using dir = tempDir("glob-trailing-sep-peek", files);
+      expect(scan(String(dir), "**/foo/")).toEqual([]);
+    });
+
+    test("**/*/ yields only directories", () => {
+      using dir = tempDir("glob-trailing-sep-star", files);
+      expect(scan(String(dir), "**/*/")).toEqual(["bar", "sub"]);
+    });
+
+    test("literal/ does not yield a file via the statat fast path", () => {
+      using dir = tempDir("glob-trailing-sep-literal", files);
+      expect(scan(String(dir), "foo/")).toEqual([]);
+      expect(scan(String(dir), "bar/")).toEqual(["bar"]);
+    });
+
+    test("prefix/literal/ does not yield a file", () => {
+      using dir = tempDir("glob-trailing-sep-prefix-literal", files);
+      expect(scan(String(dir), "sub/foo/")).toEqual([]);
+      expect(scan(String(dir), "*/foo/")).toEqual([]);
+    });
+
+    test("**/foo/ yields a directory named foo", () => {
+      using dir = tempDir("glob-trailing-sep-dir-named-foo", {
+        "foo/placeholder": "x",
+        "sub/foo/placeholder": "x",
+        "sub/bar": "x",
+      });
+      expect(scan(String(dir), "**/foo/")).toEqual(["foo", j("sub", "foo")]);
+    });
+  });
 });
 
 describe("absolute path pattern", async () => {