rust: fix cargo check --tests for bun_parsers and bun_sys after #34820/#35002

src/parsers/json.rs

@@ -1849,7 +1849,12 @@ mod tests {
                 out.push('\n');
             }
 
-            writeln!(out, "bool={:?}", Expr::get_boolean(&root, b"private")).unwrap();
+            writeln!(
+                out,
+                "bool={:?}",
+                root.get(b"private").and_then(|e| e.as_bool())
+            )
+            .unwrap();
             writeln!(out, "num={:?}", root.get_number(b"count").map(|(n, _)| n)).unwrap();
             writeln!(
                 out,

src/parsers/native_test_shims.rs

@@ -38,3 +38,24 @@ unsafe extern "C" fn highway_index_of_any_char(
     };
     t.iter().position(|c| cs.contains(c)).unwrap_or(text_len)
 }
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn highway_memmem(
+    haystack: *const u8,
+    haystack_len: usize,
+    needle: *const u8,
+    needle_len: usize,
+) -> *const u8 {
+    // SAFETY: caller contract of `bun_highway::memmem` guarantees both
+    // (ptr, len) pairs describe valid readable ranges.
+    let (h, n) = unsafe {
+        (
+            core::slice::from_raw_parts(haystack, haystack_len),
+            core::slice::from_raw_parts(needle, needle_len),
+        )
+    };
+    h.windows(n.len())
+        .position(|w| w == n)
+        // SAFETY: `i < haystack_len`, so `haystack.add(i)` stays in bounds.
+        .map_or(core::ptr::null(), |i| unsafe { haystack.add(i) })
+}

src/sys/file.rs

@@ -486,13 +486,12 @@ pub(crate) mod tests {
     #[test]
     fn dropping_stdio_is_safe() {
         let _g = FD_TEST_LOCK.lock();
-        // `File::stdin()` / `stdout()` / `stderr()` wrap process-shared
-        // descriptors that the caller does not own. Dropping the wrapper must
-        // not tear down the test harness's output.
+        // `File::stdin()` / `stdout()` wrap process-shared descriptors that the
+        // caller does not own. Dropping the wrapper must not tear down the test
+        // harness's output.
         for _ in 0..16 {
             let _ = File::stdin();
             let _ = File::stdout();
-            let _ = File::stderr();
         }
         assert!(fstat(Fd::stdout()).is_ok());
     }

test/internal/rust-tests-compile.test.ts

@@ -0,0 +1,46 @@
+// Verifies that the `#[cfg(test)]` code in a fixed set of Rust crates compiles.
+//
+// `bun bd`, `rust:check`, and `rust:clippy` all build with the default cfg only,
+// so a workspace-wide refactor that removes a symbol whose sole caller sits
+// behind `#[cfg(test)]` is invisible to every other CI lane. That is exactly how
+// #35002 broke `cargo test -p bun_parsers` (removed `Expr::get_boolean`) and
+// `cargo test -p bun_sys` (removed `File::stderr`).
+//
+// This does not try to link or run the unit tests (linking needs the C/C++ dep
+// archive assembled by `scripts/bench-json-rust.sh`); `cargo check --tests` is
+// enough to catch the class of breakage above and is fast on a warm build tree.
+import { expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = join(import.meta.dir, "..", "..");
+
+// Crates whose `#[cfg(test)]` modules are worth guarding here. Keep this list
+// small: each entry costs a `cargo check` of its dependency closure.
+const CRATES = ["bun_parsers", "bun_sys"];
+
+const cargo = Bun.which("cargo");
+// `cargo check` resolves the workspace, which requires the codegen dir that
+// `bun bd` / `bun run build --configure-only` populates.
+const workspaceReady = existsSync(join(repo, "build", "debug", "codegen", "build_options.rs"));
+
+test.skipIf(!cargo || !workspaceReady)(
+  `cargo check --tests compiles: ${CRATES.join(", ")}`,
+  async () => {
+    await using proc = Bun.spawn({
+      cmd: [cargo!, "check", ...CRATES.flatMap(c => ["-p", c]), "--tests", "--keep-going", "--message-format=short"],
+      cwd: repo,
+      env: { ...process.env, CARGO_TERM_COLOR: "never" },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+    const errors = stderr
+      .split("\n")
+      .filter(l => l.includes(": error[") || l.includes(": error:"))
+      .join("\n");
+    expect(errors).toBe("");
+    expect(exitCode).toBe(0);
+  },
+  120_000,
+);