Thread in-tree information through Mode

Author: Mark-Simulacrum

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());
 

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")
 }

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,
  &[]
  );
 

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))

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");