Use cross compile style target/host isolation for all builds.

Author: jameshilliard

crates/cargo-test-support/src/lib.rs

@@ -256,12 +256,22 @@ impl Project {
         self.root.clone()
     }
 
-    /// Project's target dir, ex: `/path/to/cargo/target/cit/t0/foo/target`
+    /// Project's target dir, ex: `/path/to/cargo/target/cit/t0/foo/target/target-triple`
     pub fn build_dir(&self) -> PathBuf {
-        self.root().join("target")
+        self.root().join("target").join(rustc_host())
     }
 
-    /// Project's debug dir, ex: `/path/to/cargo/target/cit/t0/foo/target/debug`
+    /// Project's target dir, ex: `/path/to/cargo/target/cit/t0/foo/target/host/host-triple`
+    pub fn host_dir(&self) -> PathBuf {
+        self.root().join("target/host").join(rustc_host())
+    }
+
+    /// Project's debug dir, ex: `/path/to/cargo/target/cit/t0/foo/target/host/host-triple/debug`
+    pub fn host_debug_dir(&self) -> PathBuf {
+        self.host_dir().join("debug")
+    }
+
+    /// Project's debug dir, ex: `/path/to/cargo/target/cit/t0/foo/target/target-triple/debug`
     pub fn target_debug_dir(&self) -> PathBuf {
         self.build_dir().join("debug")
     }
@@ -280,16 +290,25 @@ impl Project {
             .join(paths::get_lib_filename(name, kind))
     }
 
+    /// Path to an example built as a library.
+    /// `kind` should be one of: "lib", "rlib", "staticlib", "dylib", "proc-macro"
+    /// ex: `/path/to/cargo/target/cit/t0/foo/target/host/host-triple/debug/examples/libex.rlib`
+    pub fn host_example_lib(&self, name: &str, kind: &str) -> PathBuf {
+        self.host_debug_dir()
+            .join("examples")
+            .join(paths::get_lib_filename(name, kind))
+    }
+
     /// Path to a debug binary.
-    /// ex: `/path/to/cargo/target/cit/t0/foo/target/debug/foo`
+    /// ex: `/path/to/cargo/target/target-triple/cit/t0/foo/target/target-triple/debug/foo`
     pub fn bin(&self, b: &str) -> PathBuf {
         self.build_dir()
             .join("debug")
             .join(&format!("{}{}", b, env::consts::EXE_SUFFIX))
     }
 
     /// Path to a release binary.
-    /// ex: `/path/to/cargo/target/cit/t0/foo/target/release/foo`
+    /// ex: `/path/to/cargo/target/target-triple/cit/t0/foo/target/target-triple/release/foo`
     pub fn release_bin(&self, b: &str) -> PathBuf {
         self.build_dir()
             .join("release")
@@ -299,11 +318,11 @@ impl Project {
     /// Path to a debug binary for a specific target triple.
     /// ex: `/path/to/cargo/target/cit/t0/foo/target/i686-apple-darwin/debug/foo`
     pub fn target_bin(&self, target: &str, b: &str) -> PathBuf {
-        self.build_dir().join(target).join("debug").join(&format!(
-            "{}{}",
-            b,
-            env::consts::EXE_SUFFIX
-        ))
+        self.root()
+            .join("target")
+            .join(target)
+            .join("debug")
+            .join(&format!("{}{}", b, env::consts::EXE_SUFFIX))
     }
 
     /// Returns an iterator of paths matching the glob pattern, which is

src/bin/cargo/commands/bench.rs

@@ -51,8 +51,10 @@ pub fn cli() -> App {
 
 pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     let ws = args.workspace(config)?;
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts = args.compile_options(
         config,
+        rustc,
         CompileMode::Bench,
         Some(&ws),
         ProfileChecking::Checked,

src/bin/cargo/commands/build.rs

@@ -49,8 +49,10 @@ pub fn cli() -> App {
 
 pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     let ws = args.workspace(config)?;
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts = args.compile_options(
         config,
+        rustc,
         CompileMode::Build,
         Some(&ws),
         ProfileChecking::Checked,

src/bin/cargo/commands/check.rs

@@ -54,7 +54,9 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         }
     };
     let mode = CompileMode::Check { test };
-    let compile_opts = args.compile_options(config, mode, Some(&ws), ProfileChecking::Unchecked)?;
+    let rustc = config.load_global_rustc(Some(&ws));
+    let compile_opts =
+        args.compile_options(config, rustc, mode, Some(&ws), ProfileChecking::Unchecked)?;
 
     ops::compile(&ws, &compile_opts)?;
     Ok(())

src/bin/cargo/commands/doc.rs

@@ -40,8 +40,9 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     let mode = CompileMode::Doc {
         deps: !args.is_present("no-deps"),
     };
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts =
-        args.compile_options(config, mode, Some(&ws), ProfileChecking::Checked)?;
+        args.compile_options(config, rustc, mode, Some(&ws), ProfileChecking::Checked)?;
     compile_opts.rustdoc_document_private_items = args.is_present("document-private-items");
 
     let doc_opts = DocOptions {

src/bin/cargo/commands/fix.rs

@@ -83,7 +83,9 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
 
     // Unlike other commands default `cargo fix` to all targets to fix as much
     // code as we can.
-    let mut opts = args.compile_options(config, mode, Some(&ws), ProfileChecking::Unchecked)?;
+    let rustc = config.load_global_rustc(Some(&ws));
+    let mut opts =
+        args.compile_options(config, rustc, mode, Some(&ws), ProfileChecking::Unchecked)?;
 
     if let CompileFilter::Default { .. } = opts.filter {
         opts.filter = CompileFilter::Only {

src/bin/cargo/commands/install.rs

@@ -127,8 +127,15 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         None
     };
 
+    let ws = args.workspace(config);
+    let rustc = if ws.is_ok() {
+        config.load_global_rustc(Some(&ws?))
+    } else {
+        config.load_global_rustc(None)
+    };
     let mut compile_opts = args.compile_options(
         config,
+        rustc,
         CompileMode::Build,
         workspace.as_ref(),
         ProfileChecking::Checked,

src/bin/cargo/commands/run.rs

@@ -33,8 +33,10 @@ pub fn cli() -> App {
 pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     let ws = args.workspace(config)?;
 
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts = args.compile_options(
         config,
+        rustc,
         CompileMode::Build,
         Some(&ws),
         ProfileChecking::Checked,

src/bin/cargo/commands/rustc.rs

@@ -60,8 +60,10 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
             return Err(CliError::new(err, 101));
         }
     };
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts = args.compile_options_for_single_package(
         config,
+        rustc,
         mode,
         Some(&ws),
         ProfileChecking::Unchecked,

src/bin/cargo/commands/rustdoc.rs

@@ -40,8 +40,10 @@ pub fn cli() -> App {
 
 pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     let ws = args.workspace(config)?;
+    let rustc = config.load_global_rustc(Some(&ws));
     let mut compile_opts = args.compile_options_for_single_package(
         config,
+        rustc,
         CompileMode::Doc { deps: false },
         Some(&ws),
         ProfileChecking::Checked,