feat(rust_common): allow compile actions to declare that extra folders will be created

This technique is sometimes needed when a proc_macro derives information from the build, and it needs to be consumed by some other tool

sort

cursor wrote a new unit test for this PR

fmt

Author: alexeagle

rust/private/rust.bzl

@@ -732,6 +732,11 @@ _common_attrs = {
     "edition": attr.string(
         doc = "The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.",
     ),
+    "extra_outdirs": attr.string_list(
+        doc = dedent("""\
+            List of additional output directories which are expected to be written by the compiler.
+        """),
+    ),
     "lint_config": attr.label(
         doc = "Set of lints to apply when building this crate.",
         providers = [LintsInfo],

rust/private/rustc.bzl

@@ -1482,6 +1482,9 @@ def rustc_compile_action(
         interface_library = ctx.actions.declare_file(crate_info.output.basename + ".lib", sibling = crate_info.output)
         outputs.append(interface_library)
 
+    if hasattr(ctx.attr, "extra_outdirs"):
+        outputs.extend([ctx.actions.declare_directory(outdir) for outdir in ctx.attr.extra_outdirs])
+
     # The action might generate extra output that we don't want to include in the `DefaultInfo` files.
     action_outputs = list(outputs)
     if rustc_output:

test/unit/extra_outdirs/BUILD.bazel

@@ -0,0 +1,33 @@
+load("//rust:defs.bzl", "rust_library", "rust_proc_macro")
+load(":extra_outdirs_test.bzl", "extra_outdirs_test_suite")
+
+rust_proc_macro(
+    name = "write_outdirs_macro",
+    srcs = ["proc_macro.rs"],
+    edition = "2018",
+    visibility = ["//test:__subpackages__"],
+)
+
+rust_library(
+    name = "lib",
+    srcs = ["lib.rs"],
+    edition = "2018",
+)
+
+rust_library(
+    name = "lib_with_outdirs",
+    srcs = ["lib_with_outdirs.rs"],
+    edition = "2018",
+    extra_outdirs = [
+        "test_dir",
+        "another_dir",
+    ],
+    proc_macro_deps = [":write_outdirs_macro"],
+    rustc_env = {
+        "EXTRA_OUTDIRS": "test_dir,another_dir",
+    },
+)
+
+extra_outdirs_test_suite(
+    name = "extra_outdirs_test_suite",
+)

test/unit/extra_outdirs/extra_outdirs_test.bzl

@@ -0,0 +1,110 @@
+"""Unittest to verify extra_outdirs attribute adds directories to action outputs."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//test/unit:common.bzl", "assert_action_mnemonic")
+
+def _extra_outdirs_present_test(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+    
+    # Find the Rustc action
+    rustc_action = [action for action in target.actions if action.mnemonic == "Rustc"][0]
+    assert_action_mnemonic(env, rustc_action, "Rustc")
+    
+    # Get all outputs from the action
+    outputs = rustc_action.outputs.to_list()
+    
+    # Check that the expected directories are in the outputs
+    expected_dirs = ctx.attr.expected_outdirs
+    found_dirs = []
+    
+    for output in outputs:
+        # Check if this output is a directory (directories don't have extensions)
+        # and if its basename matches one of our expected directories
+        if output.is_directory:
+            if output.basename in expected_dirs:
+                found_dirs.append(output.basename)
+    
+    # Verify all expected directories were found
+    asserts.equals(
+        env,
+        sorted(found_dirs),
+        sorted(expected_dirs),
+        "Expected to find directories {expected} in action outputs, but found {found}".format(
+            expected = expected_dirs,
+            found = found_dirs,
+        ),
+    )
+    
+    return analysistest.end(env)
+
+def _extra_outdirs_not_present_test(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+    
+    # Find the Rustc action
+    rustc_action = [action for action in target.actions if action.mnemonic == "Rustc"][0]
+    assert_action_mnemonic(env, rustc_action, "Rustc")
+    
+    # Get all outputs from the action
+    outputs = rustc_action.outputs.to_list()
+    
+    # Check that no extra directories are present
+    # We expect only the standard outputs (rlib, rmeta if pipelining, etc.)
+    # but not any extra_outdirs directories
+    unexpected_dirs = []
+    for output in outputs:
+        if output.is_directory:
+            # Standard directories like .dSYM are okay, but we shouldn't have
+            # any of the extra_outdirs we're testing for
+            if output.basename in ["test_dir", "another_dir"]:
+                unexpected_dirs.append(output.basename)
+    
+    asserts.equals(
+        env,
+        [],
+        unexpected_dirs,
+        "Expected no extra_outdirs directories, but found {found}".format(
+            found = unexpected_dirs,
+        ),
+    )
+    
+    return analysistest.end(env)
+
+extra_outdirs_present_test = analysistest.make(
+    _extra_outdirs_present_test,
+    attrs = {
+        "expected_outdirs": attr.string_list(
+            mandatory = True,
+            doc = "List of expected output directory names",
+        ),
+    },
+)
+
+extra_outdirs_not_present_test = analysistest.make(_extra_outdirs_not_present_test)
+
+def extra_outdirs_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+    extra_outdirs_not_present_test(
+        name = "extra_outdirs_not_present_test",
+        target_under_test = ":lib",
+    )
+    
+    extra_outdirs_present_test(
+        name = "extra_outdirs_present_test",
+        target_under_test = ":lib_with_outdirs",
+        expected_outdirs = ["test_dir", "another_dir"],
+    )
+    
+    native.test_suite(
+        name = name,
+        tests = [
+            ":extra_outdirs_not_present_test",
+            ":extra_outdirs_present_test",
+        ],
+    )
+

test/unit/extra_outdirs/lib.rs

@@ -0,0 +1,2 @@
+pub fn call() {}
+

test/unit/extra_outdirs/lib_with_outdirs.rs

@@ -0,0 +1,6 @@
+use write_outdirs_macro::write_to_outdirs;
+
+write_to_outdirs!();
+
+pub fn call() {}
+

test/unit/extra_outdirs/proc_macro.rs

@@ -0,0 +1,36 @@
+// Similar to
+// https://github.com/napi-rs/napi-rs/blob/main/crates/macro/src/expand/typedef/type_def.rs#L11-L12
+// this proc macro has a side-effect of writing extra metadata directories.
+use proc_macro::TokenStream;
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+#[proc_macro]
+pub fn write_to_outdirs(_item: TokenStream) -> TokenStream {
+    // Read the list of directories to write to from an environment variable
+    if let Ok(outdirs) = env::var("EXTRA_OUTDIRS") {
+        // Get the manifest directory (package directory) as the base path
+        let manifest_dir = env::var("CARGO_MANIFEST_DIR")
+            .unwrap_or_else(|_| ".".to_string());
+        
+        for dir in outdirs.split(',') {
+            let dir = dir.trim();
+            if !dir.is_empty() {
+                // Construct the full path: manifest_dir + directory name
+                let dir_path = PathBuf::from(&manifest_dir).join(dir);
+                // Create the directory if it doesn't exist
+                if let Err(e) = fs::create_dir_all(&dir_path) {
+                    panic!("Failed to create directory {}: {:?}", dir_path.display(), e);
+                }
+                // Write a marker file to ensure the directory is created
+                let marker_file = dir_path.join("marker.txt");
+                if let Err(e) = fs::write(&marker_file, "created by proc-macro") {
+                    panic!("Failed to write marker file to {}: {:?}", marker_file.display(), e);
+                }
+            }
+        }
+    }
+    TokenStream::new()
+}
+