Thread in-tree information through Mode

rust-lang · Centril · Aug 21, 2019 · Aug 27, 2019 · Aug 27, 2019 · Aug 30, 2019
commit 669c3e3b935014f6f3e3c30eae1ddd55806490f9
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
@@ -765,7 +765,9 @@ impl<'a> Builder<'a> {
         if cmd == "doc" || cmd == "rustdoc" {
             let my_out = match mode {
                 // This is the intended out directory for compiler documentation.
-                Mode::Rustc | Mode::ToolRustc | Mode::Codegen => self.compiler_doc_out(target),
+                Mode::Rustc | Mode::ToolRustc { .. } | Mode::Codegen => {
+                    self.compiler_doc_out(target)
+                }
                 _ => self.crate_doc_out(target),
             };
             let rustdoc = self.rustdoc(compiler);
@@ -797,8 +799,8 @@ impl<'a> Builder<'a> {
         }
 
         match mode {
-            Mode::Std | Mode::ToolBootstrap | Mode::ToolStd => {},
-            Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
+            Mode::Std | Mode::ToolBootstrap { .. } | Mode::ToolStd { .. } => {},
+            Mode::Rustc | Mode::Codegen | Mode::ToolRustc { .. } => {
                 // Build proc macros both for the host and the target
                 if target != compiler.host && cmd != "check" {
                     cargo.arg("-Zdual-proc-macros");
@@ -891,7 +893,11 @@ impl<'a> Builder<'a> {
         // the stage0 build means it uses libraries build by the stage0
         // compiler, but for tools we just use the precompiled libraries that
         // we've downloaded
-        let use_snapshot = mode == Mode::ToolBootstrap;
+        let use_snapshot = if let Mode::ToolBootstrap { .. } = mode {
+            true
+        } else {
+            false
+        };
         assert!(!use_snapshot || stage == 0 || self.local_rebuild);
 
         let maybe_sysroot = self.sysroot(compiler);
@@ -944,8 +950,9 @@ impl<'a> Builder<'a> {
         let debuginfo_level = match mode {
             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
             Mode::Std => self.config.rust_debuginfo_level_std,
-            Mode::ToolBootstrap | Mode::ToolStd |
-            Mode::ToolRustc => self.config.rust_debuginfo_level_tools,
+            Mode::ToolBootstrap { .. } | Mode::ToolStd { .. } | Mode::ToolRustc { .. } => {
+                self.config.rust_debuginfo_level_tools
+            }
         };
         cargo.env("RUSTC_DEBUGINFO_LEVEL", debuginfo_level.to_string());
 

diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs
@@ -3,7 +3,7 @@
 use crate::compile::{run_cargo, std_cargo, rustc_cargo, rustc_cargo_env,
                      add_to_sysroot};
 use crate::builder::{RunConfig, Builder, Kind, ShouldRun, Step};
-use crate::tool::{prepare_tool_cargo, SourceType};
+use crate::tool::prepare_tool_cargo;
 use crate::{Compiler, Mode};
 use crate::cache::{INTERNER, Interned};
 use std::path::PathBuf;
@@ -187,11 +187,10 @@ impl Step for Rustdoc {
 
         let mut cargo = prepare_tool_cargo(builder,
                                            compiler,
-                                           Mode::ToolRustc,
+                                           Mode::ToolRustc { in_tree: true },
                                            target,
                                            cargo_subcommand(builder.kind),
                                            "src/tools/rustdoc",
-                                           SourceType::InTree,
                                            &[]);
 
         println!("Checking rustdoc artifacts ({} -> {})", &compiler.host, target);
@@ -244,6 +243,7 @@ pub fn rustdoc_stamp(
     compiler: Compiler,
     target: Interned<String>,
 ) -> PathBuf {
-    builder.cargo_out(compiler, Mode::ToolRustc, target)
+    // doesn't really matter whether we're in-tree or not
+    builder.cargo_out(compiler, Mode::ToolRustc { in_tree: true }, target)
         .join(".rustdoc-check.stamp")
 }
diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs
@@ -17,7 +17,7 @@ use build_helper::{t, up_to_date};
 
 use crate::util::symlink_dir;
 use crate::builder::{Builder, Compiler, RunConfig, ShouldRun, Step};
-use crate::tool::{self, prepare_tool_cargo, Tool, SourceType};
+use crate::tool::{self, prepare_tool_cargo, Tool};
 use crate::compile;
 use crate::cache::{INTERNER, Interned};
 use crate::config::Config;
@@ -633,7 +633,7 @@ impl Step for Rustdoc {
         builder.ensure(tool::Rustdoc { compiler: compiler });
 
         // Symlink compiler docs to the output directory of rustdoc documentation.
-        let out_dir = builder.stage_out(compiler, Mode::ToolRustc)
+        let out_dir = builder.stage_out(compiler, Mode::ToolRustc { in_tree: true })
             .join(target)
             .join("doc");
         t!(fs::create_dir_all(&out_dir));
@@ -643,11 +643,10 @@ impl Step for Rustdoc {
         let mut cargo = prepare_tool_cargo(
             builder,
             compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustc { in_tree: true },
             target,
             "doc",
             "src/tools/rustdoc",
-            SourceType::InTree,
             &[]
         );
 

diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
@@ -304,19 +304,19 @@ pub enum Mode {
     /// "other" here is for miscellaneous sets of tools that are built using the
     /// bootstrap compiler in its entirety (target libraries and all).
     /// Typically these tools compile with stable Rust.
-    ToolBootstrap,
+    ToolBootstrap { in_tree: bool },
 
     /// Compile a tool which uses all libraries we compile (up to rustc).
     /// Doesn't use the stage0 compiler libraries like "other", and includes
     /// tools like rustdoc, cargo, rls, etc.
-    ToolStd,
-    ToolRustc,
+    ToolStd { in_tree: bool },
+    ToolRustc { in_tree: bool },
 }
 
 impl Mode {
     pub fn is_tool(&self) -> bool {
         match self {
-            Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd => true,
+            Mode::ToolBootstrap { .. } | Mode::ToolRustc { .. } | Mode::ToolStd { .. } => true,
             _ => false
         }
     }
@@ -528,8 +528,8 @@ impl Build {
             Mode::Std => "-std",
             Mode::Rustc => "-rustc",
             Mode::Codegen => "-codegen",
-            Mode::ToolBootstrap => "-bootstrap-tools",
-            Mode::ToolStd | Mode::ToolRustc => "-tools",
+            Mode::ToolBootstrap { .. } => "-bootstrap-tools",
+            Mode::ToolStd { .. } | Mode::ToolRustc { .. } => "-tools",
         };
         self.out.join(&*compiler.host)
                 .join(format!("stage{}{}", compiler.stage, suffix))

diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
@@ -19,7 +19,7 @@ use crate::compile;
 use crate::dist;
 use crate::flags::Subcommand;
 use crate::native;
-use crate::tool::{self, Tool, SourceType};
+use crate::tool::{self, Tool};
 use crate::toolstate::ToolState;
 use crate::util::{self, dylib_path, dylib_path_var};
 use crate::Crate as CargoCrate;
@@ -213,11 +213,10 @@ impl Step for Cargo {
         });
         let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolRustc,
+                                                 Mode::ToolRustc { in_tree: false },
                                                  self.host,
                                                  "test",
                                                  "src/tools/cargo",
-                                                 SourceType::Submodule,
                                                  &[]);
 
         if !builder.fail_fast {
@@ -279,11 +278,10 @@ impl Step for Rls {
 
         let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolRustc,
+                                                 Mode::ToolRustc { in_tree: false },
                                                  host,
                                                  "test",
                                                  "src/tools/rls",
-                                                 SourceType::Submodule,
                                                  &[]);
 
         builder.add_rustc_lib_path(compiler, &mut cargo);
@@ -335,11 +333,10 @@ impl Step for Rustfmt {
 
         let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolRustc,
+                                                 Mode::ToolRustc { in_tree: false },
                                                  host,
                                                  "test",
                                                  "src/tools/rustfmt",
-                                                 SourceType::Submodule,
                                                  &[]);
 
         let dir = testdir(builder, compiler.host);
@@ -392,11 +389,10 @@ impl Step for Miri {
             let mut cargo = tool::prepare_tool_cargo(
                 builder,
                 compiler,
-                Mode::ToolRustc,
+                Mode::ToolRustc { in_tree: false },
                 host,
                 "run",
                 "src/tools/miri",
-                SourceType::Submodule,
                 &[],
             );
             cargo
@@ -451,11 +447,10 @@ impl Step for Miri {
             let mut cargo = tool::prepare_tool_cargo(
                 builder,
                 compiler,
-                Mode::ToolRustc,
+                Mode::ToolRustc { in_tree: false },
                 host,
                 "test",
                 "src/tools/miri",
-                SourceType::Submodule,
                 &[],
             );
 
@@ -504,11 +499,10 @@ impl Step for CompiletestTest {
 
         let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolBootstrap,
+                                                 Mode::ToolBootstrap { in_tree: true },
                                                  host,
                                                  "test",
                                                  "src/tools/compiletest",
-                                                 SourceType::InTree,
                                                  &[]);
 
         try_run(builder, &mut cargo);
@@ -551,19 +545,18 @@ impl Step for Clippy {
         if let Some(clippy) = clippy {
             let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolRustc,
+                                                 Mode::ToolRustc { in_tree: false },
                                                  host,
                                                  "test",
                                                  "src/tools/clippy",
-                                                 SourceType::Submodule,
                                                  &[]);
 
             // clippy tests need to know about the stage sysroot
             cargo.env("SYSROOT", builder.sysroot(compiler));
             cargo.env("RUSTC_TEST_SUITE", builder.rustc(compiler));
             cargo.env("RUSTC_LIB_PATH", builder.rustc_libdir(compiler));
             let host_libs = builder
-                .stage_out(compiler, Mode::ToolRustc)
+                .stage_out(compiler, Mode::ToolRustc { in_tree: false })
                 .join(builder.cargo_dir());
             cargo.env("HOST_LIBS", host_libs);
             // clippy tests need to find the driver
@@ -1877,11 +1870,10 @@ impl Step for CrateRustdoc {
 
         let mut cargo = tool::prepare_tool_cargo(builder,
                                                  compiler,
-                                                 Mode::ToolRustc,
+                                                 Mode::ToolRustc { in_tree: true },
                                                  target,
                                                  test_kind.subcommand(),
                                                  "src/tools/rustdoc",
-                                                 SourceType::InTree,
                                                  &[]);
         if test_kind.subcommand() == "test" && !builder.fail_fast {
             cargo.arg("--no-fail-fast");