use BootstrapCommand in builder::Cargo

Signed-off-by: onur-ozkan <work@onurozkan.dev>

Author: onur-ozkan

Diff for: src/bootstrap/src/core/builder.rs

@@ -21,6 +21,7 @@ use crate::core::config::flags::{Color, Subcommand};
 use crate::core::config::{DryRun, SplitDebuginfo, TargetSelection};
 use crate::prepare_behaviour_dump_dir;
 use crate::utils::cache::Cache;
+use crate::utils::exec::BootstrapCommand;
 use crate::utils::helpers::{self, add_dylib_path, add_link_lib_path, exe, linker_args};
 use crate::utils::helpers::{check_cfg_arg, libdir, linker_flags, output, t, LldThreads};
 use crate::EXTRA_CHECK_CFGS;
@@ -2152,7 +2153,7 @@ impl<'a> Builder<'a> {
         });
 
         Cargo {
-            command: cargo,
+            bootstrap_command: cargo.into(),
             compiler,
             target,
             rustflags,
@@ -2382,7 +2383,7 @@ impl HostFlags {
 
 #[derive(Debug)]
 pub struct Cargo {
-    command: Command,
+    bootstrap_command: BootstrapCommand,
     compiler: Compiler,
     target: TargetSelection,
     rustflags: Rustflags,
@@ -2429,7 +2430,7 @@ impl Cargo {
     }
 
     pub fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Cargo {
-        self.command.arg(arg.as_ref());
+        self.bootstrap_command.inner_command.arg(arg.as_ref());
         self
     }
 
@@ -2448,16 +2449,16 @@ impl Cargo {
         // These are managed through rustflag/rustdocflag interfaces.
         assert_ne!(key.as_ref(), "RUSTFLAGS");
         assert_ne!(key.as_ref(), "RUSTDOCFLAGS");
-        self.command.env(key.as_ref(), value.as_ref());
+        self.bootstrap_command.inner_command.env(key.as_ref(), value.as_ref());
         self
     }
 
     pub fn add_rustc_lib_path(&mut self, builder: &Builder<'_>) {
-        builder.add_rustc_lib_path(self.compiler, &mut self.command);
+        builder.add_rustc_lib_path(self.compiler, &mut self.bootstrap_command.inner_command);
     }
 
     pub fn current_dir(&mut self, dir: &Path) -> &mut Cargo {
-        self.command.current_dir(dir);
+        self.bootstrap_command.inner_command.current_dir(dir);
         self
     }
 
@@ -2530,7 +2531,9 @@ impl Cargo {
 
         if let Some(target_linker) = builder.linker(target) {
             let target = crate::envify(&target.triple);
-            self.command.env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
+            self.bootstrap_command
+                .inner_command
+                .env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
         }
         // We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not
         // `linker_args` here.
@@ -2560,7 +2563,7 @@ impl Cargo {
                 // https://github.com/llvm/llvm-project/pull/81849. This is
                 // fixed in LLVM 19, but can't be backported.
                 if !target.starts_with("aarch64") && !target.starts_with("arm64ec") {
-                    self.command.env("CC", cl).env("CXX", cl);
+                    self.bootstrap_command.inner_command.env("CC", cl).env("CXX", cl);
                 }
             }
         } else {
@@ -2582,22 +2585,26 @@ impl Cargo {
             };
             let triple_underscored = target.triple.replace('-', "_");
             let cc = ccacheify(&builder.cc(target));
-            self.command.env(format!("CC_{triple_underscored}"), &cc);
+            self.bootstrap_command.inner_command.env(format!("CC_{triple_underscored}"), &cc);
 
             let cflags = builder.cflags(target, GitRepo::Rustc, CLang::C).join(" ");
-            self.command.env(format!("CFLAGS_{triple_underscored}"), &cflags);
+            self.bootstrap_command
+                .inner_command
+                .env(format!("CFLAGS_{triple_underscored}"), &cflags);
 
             if let Some(ar) = builder.ar(target) {
                 let ranlib = format!("{} s", ar.display());
-                self.command
+                self.bootstrap_command
+                    .inner_command
                     .env(format!("AR_{triple_underscored}"), ar)
                     .env(format!("RANLIB_{triple_underscored}"), ranlib);
             }
 
             if let Ok(cxx) = builder.cxx(target) {
                 let cxx = ccacheify(&cxx);
                 let cxxflags = builder.cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");
-                self.command
+                self.bootstrap_command
+                    .inner_command
                     .env(format!("CXX_{triple_underscored}"), &cxx)
                     .env(format!("CXXFLAGS_{triple_underscored}"), cxxflags);
             }
@@ -2611,23 +2618,23 @@ impl From<Cargo> for Command {
     fn from(mut cargo: Cargo) -> Command {
         let rustflags = &cargo.rustflags.0;
         if !rustflags.is_empty() {
-            cargo.command.env("RUSTFLAGS", rustflags);
+            cargo.bootstrap_command.inner_command.env("RUSTFLAGS", rustflags);
         }
 
         let rustdocflags = &cargo.rustdocflags.0;
         if !rustdocflags.is_empty() {
-            cargo.command.env("RUSTDOCFLAGS", rustdocflags);
+            cargo.bootstrap_command.inner_command.env("RUSTDOCFLAGS", rustdocflags);
         }
 
         let encoded_hostflags = cargo.hostflags.encode();
         if !encoded_hostflags.is_empty() {
-            cargo.command.env("RUSTC_HOST_FLAGS", encoded_hostflags);
+            cargo.bootstrap_command.inner_command.env("RUSTC_HOST_FLAGS", encoded_hostflags);
         }
 
         if !cargo.allow_features.is_empty() {
-            cargo.command.env("RUSTC_ALLOW_FEATURES", cargo.allow_features);
+            cargo.bootstrap_command.inner_command.env("RUSTC_ALLOW_FEATURES", cargo.allow_features);
         }
 
-        cargo.command
+        cargo.bootstrap_command.inner_command
     }
 }