glob: honour backslash escapes of non-special characters in scan()

src/glob/GlobWalker.rs

@@ -1863,7 +1863,7 @@
         !filepath.is_empty() && filepath[0] == b'.'
     }
 
-    const SYNTAX_TOKENS: &'static [u8] = b"*[{?!";
+    const SYNTAX_TOKENS: &'static [u8] = b"*[{?!\\";
 
     fn check_special_syntax(pattern: &[u8]) -> bool {
         strings::index_of_any(pattern, Self::SYNTAX_TOKENS).is_some()
@@ -1939,11 +1939,13 @@
                             // false negatives, but that's okay, it just
                             // means we don't apply the optimization.
                             //
                             // We also don't need to look for the `!` token,
                             // because that only applies negation if at the
                             // beginning of the string.
-                            b'[' | b'{' | b'?' | b'*' => break 'out_of_check_wildcard_filepath,
+                            b'[' | b'{' | b'?' | b'*' | b'\\' => {
+                                break 'out_of_check_wildcard_filepath
+                            }
                             _ => {}
                         }
                     }
                     component.syntax_hint = SyntaxHint::WildcardFilepath;

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

@@ -23,7 +23,7 @@
 import { Glob, GlobScanOptions } from "bun";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import fg from "fast-glob";
-import { bunEnv, bunExe, tempDir, tempDirWithFiles, tmpdirSync } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir, tempDirWithFiles, tmpdirSync } from "harness";
 import * as fs from "node:fs";
 import * as path from "path";
 import { createTempDirectoryWithBrokenSymlinks, prepareEntries, tempFixturesDir } from "./util";
@@ -618,6 +618,41 @@ describe("literal fast path", async () => {
   });
 });
 
+// On Windows `\` is a path separator, not an escape character.
+describe.skipIf(isWindows)("backslash escapes non-special characters", () => {
+  let cwd = "";
+  beforeAll(() => {
+    cwd = tempDirWithFiles("glob-scan-backslash-escape", {
+      "sp ace.txt": "x",
+      "d r": { "f.txt": "x" },
+      "foo.t s": "x",
+    });
+  });
+
+  // `\x` quotes `x` whether or not `x` is special, so scan must agree with match.
+  test.each([
+    ["literal component", "sp\\ ace.txt", ["sp ace.txt"]],
+    ["*.ext component", "*.t\\ s", ["foo.t s"]],
+    ["directory component", "d\\ r/*.txt", ["d r/f.txt"]],
+    ["under **", "**/sp\\ ace.txt", ["sp ace.txt"]],
+    ["escaped backslash is literal", "sp\\\\ ace.txt", []],
+  ])("%s", async (_, pattern, expected) => {
+    const glob = new Glob(pattern);
+    const sync = Array.from(glob.scanSync({ cwd })).sort();
+    const async = (await Array.fromAsync(glob.scan({ cwd }))).sort();
+    expect({ sync, async }).toEqual({ sync: expected, async: expected });
+    for (const name of expected) {
+      expect(glob.match(name)).toBe(true);
+    }
+  });
+
+  test("absolute path", async () => {
+    const glob = new Glob(path.posix.join(cwd, "sp\\ ace.txt"));
+    const entries = await Array.fromAsync(glob.scan());
+    expect(entries).toEqual([path.join(cwd, "sp ace.txt")]);
+  });
+});
+
 describe("trailing directory separator", async () => {
   test("matches directories absolute", async () => {
     const tmpdir = tmpdirSync();