implement primary unit rustc

Author: yaahc

src/cargo/core/compiler/build_config.rs

@@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use serde::ser;
 
@@ -26,6 +26,8 @@ pub struct BuildConfig {
     pub build_plan: bool,
     /// An optional wrapper, if any, used to wrap rustc invocations
     pub rustc_wrapper: Option<ProcessBuilder>,
+    /// An optional override of the rustc path for primary units only
+    pub primary_unit_rustc: Option<PathBuf>,
     pub rustfix_diagnostic_server: RefCell<Option<RustfixDiagnosticServer>>,
     /// Whether or not Cargo should cache compiler output on disk.
     cache_messages: bool,
@@ -99,6 +101,7 @@ impl BuildConfig {
             force_rebuild: false,
             build_plan: false,
             rustc_wrapper: None,
+            primary_unit_rustc: None,
             rustfix_diagnostic_server: RefCell::new(None),
             cache_messages: config.cli_unstable().cache_messages,
         })

src/cargo/core/compiler/compilation.rs

@@ -69,6 +69,7 @@ pub struct Compilation<'cfg> {
 
     config: &'cfg Config,
     rustc_process: ProcessBuilder,
+    primary_unit_rustc_process: Option<ProcessBuilder>,
 
     target_runner: Option<(PathBuf, Vec<String>)>,
 }
@@ -77,8 +78,17 @@ impl<'cfg> Compilation<'cfg> {
     pub fn new<'a>(bcx: &BuildContext<'a, 'cfg>) -> CargoResult<Compilation<'cfg>> {
         let mut rustc = bcx.rustc.process();
 
+        let mut primary_unit_rustc_process = bcx
+            .build_config
+            .primary_unit_rustc
+            .as_ref()
+            .map(|primary_unit_rustc| bcx.rustc.process_with(primary_unit_rustc));
+
         if bcx.config.extra_verbose() {
             rustc.display_env_vars();
+            primary_unit_rustc_process.as_mut().map(|rustc| {
+                rustc.display_env_vars();
+            });
         }
 
         Ok(Compilation {
@@ -97,15 +107,29 @@ impl<'cfg> Compilation<'cfg> {
             rustdocflags: HashMap::new(),
             config: bcx.config,
             rustc_process: rustc,
+            primary_unit_rustc_process,
             host: bcx.host_triple().to_string(),
             target: bcx.target_triple().to_string(),
             target_runner: target_runner(bcx)?,
         })
     }
 
     /// See `process`.
-    pub fn rustc_process(&self, pkg: &Package, target: &Target) -> CargoResult<ProcessBuilder> {
-        let mut p = self.fill_env(self.rustc_process.clone(), pkg, true)?;
+    pub fn rustc_process(
+        &self,
+        pkg: &Package,
+        target: &Target,
+        is_primary: bool,
+    ) -> CargoResult<ProcessBuilder> {
+        let rustc = if is_primary {
+            self.primary_unit_rustc_process
+                .clone()
+                .unwrap_or_else(|| self.rustc_process.clone())
+        } else {
+            self.rustc_process.clone()
+        };
+
+        let mut p = self.fill_env(rustc, pkg, true)?;
         if target.edition() != Edition::Edition2015 {
             p.arg(format!("--edition={}", target.edition()));
         }

src/cargo/core/compiler/mod.rs

@@ -180,9 +180,6 @@ fn rustc<'a, 'cfg>(
     exec: &Arc<dyn Executor>,
 ) -> CargoResult<Work> {
     let mut rustc = prepare_rustc(cx, &unit.target.rustc_crate_types(), unit)?;
-    if cx.is_primary_package(unit) {
-        rustc.env("CARGO_PRIMARY_PACKAGE", "1");
-    }
     let build_plan = cx.bcx.build_config.build_plan;
 
     let name = unit.pkg.name().to_string();
@@ -593,7 +590,15 @@ fn prepare_rustc<'a, 'cfg>(
     crate_types: &[&str],
     unit: &Unit<'a>,
 ) -> CargoResult<ProcessBuilder> {
-    let mut base = cx.compilation.rustc_process(unit.pkg, unit.target)?;
+    let is_primary = cx.is_primary_package(unit);
+    let mut base = cx
+        .compilation
+        .rustc_process(unit.pkg, unit.target, is_primary)?;
+
+    if is_primary {
+        base.env("CARGO_PRIMARY_PACKAGE", "1");
+    }
+
     base.inherit_jobserver(&cx.jobserver);
     build_base_args(cx, &mut base, unit, crate_types)?;
     build_deps_args(&mut base, cx, unit)?;

src/cargo/util/rustc.rs

@@ -66,6 +66,18 @@ impl Rustc {
         })
     }
 
+    /// Gets a process builder set up to use the found rustc version, with a wrapper if `Some`.
+    pub fn process_with(&self, path: impl AsRef<Path>) -> ProcessBuilder {
+        match self.wrapper {
+            Some(ref wrapper) if !wrapper.get_program().is_empty() => {
+                let mut cmd = wrapper.clone();
+                cmd.arg(path.as_ref());
+                cmd
+            }
+            _ => util::process(path.as_ref()),
+        }
+    }
+
     /// Gets a process builder set up to use the found rustc version, with a wrapper if `Some`.
     pub fn process(&self) -> ProcessBuilder {
         match self.wrapper {