release: publish fbuild 2.5.7 dependency cascade

Cargo.toml

@@ -69,7 +69,7 @@ exclude = [
 libraries = [{ path = "dylints/*" }]
 
 [workspace.package]
-version = "2.5.6"
+version = "2.5.7"
 edition = "2021"
 rust-version = "1.94.1"
 license = "MIT OR Apache-2.0"

crates/fbuild-build/Cargo.toml

@@ -48,11 +48,9 @@ tree-sitter-cpp = { workspace = true }
 # child processes) was deleted in the same PR; there is no
 # `--no-default-features` escape hatch.
 #
-# Pinned at zccache 1.12.17 (`5ee292f`, upstream main). soldr's
-# `_vender/zccache` submodule currently sits 3 commits behind this at
-# `4180af8`; both revs speak the same shared-broker protocol, so the two
-# embedded services still interoperate. Re-check that submodule when
-# repinning — a protocol-affecting zccache change must land in both.
+# Pinned at zccache 1.13.1 (`8cf6dd0`, release tag), which pins
+# running-process 4.8.1 at `359b4e3`. Keep both revisions aligned when
+# repinning so fbuild links exactly one copy of the exported broker symbols.
 #
 # `running-process` in the workspace root must be pinned to the SAME git rev
 # zccache uses, or its unmangled `rp_*_public` C symbols get linked twice.

crates/fbuild-build/tests/zccache_embedded_smoke.rs

@@ -5,8 +5,45 @@
 //! with it).
 
 use fbuild_build::zccache_embedded::FbuildZccacheService;
+use fbuild_core::path::NormalizedPath;
 use zccache::embedded::ShutdownMode;
 
+fn find_c_compiler() -> NormalizedPath {
+    let path_dirs: Vec<_> =
+        std::env::split_paths(&std::env::var_os("PATH").expect("PATH should be set")).collect();
+    let on_path = |name: &str| {
+        path_dirs
+            .iter()
+            .map(|dir| dir.join(name))
+            .find(|candidate| candidate.is_file())
+            .map(NormalizedPath::from)
+    };
+    if cfg!(windows) {
+        if let Some(candidate) = on_path("clang.exe") {
+            return candidate;
+        }
+        if let Some(program_files) = std::env::var_os("ProgramFiles") {
+            let candidate = NormalizedPath::new(std::path::Path::new(&program_files))
+                .join("LLVM")
+                .join("bin")
+                .join("clang.exe");
+            if candidate.is_file() {
+                return candidate;
+            }
+        }
+        if let Some(candidate) = on_path("gcc.exe") {
+            return candidate;
+        }
+        panic!("clang.exe or gcc.exe must be installed for this smoke test");
+    }
+    for name in ["cc", "clang", "gcc"] {
+        if let Some(candidate) = on_path(name) {
+            return candidate;
+        }
+    }
+    panic!("cc, clang, or gcc must be installed for this smoke test");
+}
+
 /// `FbuildZccacheService::start_in` produces a working service
 /// handle: the cache root exists on disk, the identity carries our
 /// product tag, and a graceful shutdown returns cleanly.
@@ -42,3 +79,80 @@ async fn embedded_service_starts_and_shuts_down() {
         .await
         .expect("graceful shutdown should succeed");
 }
+
+/// A real compile traverses fbuild's embedded zccache boundary twice: the
+/// first invocation populates a fresh cache and the second must materialize
+/// the object from that cache. This is also a link-time guard against loading
+/// two copies of running-process's unmangled `rp_*_public` exports.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn embedded_compilation_cold_miss_then_warm_hit() {
+    let tmp = tempfile::TempDir::new().expect("tempdir");
+    let cache_root = tmp.path().join("zccache");
+    let source = tmp.path().join("smoke.c");
+    let object = tmp.path().join(if cfg!(windows) {
+        "smoke.obj"
+    } else {
+        "smoke.o"
+    });
+    std::fs::write(&source, "int smoke(void) { return 42; }\n").expect("write source");
+
+    let svc = FbuildZccacheService::start_in(cache_root)
+        .await
+        .expect("embedded service should start");
+    let compiler = find_c_compiler();
+    let args = vec![
+        "-c".to_string(),
+        source.to_string_lossy().into_owned(),
+        "-o".to_string(),
+        object.to_string_lossy().into_owned(),
+    ];
+    let mut compile_env = fbuild_core::subprocess::compile_env_for_build(tmp.path())
+        .expect("prepare the same hermetic compile environment used in production");
+    compile_env.push((
+        "ZCCACHE_WORKTREE_ROOT".to_string(),
+        tmp.path().to_string_lossy().into_owned(),
+    ));
+
+    let cold = svc
+        .compile(
+            &compiler,
+            args.clone(),
+            tmp.path().to_path_buf(),
+            compile_env.clone(),
+        )
+        .await
+        .expect("cold embedded compile should succeed");
+    assert_eq!(
+        cold.exit_code,
+        0,
+        "cold compile stderr: {}",
+        String::from_utf8_lossy(&cold.stderr)
+    );
+    assert!(!cold.cached, "fresh cache unexpectedly reported a hit");
+    assert!(object.is_file(), "cold compile should create an object");
+
+    svc.flush()
+        .await
+        .expect("flush cold compile into the cache");
+    std::fs::remove_file(&object).expect("remove cold object before warm materialization");
+
+    let warm = svc
+        .compile(&compiler, args, tmp.path().to_path_buf(), compile_env)
+        .await
+        .expect("warm embedded compile should succeed");
+    assert_eq!(
+        warm.exit_code,
+        0,
+        "warm compile stderr: {}",
+        String::from_utf8_lossy(&warm.stderr)
+    );
+    assert!(
+        warm.cached,
+        "second identical compile should be a cache hit"
+    );
+    assert!(object.is_file(), "warm hit should materialize the object");
+
+    svc.shutdown(ShutdownMode::Graceful)
+        .await
+        .expect("graceful shutdown should succeed");
+}

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fbuild"
-version = "2.5.6"
+version = "2.5.7"
 description = "PlatformIO-compatible embedded build tool (Rust implementation)"
 readme = "README.md"
 requires-python = ">=3.10"