Add standard library bindings in the subcommand.

Included in this change is a fix for Pat types, which was uncovered by
binding the stdlib.

Lookup the sysroot from rustc and use that to find the rmetas for the
standard library. Generate bindings to those standard library metas and
pass them to other crates in the graph.

PiperOrigin-RevId: 911371167

Author: thunderseethe

cc_bindings_from_rs/cargo-cpp_api_from_rust.rs

@@ -225,13 +225,134 @@ impl BindingGenerationContext {
         Ok(Self { pkg_to_artifact, root, ordered, dirs, resolve: resolve.clone() })
     }
 
+    fn get_sysroot() -> Result<Utf8PathBuf> {
+        // The user requested finding this from cargo_metadata, but since it's not actually
+        // present in `cargo metadata` output, we fall back to invoking `rustc --print sysroot`.
+        let output = std::process::Command::new("rustc").arg("--print").arg("sysroot").output()?;
+        if !output.status.success() {
+            bail!("Failed to get sysroot from rustc");
+        }
+        let path = std::str::from_utf8(&output.stdout)?.trim();
+        Ok(Utf8PathBuf::from(path))
+    }
+
+    fn find_stdlib_rmetas(sysroot: &Utf8PathBuf) -> Result<Vec<(String, Utf8PathBuf)>> {
+        let mut rmetas = Vec::new();
+        let libs = ["core", "alloc", "std", "proc_macro"];
+        // Walk the lib directory to find the matching rmeta files.
+        // Usually sysroot/lib/rustlib/<target>/lib/
+        let rustlib = sysroot.join("lib").join("rustlib");
+        let mut target_lib_dir = None;
+        if rustlib.exists() {
+            for entry in std::fs::read_dir(rustlib)? {
+                let entry = entry?;
+                let path = entry.path();
+                if path.is_dir() {
+                    let lib_sub = path.join("lib");
+                    if lib_sub.exists() {
+                        // Make sure it's the target directory by checking if any rlib/rmeta is there.
+                        for sub_entry in std::fs::read_dir(&lib_sub)? {
+                            let sub_entry = sub_entry?;
+                            if sub_entry
+                                .path()
+                                .extension()
+                                .is_some_and(|ext| ext == "rmeta" || ext == "rlib")
+                            {
+                                target_lib_dir = Some(Utf8PathBuf::from_path_buf(lib_sub).unwrap());
+                                break;
+                            }
+                        }
+                        if target_lib_dir.is_some() {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        let lib_dir =
+            target_lib_dir.ok_or_else(|| anyhow!("Could not find target lib dir in sysroot"))?;
+
+        for lib in libs {
+            let mut found = None;
+            for entry in std::fs::read_dir(&lib_dir)? {
+                let entry = entry?;
+                let path = entry.path();
+                if let Some(ext) = path.extension() {
+                    if ext == "rmeta"
+                        && let Some(file_name) = path.file_name().and_then(|s| s.to_str())
+                        && file_name.starts_with(&format!("lib{}-", lib))
+                    {
+                        found = Some(Utf8PathBuf::from_path_buf(path).unwrap());
+                        break;
+                    }
+                }
+            }
+            let path = found.ok_or_else(|| anyhow!("Failed to find rmeta for {}", lib))?;
+            rmetas.push((lib.to_string(), path));
+        }
+        Ok(rmetas)
+    }
+
     fn generate_bindings(&self) -> Result<String> {
         let mut pkg_to_header = HashMap::new();
         let mut lib_rs_content = String::new();
         let deps_dir = &self.dirs.deps_dir;
         let headers_dir = &self.dirs.headers_dir;
 
         fs::create_dir_all(headers_dir)?;
+
+        // 1. Locate standard library crates and generate bindings for them first.
+        let sysroot = Self::get_sysroot()?;
+        let stdlib_crates = Self::find_stdlib_rmetas(&sysroot)?;
+        let mut stdlib_externs = Vec::new();
+        for (crate_name, rmeta_path) in &stdlib_crates {
+            let intermediate_h = deps_dir.join(format!("{}.h", crate_name));
+            let final_h = headers_dir.join(format!("{}.h", crate_name));
+            let intermediate_rs = deps_dir.join(format!("lib{}.rs", crate_name));
+
+            if intermediate_h.exists() && intermediate_rs.exists() {
+                pkg_to_header.insert(crate_name.to_string(), format!("{}.h", crate_name));
+                stdlib_externs.push((crate_name.clone(), rmeta_path.clone()));
+                if !final_h.exists() {
+                    fs::copy(&intermediate_h, &final_h)?;
+                }
+                continue;
+            }
+
+            let mut current_args = vec![
+                "cpp_api_from_rust".to_string(),
+                "--crubit-support-path-format=<support/{header}>".to_string(),
+                "--enable-rmeta-interface".to_string(),
+                format!("--source-crate-name={}", crate_name),
+                format!("--h-out={}", intermediate_h),
+                format!("--rs-out={}", intermediate_rs),
+                format!("--extern={}={}", crate_name, rmeta_path),
+                format!("-Ldependency={}", deps_dir.as_str()),
+            ];
+            // Explicitly pass preceding standard library crates to succeeding ones.
+            for (prev_name, prev_path) in &stdlib_externs {
+                current_args.push(format!("--extern={}={}", prev_name, prev_path));
+                if let Some(prev_header) = pkg_to_header.get(prev_name) {
+                    current_args.push(format!("--crate-header={}={}", prev_name, prev_header));
+                }
+            }
+
+            let cmdline = Cmdline::new(&current_args).map_err(|err| {
+                match err.downcast_ref::<clap::Error>() {
+                    Some(clap_err) => {
+                        let _: std::convert::Infallible = clap_err.exit();
+                    }
+                    None => err,
+                }
+            })?;
+            cpp_api_from_rust_lib::run_with_cmdline_args(&cmdline)?;
+            pkg_to_header.insert(crate_name.to_string(), format!("{}.h", crate_name));
+            stdlib_externs.push((crate_name.clone(), rmeta_path.clone()));
+
+            fs::copy(&intermediate_h, &final_h)?;
+        }
+
+        // 2. Generate bindings for user packages in topological order.
         for pkg_id in self.ordered.iter() {
             let Some(artifact_info) = self.pkg_to_artifact.get(&pkg_id.repr) else {
                 continue;
@@ -265,6 +386,15 @@ impl BindingGenerationContext {
                 format!("--extern={}={}", crate_name, artifact_info.path),
                 format!("-Ldependency={}", deps_dir.as_str()),
             ];
+
+            // Pass stdlib dependencies to user crates
+            for (std_name, std_path) in &stdlib_externs {
+                current_args.push(format!("--extern={}={}", std_name, std_path));
+                if let Some(std_header) = pkg_to_header.get(std_name.as_str()) {
+                    current_args.push(format!("--crate-header={}={}", std_name, std_header));
+                }
+            }
+
             let resolve_node = self
                 .resolve
                 .nodes
@@ -381,8 +511,17 @@ bridge_rust = {{ package = "crubit_bridge_rust", version = "0.0.1" }}
             let message =
                 message.map_err(|err| anyhow!("Failed to parse cargo message: {}", err))?;
             // TODO: Extract an iterator wrapper that prints out lines out output and returns artifacts.
-            let Message::CompilerArtifact(artifact) = message else {
-                continue;
+            let artifact = match message {
+                Message::CompilerArtifact(artifact) => artifact,
+                Message::CompilerMessage(msg) => {
+                    eprintln!("{}", msg);
+                    continue;
+                }
+                Message::TextLine(line) => {
+                    println!("{}", line);
+                    continue;
+                }
+                _ => continue,
             };
             if artifact.target.kind.contains(&cargo_metadata::TargetKind::StaticLib) {
                 cargo_static_lib_path = artifact.filenames.first().cloned();

cc_bindings_from_rs/generate_bindings/query_compiler.rs

@@ -77,11 +77,20 @@ pub fn is_c_abi_compatible_by_value<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bo
                 return false;
             };
             #[rustversion::before(2026-04-19)]
-            let ty = tcx.type_of(field.did).instantiate(tcx, substs);
+            let mut ty = tcx.type_of(field.did).instantiate(tcx, substs);
             #[rustversion::since(2026-04-19)]
-            let ty = tcx.type_of(field.did).instantiate(tcx, substs).skip_normalization();
+            let mut ty = tcx.type_of(field.did).instantiate(tcx, substs).skip_normalization();
+
+            // Pattern types can be considered by value when they're embedded within an ADT.
+            // We dont' want to do that for pattern types at large because they might mean they're
+            // in a function signature, and we cannot uphold a pattern types invariants across the
+            // FFI boundary leading to UB.
+            if let ty::TyKind::Pat(pat_ty, _) = ty.kind() {
+                ty = *pat_ty;
+            }
             is_c_abi_compatible_by_value(tcx, ty)
         }
+        ty::TyKind::Pat(_, _) => false,
 
         // Arrays are explicitly not ABI-compatible (though they are layout-compatible).
         ty::TyKind::Array { .. } => false,