Construct a crate to produce the staticlib in the subcommand.

This solves the issue of how does generated Rust code for bindings
depend on `bridge.rs`. We create a Cargo.toml package for the generated
rust code and use that to produce a staticlib. The Cargo.toml can then
depend on `bridge.rs`. We're okay with this dependency being implicit
like this because we want the subcommand to control which version of
bridge.rs is used (and we only want to change versions when subcommand
versions are changed).

PiperOrigin-RevId: 901485778

Author: thunderseethe

cc_bindings_from_rs/cargo-cpp_api_from_rust.rs

@@ -193,7 +193,6 @@ fn main() -> Result<()> {
             pkg_to_header.insert(pkg_id.repr, intermediate_h.to_string());
             lib_rs_content
                 .push_str(&format!("#[path = {:?}]\nmod r#{};\n", intermediate_rs, rs_crate_name));
-            // Final outputs: copy/rename from deps/ to their final locations.
             if !final_h.exists() {
                 fs::copy(&intermediate_h, &final_h)?;
             }
@@ -254,21 +253,84 @@ fn main() -> Result<()> {
     fs::write(&lib_rs_path, lib_rs_content)?;
 
     let static_lib_path = target_dir.join(&profile_dir).join(format!("lib{}.a", root_name));
-    let mut final_rustc_args = vec![
-        "rustc".to_string(),
-        lib_rs_path.to_string(),
-        format!("--edition={}", edition),
-        format!("--crate-name={}_cc_api", root_name),
-        "--crate-type=staticlib".to_string(),
-        format!("-Ldependency={}", deps_dir.as_str()),
-        "-o".to_string(),
-        static_lib_path.to_string(),
-    ];
-    for (_, artifact_info) in pkg_to_artifact.iter() {
-        final_rustc_args.push(format!("--extern={}={}", artifact_info.name, artifact_info.path));
+    let mut cargo_toml_content = format!(
+        r#"[package]
+name = "{root_name}-cc-api"
+version = "0.1.0"
+edition = "{edition}"
+
+[lib]
+path = "{lib_rs_filename}"
+crate-type = ["staticlib"]
+
+[dependencies]
+crubit_bridge_rust = "0.0.1"
+"#,
+        root_name = root_name,
+        edition = edition,
+        lib_rs_filename = lib_rs_path.file_name().unwrap(),
+    );
+
+    let pkg_id_to_package: HashMap<_, _> =
+        metadata.packages.iter().map(|p| (p.id.clone(), p)).collect();
+    let root_node = resolve
+        .nodes
+        .iter()
+        .find(|n| n.id == root.id)
+        .expect("Root package must be in resolve graph");
+
+    for dep in &root_node.dependencies {
+        let pkg = pkg_id_to_package.get(dep).expect("Dependency must be in package list");
+        if let Some(source) = &pkg.source {
+            if source.is_crates_io() {
+                cargo_toml_content.push_str(&format!("{} = \"{}\"\n", pkg.name, pkg.version));
+            } else {
+                // If it's not crates.io, we may need a more complex way to resolve it.
+                // For now, we'll try to use the path if it's available.
+                cargo_toml_content.push_str(&format!(
+                    "{} = {{ path = {:?} }}\n",
+                    pkg.name,
+                    pkg.manifest_path.parent().unwrap()
+                ));
+            }
+        } else {
+            // No source means it's a local/path dependency.
+            // We need to find the relative path from deps_dir to the package's directory.
+            let pkg_dir = pkg.manifest_path.parent().unwrap();
+            cargo_toml_content.push_str(&format!("{} = {{ path = {:?} }}\n", pkg.name, pkg_dir));
+        }
     }
 
-    cpp_api_from_rust_lib::run_rustc(&final_rustc_args);
+    let cargo_toml_path = deps_dir.join("Cargo.toml");
+    fs::write(&cargo_toml_path, cargo_toml_content)?;
+
+    let mut cargo_build = Command::new(cargo_bin());
+    cargo_build.args([
+        "build",
+        "--manifest-path",
+        cargo_toml_path.as_str(),
+        format!("--target-dir={}", target_dir).as_str(),
+    ]);
+
+    let profile = if profile_dir.as_str() == "release" { "--release" } else { "--debug" };
+    if profile == "--release" {
+        cargo_build.arg("--release");
+    }
+
+    let status =
+        cargo_build.status().map_err(|err| anyhow!("Failed to run cargo build: {}", err))?;
+    if !status.success() {
+        bail!("Cargo build of bindings failed");
+    }
+
+    // Cargo will output to target_dir/profile/staticlibname.a
+    // The previous implementation expected it at lib{root_name}.a directly under the profile dir.
+    let cargo_static_lib_path =
+        target_dir.join(&profile_dir).join(format!("lib{}_cc_api.a", root_name.replace('-', "_")));
+
+    if cargo_static_lib_path.exists() {
+        fs::copy(&cargo_static_lib_path, &static_lib_path)?;
+    }
 
     Ok(())
 }