Fix cargo_build_script tree artifact failures (#3945)

After `drain_runfiles_dir` removes symlinks and retains only files
matching `filename_suffixes_to_retain` (default: `.lib`, `.so`), targets
with no matching files were left with a directory tree of empty
subdirectories. The existing `.empty` file guard used a shallow
`read_dir().count() == 0` check, which returned non-zero because empty
nested directories (e.g. `workspace_name/pkg/...`) still existed -- even
though remote execution tree artifacts only track files, not
directories. This adds a recursive `dir_contains_files` helper, moves
the `.empty` guard into the shared `drain_runfiles_dir` method (covering
both Unix and Windows paths), and recursively cleans up empty ancestor
directories during drain. The same `.empty` guard is also applied to
`OUT_DIR` in `bin.rs`.

Author: UebelAndre

cargo/private/cargo_build_script_runner/bin.rs

@@ -237,6 +237,26 @@ fn run_buildrs() -> Result<(), String> {
             .drain_runfiles_dir(&out_dir_abs)
             .unwrap();
     }
+
+    // If out_dir is empty add an empty file to the directory to avoid an upstream Bazel bug
+    // https://github.com/bazelbuild/bazel/issues/28286
+    if out_dir_abs.read_dir().map(|read| read.count()).unwrap_or(0) == 0 {
+        create_dir_all(&out_dir_abs).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create OUT_DIR `{}`\n{:?}",
+                out_dir_abs.display(),
+                e
+            )
+        });
+        std::fs::write(out_dir_abs.join(".empty"), "").unwrap_or_else(|e| {
+            panic!(
+                "Failed to write empty file to OUT_DIR `{}`\n{:?}",
+                out_dir_abs.display(),
+                e
+            )
+        })
+    }
+
     Ok(())
 }
 

cargo/private/cargo_build_script_runner/cargo_manifest_dir.rs

@@ -78,6 +78,32 @@ fn is_dir_empty(path: &Path) -> Result<bool, String> {
     Ok(entries.next().is_none())
 }
 
+/// Recursively checks whether a directory tree contains any regular files.
+///
+/// Returns `false` if the directory only contains empty subdirectories,
+/// which is important because remote execution tree artifacts only track
+/// files, not directories.
+fn dir_contains_files(path: &Path) -> bool {
+    let entries = match std::fs::read_dir(path) {
+        Ok(entries) => entries,
+        Err(_) => return false,
+    };
+    for entry in entries.flatten() {
+        let file_type = match entry.file_type() {
+            Ok(ft) => ft,
+            Err(_) => continue,
+        };
+        if file_type.is_dir() {
+            if dir_contains_files(&entry.path()) {
+                return true;
+            }
+        } else {
+            return true;
+        }
+    }
+    false
+}
+
 /// A struct for generating runfiles directories to use when running Cargo build scripts.
 pub struct RunfilesMaker {
     /// The output where a runfiles-like directory should be written.
@@ -248,17 +274,24 @@ impl RunfilesMaker {
                 .iter()
                 .any(|suffix| dest.ends_with(suffix))
             {
-                if let Some(parent) = abs_dest.parent() {
-                    if is_dir_empty(parent).map_err(|e| {
+                let mut dir = abs_dest.parent().map(Path::to_path_buf);
+                while let Some(parent) = dir {
+                    if parent == self.output_dir {
+                        break;
+                    }
+                    if is_dir_empty(&parent).map_err(|e| {
                         format!("Failed to determine if directory was empty with: {:?}", e)
                     })? {
-                        std::fs::remove_dir(parent).map_err(|e| {
+                        std::fs::remove_dir(&parent).map_err(|e| {
                             format!(
                                 "Failed to delete directory {} with {:?}",
                                 parent.display(),
                                 e
                             )
                         })?;
+                        dir = parent.parent().map(Path::to_path_buf);
+                    } else {
+                        break;
                     }
                 }
                 continue;
@@ -273,6 +306,7 @@ impl RunfilesMaker {
                 )
             })?;
         }
+
         Ok(())
     }
 
@@ -312,6 +346,20 @@ impl RunfilesMaker {
             self.drain_runfiles_dir_unix()?;
         }
 
+        // If the runfiles dir contains no files, add an empty file to avoid
+        // an upstream Bazel bug where tree artifacts with only empty
+        // subdirectories are considered "not created" in remote execution.
+        // https://github.com/bazelbuild/bazel/issues/28286
+        if !dir_contains_files(&self.output_dir) {
+            std::fs::write(self.output_dir.join(".empty"), "").unwrap_or_else(|e| {
+                panic!(
+                    "Failed to write empty file to runfiles dir `{}`\n{:?}",
+                    self.output_dir.display(),
+                    e
+                )
+            })
+        }
+
         // Due to the symlinks in `CARGO_MANIFEST_DIR`, some build scripts
         // may have placed symlinks over real files in `OUT_DIR`. To counter
         // this, all non-relative symlinks are resolved.

extensions/wasm_bindgen/private/BUILD.bazel

@@ -15,6 +15,13 @@ bzl_library(
     ],
 )
 
+rust_binary(
+    name = "wasm_bindgen_wrapper",
+    srcs = ["wasm_bindgen_wrapper.rs"],
+    edition = "2021",
+    visibility = ["//visibility:public"],
+)
+
 rust_binary(
     name = "wasm_bindgen_test_runner",
     srcs = ["wasm_bindgen_test_runner.rs"],

extensions/wasm_bindgen/private/wasm_bindgen.bzl

@@ -77,14 +77,18 @@ def rust_wasm_bindgen_action(*, ctx, toolchain, wasm_file, target_output, flags
     outputs = [bindgen_wasm_module, snippets] + js_out + ts_out
 
     args = ctx.actions.args()
+    args.add(bindgen_bin.path)
+    args.add(snippets.path)
+    args.add("--")
     args.add("--target", target_output)
     args.add("--out-dir", bindgen_wasm_module.dirname)
     args.add("--out-name", out_name)
     args.add_all(flags)
     args.add(input_file)
 
     ctx.actions.run(
-        executable = bindgen_bin,
+        executable = ctx.executable._process_wrapper,
+        tools = [bindgen_bin],
         inputs = [input_file],
         outputs = outputs,
         mnemonic = "RustWasmBindgen",
@@ -178,6 +182,12 @@ WASM_BINDGEN_ATTR = {
     "_allowlist_function_transition": attr.label(
         default = Label("@bazel_tools//tools/allowlists/function_transition_allowlist"),
     ),
+    "_process_wrapper": attr.label(
+        doc = "A process wrapper for ensuring tree artifacts are non-empty.",
+        default = Label("//private:wasm_bindgen_wrapper"),
+        executable = True,
+        cfg = "exec",
+    ),
 }
 
 rust_wasm_bindgen = rule(

extensions/wasm_bindgen/private/wasm_bindgen_wrapper.rs

@@ -0,0 +1,43 @@
+//! A process wrapper for `wasm-bindgen` that ensures the `snippets` tree
+//! artifact directory is never empty after the tool runs.
+//!
+//! Bazel does not track empty directories in remote execution, so an empty
+//! `snippets` directory can cause action cache misses or "output not created"
+//! errors. See <https://github.com/bazelbuild/bazel/issues/28286>.
+
+use std::env;
+use std::fs;
+use std::path::Path;
+use std::process::{self, Command};
+
+fn main() {
+    let mut args = env::args().skip(1);
+
+    let bindgen = args
+        .next()
+        .expect("expected wasm-bindgen binary path as first argument");
+    let snippets_dir = args
+        .next()
+        .expect("expected snippets dir as second argument");
+
+    let remaining: Vec<String> = args.skip_while(|a| a == "--").collect();
+
+    let status = Command::new(&bindgen)
+        .args(&remaining)
+        .status()
+        .unwrap_or_else(|e| panic!("failed to spawn {}: {}", bindgen, e));
+
+    if !status.success() {
+        process::exit(status.code().unwrap_or(1));
+    }
+
+    let is_empty = fs::read_dir(&snippets_dir)
+        .map(|mut entries| entries.next().is_none())
+        .unwrap_or(true);
+
+    if is_empty {
+        let sentinel = Path::new(&snippets_dir).join(".empty");
+        fs::File::create(&sentinel)
+            .unwrap_or_else(|e| panic!("failed to create {}: {}", sentinel.display(), e));
+    }
+}