use RUSTC_WRAPPER instead of RUSTC

fix RUSTC_WRAPPER hacks

Author: jyn514

src/bootstrap/src/bin/rustc.rs

@@ -20,7 +20,7 @@ use std::path::PathBuf;
 use std::process::{Child, Command};
 use std::time::Instant;
 
-use dylib_util::{dylib_path, dylib_path_var};
+use dylib_util::{dylib_path, dylib_path_var, exe};
 
 #[path = "../utils/bin_helpers.rs"]
 mod bin_helpers;
@@ -29,8 +29,10 @@ mod bin_helpers;
 mod dylib_util;
 
 fn main() {
-    let args = env::args_os().skip(1).collect::<Vec<_>>();
-    let arg = |name| args.windows(2).find(|args| args[0] == name).and_then(|args| args[1].to_str());
+    let orig_args = env::args_os().skip(1).collect::<Vec<_>>();
+    let mut args = orig_args.clone();
+    let arg =
+        |name| orig_args.windows(2).find(|args| args[0] == name).and_then(|args| args[1].to_str());
 
     // We don't use the stage in this shim, but let's parse it to make sure that we're invoked
     // by bootstrap, or that we provide a helpful error message if not.
@@ -56,12 +58,33 @@ fn main() {
     let sysroot = env::var_os("RUSTC_SYSROOT").expect("RUSTC_SYSROOT was not set");
     let on_fail = env::var_os("RUSTC_ON_FAIL").map(Command::new);
 
-    let rustc = env::var_os(rustc).unwrap_or_else(|| panic!("{:?} was not set", rustc));
+    let rustc_real = env::var_os(rustc).unwrap_or_else(|| panic!("{:?} was not set", rustc));
     let libdir = env::var_os(libdir).unwrap_or_else(|| panic!("{:?} was not set", libdir));
     let mut dylib_path = dylib_path();
     dylib_path.insert(0, PathBuf::from(&libdir));
 
-    let mut cmd = Command::new(rustc);
+    // if we're running clippy, trust cargo-clippy to set clippy-driver appropriately (and don't override it with rustc).
+    // otherwise, substitute whatever cargo thinks rustc should be with RUSTC_REAL.
+    // NOTE: this means we ignore RUSTC in the environment.
+    // FIXME: We might want to consider removing RUSTC_REAL and setting RUSTC directly?
+    let target_name = target
+        .map(|s| s.to_owned())
+        .unwrap_or_else(|| env::var("CFG_COMPILER_HOST_TRIPLE").unwrap());
+    let is_clippy = args[0].to_string_lossy().ends_with(&exe("clippy-driver", &target_name));
+    let rustc_driver = if is_clippy {
+        args.remove(0)
+    } else {
+        args.remove(0);
+        rustc_real
+    };
+
+    let mut cmd = if let Some(wrapper) = env::var_os("RUSTC_WRAPPER_REAL") {
+        let mut cmd = Command::new(wrapper);
+        cmd.arg(rustc_driver);
+        cmd
+    } else {
+        Command::new(rustc_driver)
+    };
     cmd.args(&args).env(dylib_path_var(), env::join_paths(&dylib_path).unwrap());
 
     // Get the name of the crate we're compiling, if any.

src/bootstrap/src/core/builder.rs

@@ -1614,7 +1614,17 @@ impl<'a> Builder<'a> {
         // Clippy support is a hack and uses the default `cargo-clippy` in path.
         // Don't override RUSTC so that the `cargo-clippy` in path will be run.
         if cmd != "clippy" {
-            cargo.env("RUSTC", self.bootstrap_out.join("rustc"));
+            // Set RUSTC_WRAPPER to the bootstrap shim, which switches between beta and in-tree
+            // sysroot depending on whether we're building build scripts.
+            // NOTE: we intentionally use RUSTC_WRAPPER so that we can support clippy - RUSTC is not
+            // respected by clippy-driver; RUSTC_WRAPPER happens earlier, before clippy runs.
+            cargo.env("RUSTC_WRAPPER", self.bootstrap_out.join("rustc"));
+
+            // Someone might have set some previous rustc wrapper (e.g.
+            // sccache) before bootstrap overrode it. Respect that variable.
+            if let Some(existing_wrapper) = env::var_os("RUSTC_WRAPPER") {
+                cargo.env("RUSTC_WRAPPER_REAL", existing_wrapper);
+            }
         }
 
         // Dealing with rpath here is a little special, so let's go into some

src/bootstrap/src/utils/dylib.rs

@@ -25,3 +25,16 @@ pub fn dylib_path() -> Vec<std::path::PathBuf> {
     };
     std::env::split_paths(&var).collect()
 }
+
+/// Given an executable called `name`, return the filename for the
+/// executable for a particular target.
+#[allow(dead_code)]
+pub fn exe(name: &str, target: &str) -> String {
+    if target.contains("windows") {
+        format!("{name}.exe")
+    } else if target.contains("uefi") {
+        format!("{name}.efi")
+    } else {
+        name.to_string()
+    }
+}

src/bootstrap/src/utils/helpers.rs

@@ -45,16 +45,8 @@ macro_rules! t {
 }
 pub use t;
 
-/// Given an executable called `name`, return the filename for the
-/// executable for a particular target.
 pub fn exe(name: &str, target: TargetSelection) -> String {
-    if target.contains("windows") {
-        format!("{name}.exe")
-    } else if target.contains("uefi") {
-        format!("{name}.efi")
-    } else {
-        name.to_string()
-    }
+    crate::utils::dylib::exe(name, &target.triple)
 }
 
 /// Returns `true` if the file name given looks like a dynamic library.