fix: support header_contents() with clang_macro_fallback

Fixes #3351

clang_macro_fallback() silently produced no output when headers were
provided via header_contents() instead of header(). This happened
because try_ensure_fallback_translation_unit() only looked at
input_headers (populated by .header()), returning None when it was
empty.

Fix: materialize input_header_contents to disk in the fallback build
directory so clang can consume them for PCH compilation. Both
input_headers and input_header_contents are now included in the
fallback PCH, so mixed .header() + .header_contents() setups work.

The materialized paths are sanitized (roots stripped, ".." resolved)
to prevent escaping the build directory, and tracked in
FallbackTranslationUnit for cleanup on drop.

Also stop using std::mem::take on input_header_contents in
Builder::generate(), preserving the data for the fallback TU (and
fixing a pre-existing bug where serialize_items in codegen couldn't
see header contents).

Also store the original user-provided name in input_header_contents
at header_contents() time so the fallback can reconstruct relative
paths without depending on the current working directory.

Author: zRedShift

bindgen-tests/tests/tests.rs

@@ -617,6 +617,213 @@ fn test_macro_fallback_non_system_dir() {
     }
 }
 
+#[test]
+fn test_macro_fallback_header_contents() {
+    let tmpdir = tempfile::tempdir().unwrap();
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents(
+            "test.h",
+            "#define UINT32_C(c) c ## U\n\
+             #define SIMPLE 42\n\
+             #define COMPOUND UINT32_C(69)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(tmpdir.path())
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let actual = format_code(actual).unwrap();
+
+    let expected = format_code(
+        "pub const SIMPLE: u32 = 42;\npub const COMPOUND: u32 = 69;\n",
+    )
+    .unwrap();
+
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn test_macro_fallback_multiple_header_contents() {
+    let tmpdir = tempfile::tempdir().unwrap();
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents("defs.h", "#define UINT32_C(c) c ## U\n")
+        .header_contents(
+            "test.h",
+            "#include \"defs.h\"\n\
+             #define MY_CONST UINT32_C(28)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(tmpdir.path())
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let actual = format_code(actual).unwrap();
+
+    // UINT32_C is a function-like macro, should not appear as a constant.
+    // MY_CONST should be evaluated by the fallback.
+    assert!(
+        actual.contains("pub const MY_CONST: u32 = 28;"),
+        "Expected MY_CONST constant in output:\n{actual}"
+    );
+}
+
+#[test]
+fn test_macro_fallback_mixed_header_and_header_contents() {
+    let tmpdir = tempfile::tempdir().unwrap();
+    let actual = builder()
+        .disable_header_comment()
+        .header(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/tests/headers/issue-753.h"
+        ))
+        .header_contents(
+            "extra.h",
+            "#define UINT32_C(c) c ## U\n\
+             #define EXTRA_CONST UINT32_C(99)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(tmpdir.path())
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let actual = format_code(actual).unwrap();
+
+    // Constants from the real header (issue-753.h defines UINT32_C and uses it)
+    assert!(
+        actual.contains("pub const CONST: u32 = 5;"),
+        "Expected CONST from real header in output:\n{actual}"
+    );
+    // Constants from the virtual header via fallback
+    assert!(
+        actual.contains("pub const EXTRA_CONST: u32 = 99;"),
+        "Expected EXTRA_CONST from header_contents in output:\n{actual}"
+    );
+}
+
+#[test]
+fn test_macro_fallback_header_contents_duplicate_basename() {
+    let tmpdir = tempfile::tempdir().unwrap();
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents(
+            "defs.h",
+            "#define UINT32_C(c) c ## U\n\
+             #define FROM_ROOT UINT32_C(11)\n",
+        )
+        .header_contents(
+            "sub/defs.h",
+            "#define UINT32_C(c) c ## U\n\
+             #define FROM_SUB UINT32_C(22)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(tmpdir.path())
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let actual = format_code(actual).unwrap();
+
+    assert!(
+        actual.contains("pub const FROM_ROOT: u32 = 11;"),
+        "Expected FROM_ROOT in output:\n{actual}"
+    );
+    assert!(
+        actual.contains("pub const FROM_SUB: u32 = 22;"),
+        "Expected FROM_SUB in output:\n{actual}"
+    );
+}
+
+#[test]
+fn test_macro_fallback_header_contents_absolute_name() {
+    // Absolute names must not escape the build dir — they should be
+    // materialized safely under it, and the original file must not be
+    // clobbered or deleted.
+    let tmpdir = tempfile::tempdir().unwrap();
+    let victim = tmpdir.path().join("victim.h");
+    fs::write(&victim, "// original content\n").unwrap();
+
+    let abs_name = victim.to_str().unwrap();
+    let build_dir = tmpdir.path().join("fallback_build");
+    fs::create_dir_all(&build_dir).unwrap();
+
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents(
+            abs_name,
+            "#define UINT32_C(c) c ## U\n\
+             #define ABS_CONST UINT32_C(55)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(&build_dir)
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    // The fallback-only constant should be evaluated.
+    assert!(
+        actual.contains("pub const ABS_CONST: u32 = 55;"),
+        "Expected ABS_CONST in output:\n{actual}"
+    );
+
+    // The original file must not have been deleted by FallbackTU drop.
+    assert!(
+        victim.exists(),
+        "Original file at {abs_name} was deleted by fallback cleanup"
+    );
+    assert_eq!(
+        fs::read_to_string(&victim).unwrap(),
+        "// original content\n",
+        "Original file at {abs_name} was overwritten by materialization"
+    );
+}
+
+#[test]
+fn test_macro_fallback_header_contents_parent_dir_escape() {
+    // Names with ".." must not escape the build dir or delete files
+    // outside it during FallbackTranslationUnit cleanup.
+    let tmpdir = tempfile::tempdir().unwrap();
+    let victim = tmpdir.path().join("victim.h");
+    fs::write(&victim, "// must survive\n").unwrap();
+
+    let build_dir = tmpdir.path().join("build");
+    fs::create_dir_all(&build_dir).unwrap();
+
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents(
+            "../victim.h",
+            "#define UINT32_C(c) c ## U\n\
+             #define ESCAPE_CONST UINT32_C(77)\n",
+        )
+        .clang_macro_fallback()
+        .clang_macro_fallback_build_dir(&build_dir)
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    assert!(
+        actual.contains("pub const ESCAPE_CONST: u32 = 77;"),
+        "Expected ESCAPE_CONST in output:\n{actual}"
+    );
+
+    // The file outside build_dir must not have been clobbered.
+    assert!(
+        victim.exists(),
+        "File outside build dir was deleted by fallback cleanup"
+    );
+    assert_eq!(fs::read_to_string(&victim).unwrap(), "// must survive\n",);
+}
+
 #[test]
 // Doesn't support executing sh file on Windows.
 // We may want to implement it in Rust so that we support all systems.

bindgen/clang.rs

@@ -1915,6 +1915,9 @@ impl Drop for TranslationUnit {
 pub(crate) struct FallbackTranslationUnit {
     file_path: String,
     pch_path: String,
+    /// Header files materialized from `header_contents()` that must remain on
+    /// disk while the PCH is in use (clang validates source file existence).
+    materialized_headers: Vec<String>,
     idx: Box<Index>,
     tu: TranslationUnit,
 }
@@ -1931,6 +1934,7 @@ impl FallbackTranslationUnit {
         file: String,
         pch_path: String,
         c_args: &[Box<str>],
+        materialized_headers: Vec<String>,
     ) -> Option<Self> {
         // Create empty file
         OpenOptions::new()
@@ -1951,6 +1955,7 @@ impl FallbackTranslationUnit {
         Some(FallbackTranslationUnit {
             file_path: file,
             pch_path,
+            materialized_headers,
             tu: f_translation_unit,
             idx: f_index,
         })
@@ -1989,6 +1994,9 @@ impl Drop for FallbackTranslationUnit {
     fn drop(&mut self) {
         let _ = std::fs::remove_file(&self.file_path);
         let _ = std::fs::remove_file(&self.pch_path);
+        for path in &self.materialized_headers {
+            let _ = std::fs::remove_file(path);
+        }
     }
 }
 

bindgen/codegen/mod.rs

@@ -5364,7 +5364,8 @@ pub(crate) mod utils {
         }
 
         if !context.options().input_header_contents.is_empty() {
-            for (name, contents) in &context.options().input_header_contents {
+            for (name, contents, _) in &context.options().input_header_contents
+            {
                 writeln!(code, "// {name}\n{contents}")?;
             }
 

bindgen/ir/context.rs

@@ -2042,24 +2042,76 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         &mut self,
     ) -> Option<&mut clang::FallbackTranslationUnit> {
         if self.fallback_tu.is_none() {
-            let file = format!(
-                "{}/.macro_eval.c",
+            let build_dir: String =
                 match self.options().clang_macro_fallback_build_dir {
-                    Some(ref path) => path.as_os_str().to_str()?,
-                    None => ".",
-                }
-            );
+                    Some(ref path) => path.as_os_str().to_str()?.to_owned(),
+                    None => ".".to_owned(),
+                };
+            let file = format!("{build_dir}/.macro_eval.c");
 
             let index = clang::Index::new(false, false);
 
-            let mut header_names_to_compile = Vec::new();
-            let mut header_paths = Vec::new();
-            let mut header_includes = Vec::new();
-            let [input_headers @ .., single_header] =
-                &self.options().input_headers[..]
+            // Materialize input_header_contents to disk for the fallback
+            // translation unit. header_contents() provides virtual files
+            // that only exist as unsaved buffers in the main TU — the
+            // fallback TU needs real files on disk for PCH compilation.
+            // The files must remain on disk while the PCH is in use
+            // (clang validates source file existence when loading a PCH).
+            //
+            // Both input_headers and input_header_contents are included
+            // so the PCH captures macro definitions from all sources.
+            let materialized_paths: Vec<String> = self
+                .options()
+                .input_header_contents
+                .iter()
+                .filter_map(|(_, contents, original_name)| {
+                    // Sanitize the user-provided name so it always
+                    // resolves under build_dir:
+                    //  - Root/prefix components are dropped (absolute
+                    //    paths can't bypass build_dir via Path::join).
+                    //  - ".." is resolved against the accumulated path
+                    //    but clamped to empty (can't escape build_dir).
+                    //  - "." is skipped.
+                    // This preserves directory structure for collision
+                    // avoidance (e.g. "a.h" vs "dir/a.h") while
+                    // preventing any path from escaping build_dir.
+                    use std::path::Component;
+                    let mut parts: Vec<&std::ffi::OsStr> = Vec::new();
+                    for c in Path::new(original_name.as_ref()).components() {
+                        match c {
+                            Component::Normal(s) => parts.push(s),
+                            Component::ParentDir => {
+                                parts.pop();
+                            }
+                            _ => {}
+                        }
+                    }
+                    let relative: std::path::PathBuf = parts.iter().collect();
+                    let disk_path = Path::new(&build_dir).join(&relative);
+                    if let Some(parent) = disk_path.parent() {
+                        std::fs::create_dir_all(parent).ok()?;
+                    }
+                    std::fs::write(&disk_path, contents.as_ref()).ok()?;
+                    Some(disk_path.to_str()?.to_owned())
+                })
+                .collect();
+
+            let effective_headers: Vec<Box<str>> = self
+                .options()
+                .input_headers
+                .iter()
+                .cloned()
+                .chain(materialized_paths.iter().map(|p| p.clone().into()))
+                .collect();
+
+            let [input_headers @ .., single_header] = &effective_headers[..]
             else {
                 return None;
             };
+
+            let mut header_names_to_compile = Vec::new();
+            let mut header_paths = Vec::new();
+            let mut header_includes = Vec::new();
             for input_header in input_headers {
                 let path = Path::new(input_header.as_ref());
                 if let Some(header_path) = path.parent() {
@@ -2071,17 +2123,15 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                 } else {
                     header_paths.push(".");
                 }
+                // Use full path for -include to avoid basename
+                // collisions between headers in different directories.
+                header_includes.push(input_header.as_ref().to_string());
                 let header_name = path.file_name()?.to_str()?;
-                header_includes.push(header_name.to_string());
                 header_names_to_compile
                     .push(header_name.split(".h").next()?.to_string());
             }
             let pch = format!(
-                "{}/{}",
-                match self.options().clang_macro_fallback_build_dir {
-                    Some(ref path) => path.as_os_str().to_str()?,
-                    None => ".",
-                },
+                "{build_dir}/{}",
                 header_names_to_compile.join("-") + "-precompile.h.pch"
             );
 
@@ -2118,8 +2168,12 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                     c_args.push(arg.clone());
                 }
             }
-            self.fallback_tu =
-                Some(clang::FallbackTranslationUnit::new(file, pch, &c_args)?);
+            self.fallback_tu = Some(clang::FallbackTranslationUnit::new(
+                file,
+                pch,
+                &c_args,
+                materialized_paths,
+            )?);
         }
 
         self.fallback_tu.as_mut()