From 64a2abc11c533b11ffd01a5659f02f19a712b1ff Mon Sep 17 00:00:00 2001 From: Krasimir Georgiev Date: Thu, 7 Jul 2022 10:12:05 +0000 Subject: [PATCH] Revert "Rollup merge of #95503 - jyn514:build-single-crate, r=Mark-Simulacrum" This reverts commit 0a7f2c3a025c8bab1e10ccec6208a4c19b057b26, reversing changes made to 41ad4d9b2dbb895666337d162eda52619a6056db. --- src/bootstrap/builder.rs | 19 ++--- src/bootstrap/builder/tests.rs | 125 ++++++++++++++++----------------- src/bootstrap/cache.rs | 123 ++++++++++++++++++-------------- src/bootstrap/check.rs | 4 +- src/bootstrap/compile.rs | 77 ++++---------------- src/bootstrap/dist.rs | 6 +- src/bootstrap/doc.rs | 12 ++-- src/bootstrap/test.rs | 32 ++++----- src/bootstrap/tool.rs | 10 +-- 9 files changed, 182 insertions(+), 226 deletions(-) diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index dc6a0f6f24146..fa2a530d9db68 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -13,6 +13,7 @@ use std::process::{Command, Stdio}; use std::time::{Duration, Instant}; use crate::cache::{Cache, Interned, INTERNER}; +use crate::compile; use crate::config::{SplitDebuginfo, TargetSelection}; use crate::dist; use crate::doc; @@ -25,7 +26,6 @@ use crate::tool::{self, SourceType}; use crate::util::{self, add_dylib_path, add_link_lib_path, exe, libdir, output, t}; use crate::EXTRA_CHECK_CFGS; use crate::{check, Config}; -use crate::{compile, Crate}; use crate::{Build, CLang, DocTests, GitRepo, Mode}; pub use crate::Compiler; @@ -304,7 +304,9 @@ impl StepDescription { if paths.is_empty() || builder.config.include_default_paths { for (desc, should_run) in v.iter().zip(&should_runs) { if desc.default && should_run.is_really_default() { - desc.maybe_run(builder, should_run.paths.iter().cloned().collect()); + for pathset in &should_run.paths { + desc.maybe_run(builder, vec![pathset.clone()]); + } } } } @@ -422,16 +424,8 @@ impl<'a> ShouldRun<'a> { /// any of its (local) dependencies. /// /// `make_run` will be called a single time with all matching command-line paths. - pub fn crate_or_deps(self, name: &str) -> Self { - let crates = self.builder.in_tree_crates(name, None); - self.crates(crates) - } - - /// Indicates it should run if the command-line selects any of the given crates. - /// - /// `make_run` will be called a single time with all matching command-line paths. - pub(crate) fn crates(mut self, crates: Vec<&Crate>) -> Self { - for krate in crates { + pub fn krate(mut self, name: &str) -> Self { + for krate in self.builder.in_tree_crates(name, None) { let path = krate.local_path(self.builder); self.paths.insert(PathSet::one(path, self.kind)); } @@ -587,7 +581,6 @@ impl<'a> Builder<'a> { match kind { Kind::Build => describe!( compile::Std, - compile::Rustc, compile::Assemble, compile::CodegenBackend, compile::StartupObjects, diff --git a/src/bootstrap/builder/tests.rs b/src/bootstrap/builder/tests.rs index c084e77d3a994..70cb0de7cce04 100644 --- a/src/bootstrap/builder/tests.rs +++ b/src/bootstrap/builder/tests.rs @@ -57,24 +57,6 @@ fn check_cli(paths: [&str; N]) { ); } -macro_rules! std { - ($host:ident => $target:ident, stage = $stage:literal) => { - compile::Std::new( - Compiler { host: TargetSelection::from_user(stringify!($host)), stage: $stage }, - TargetSelection::from_user(stringify!($target)), - ) - }; -} - -macro_rules! rustc { - ($host:ident => $target:ident, stage = $stage:literal) => { - compile::Rustc::new( - Compiler { host: TargetSelection::from_user(stringify!($host)), stage: $stage }, - TargetSelection::from_user(stringify!($target)), - ) - }; -} - #[test] fn test_valid() { // make sure multi suite paths are accepted @@ -135,17 +117,6 @@ fn test_exclude_kind() { assert!(run_build(&[path], config).contains::()); } -/// Ensure that if someone passes both a single crate and `library`, all library crates get built. -#[test] -fn alias_and_path_for_library() { - let mut cache = - run_build(&["library".into(), "core".into()], configure("build", &["A"], &["A"])); - assert_eq!( - first(cache.all::()), - &[std!(A => A, stage = 0), std!(A => A, stage = 1)] - ); -} - mod defaults { use super::{configure, first, run_build}; use crate::builder::*; @@ -159,7 +130,10 @@ mod defaults { let a = TargetSelection::from_user("A"); assert_eq!( first(cache.all::()), - &[std!(A => A, stage = 0), std!(A => A, stage = 1),] + &[ + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + ] ); assert!(!cache.all::().is_empty()); // Make sure rustdoc is only built once. @@ -169,7 +143,10 @@ mod defaults { // - this is the compiler it's _linked_ to, not built with. &[tool::Rustdoc { compiler: Compiler { host: a, stage: 1 } }], ); - assert_eq!(first(cache.all::()), &[rustc!(A => A, stage = 0)],); + assert_eq!( + first(cache.all::()), + &[compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a },] + ); } #[test] @@ -178,7 +155,10 @@ mod defaults { let mut cache = run_build(&[], config); let a = TargetSelection::from_user("A"); - assert_eq!(first(cache.all::()), &[std!(A => A, stage = 0)]); + assert_eq!( + first(cache.all::()), + &[compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a },] + ); assert!(!cache.all::().is_empty()); assert_eq!( first(cache.all::()), @@ -205,10 +185,10 @@ mod defaults { assert_eq!( first(cache.all::()), &[ - std!(A => A, stage = 0), - std!(A => A, stage = 1), - std!(A => B, stage = 0), - std!(A => B, stage = 1), + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: b }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, ] ); assert_eq!( @@ -228,7 +208,10 @@ mod defaults { ); assert_eq!( first(cache.all::()), - &[rustc!(A => A, stage = 0), rustc!(A => B, stage = 0),] + &[ + compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: b }, + ] ); } @@ -351,11 +334,11 @@ mod dist { assert_eq!( first(cache.all::()), &[ - std!(A => A, stage = 0), - std!(A => A, stage = 1), - std!(A => A, stage = 2), - std!(A => B, stage = 1), - std!(A => B, stage = 2), + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, ], ); assert_eq!(first(cache.all::()), &[dist::Src]); @@ -363,6 +346,7 @@ mod dist { #[test] fn dist_only_cross_host() { + let a = TargetSelection::from_user("A"); let b = TargetSelection::from_user("B"); let mut config = configure(&["A", "B"], &["A", "B"]); config.docs = false; @@ -376,7 +360,10 @@ mod dist { ); assert_eq!( first(cache.all::()), - &[rustc!(A => A, stage = 0), rustc!(A => B, stage = 1),] + &[ + compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: b }, + ] ); } @@ -463,11 +450,11 @@ mod dist { assert_eq!( first(cache.all::()), &[ - std!(A => A, stage = 0), - std!(A => A, stage = 1), - std!(A => A, stage = 2), - std!(A => B, stage = 1), - std!(A => B, stage = 2), + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, ] ); assert_eq!( @@ -487,29 +474,33 @@ mod dist { let mut builder = Builder::new(&build); builder.run_step_descriptions( &Builder::get_step_descriptions(Kind::Build), - &["compiler/rustc".into(), "library".into()], + &["compiler/rustc".into(), "library/std".into()], ); + let a = TargetSelection::from_user("A"); + let b = TargetSelection::from_user("B"); + let c = TargetSelection::from_user("C"); + assert_eq!( first(builder.cache.all::()), &[ - std!(A => A, stage = 0), - std!(A => A, stage = 1), - std!(A => A, stage = 2), - std!(A => B, stage = 1), - std!(A => B, stage = 2), - std!(A => C, stage = 2), + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, ] ); - assert_eq!(builder.cache.all::().len(), 5); + assert!(!builder.cache.all::().is_empty()); assert_eq!( first(builder.cache.all::()), &[ - rustc!(A => A, stage = 0), - rustc!(A => A, stage = 1), - rustc!(A => A, stage = 2), - rustc!(A => B, stage = 1), - rustc!(A => B, stage = 2), + compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 2 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: b }, + compile::Rustc { compiler: Compiler { host: a, stage: 2 }, target: b }, ] ); } @@ -522,10 +513,15 @@ mod dist { builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]); let a = TargetSelection::from_user("A"); + let c = TargetSelection::from_user("C"); assert_eq!( first(builder.cache.all::()), - &[std!(A => A, stage = 0), std!(A => A, stage = 1), std!(A => C, stage = 2),] + &[ + compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, + compile::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, + ] ); assert_eq!( first(builder.cache.all::()), @@ -537,7 +533,10 @@ mod dist { ); assert_eq!( first(builder.cache.all::()), - &[rustc!(A => A, stage = 0), rustc!(A => A, stage = 1),] + &[ + compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, + compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: a }, + ] ); } diff --git a/src/bootstrap/cache.rs b/src/bootstrap/cache.rs index be5c9bb078808..97f0bfdc484da 100644 --- a/src/bootstrap/cache.rs +++ b/src/bootstrap/cache.rs @@ -4,12 +4,13 @@ use std::cell::RefCell; use std::cmp::{Ord, Ordering, PartialOrd}; use std::collections::HashMap; use std::convert::AsRef; +use std::ffi::OsStr; use std::fmt; use std::hash::{Hash, Hasher}; use std::marker::PhantomData; use std::mem; use std::ops::Deref; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::sync::Mutex; // FIXME: replace with std::lazy after it gets stabilized and reaches beta @@ -19,9 +20,15 @@ use crate::builder::Step; pub struct Interned(usize, PhantomData<*const T>); -impl Default for Interned { +impl Default for Interned { fn default() -> Self { - T::default().intern() + INTERNER.intern_string(String::default()) + } +} + +impl Default for Interned { + fn default() -> Self { + INTERNER.intern_path(PathBuf::default()) } } @@ -70,48 +77,87 @@ impl fmt::Display for Interned { } } -impl fmt::Debug for Interned -where - Self: Deref, -{ +impl fmt::Debug for Interned { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let s: &U = &*self; + let s: &str = &*self; + f.write_fmt(format_args!("{:?}", s)) + } +} +impl fmt::Debug for Interned { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let s: &Path = &*self; f.write_fmt(format_args!("{:?}", s)) } } -impl Hash for Interned { +impl Hash for Interned { fn hash(&self, state: &mut H) { - let l = T::intern_cache().lock().unwrap(); + let l = INTERNER.strs.lock().unwrap(); l.get(*self).hash(state) } } -impl Deref for Interned { - type Target = T::Target; - fn deref(&self) -> &'static Self::Target { - let l = T::intern_cache().lock().unwrap(); - unsafe { mem::transmute::<&Self::Target, &'static Self::Target>(l.get(*self)) } +impl Hash for Interned { + fn hash(&self, state: &mut H) { + let l = INTERNER.paths.lock().unwrap(); + l.get(*self).hash(state) } } -impl, U: ?Sized> AsRef for Interned { - fn as_ref(&self) -> &'static U { - let l = T::intern_cache().lock().unwrap(); - unsafe { mem::transmute::<&U, &'static U>(l.get(*self).as_ref()) } +impl Deref for Interned { + type Target = str; + fn deref(&self) -> &'static str { + let l = INTERNER.strs.lock().unwrap(); + unsafe { mem::transmute::<&str, &'static str>(l.get(*self)) } } } -impl PartialOrd for Interned { +impl Deref for Interned { + type Target = Path; + fn deref(&self) -> &'static Path { + let l = INTERNER.paths.lock().unwrap(); + unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) } + } +} + +impl AsRef for Interned { + fn as_ref(&self) -> &'static Path { + let l = INTERNER.paths.lock().unwrap(); + unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) } + } +} + +impl AsRef for Interned { + fn as_ref(&self) -> &'static Path { + let l = INTERNER.strs.lock().unwrap(); + unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self).as_ref()) } + } +} + +impl AsRef for Interned { + fn as_ref(&self) -> &'static OsStr { + let l = INTERNER.paths.lock().unwrap(); + unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) } + } +} + +impl AsRef for Interned { + fn as_ref(&self) -> &'static OsStr { + let l = INTERNER.strs.lock().unwrap(); + unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) } + } +} + +impl PartialOrd> for Interned { fn partial_cmp(&self, other: &Self) -> Option { - let l = T::intern_cache().lock().unwrap(); + let l = INTERNER.strs.lock().unwrap(); l.get(*self).partial_cmp(l.get(*other)) } } -impl Ord for Interned { +impl Ord for Interned { fn cmp(&self, other: &Self) -> Ordering { - let l = T::intern_cache().lock().unwrap(); + let l = INTERNER.strs.lock().unwrap(); l.get(*self).cmp(l.get(*other)) } } @@ -162,33 +208,6 @@ impl TyIntern { pub struct Interner { strs: Mutex>, paths: Mutex>, - lists: Mutex>>, -} - -trait Internable: Clone + Eq + Hash + 'static { - fn intern_cache() -> &'static Mutex>; - - fn intern(self) -> Interned { - Self::intern_cache().lock().unwrap().intern(self) - } -} - -impl Internable for String { - fn intern_cache() -> &'static Mutex> { - &INTERNER.strs - } -} - -impl Internable for PathBuf { - fn intern_cache() -> &'static Mutex> { - &INTERNER.paths - } -} - -impl Internable for Vec { - fn intern_cache() -> &'static Mutex> { - &INTERNER.lists - } } impl Interner { @@ -202,10 +221,6 @@ impl Interner { pub fn intern_path(&self, s: PathBuf) -> Interned { self.paths.lock().unwrap().intern(s) } - - pub fn intern_list(&self, v: Vec) -> Interned> { - self.lists.lock().unwrap().intern(v) - } } pub static INTERNER: Lazy = Lazy::new(Interner::default); diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs index 4985b0546789d..731ebc41bb9a0 100644 --- a/src/bootstrap/check.rs +++ b/src/bootstrap/check.rs @@ -184,8 +184,8 @@ impl Step for Rustc { // the sysroot for the compiler to find. Otherwise, we're going to // fail when building crates that need to generate code (e.g., build // scripts and their dependencies). - builder.ensure(crate::compile::Std::new(compiler, compiler.host)); - builder.ensure(crate::compile::Std::new(compiler, target)); + builder.ensure(crate::compile::Std { target: compiler.host, compiler }); + builder.ensure(crate::compile::Std { target, compiler }); } else { builder.ensure(Std { target }); } diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index 399be26d5ac14..b4807d1ab3af2 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -29,31 +29,10 @@ use crate::util::{exe, is_debug_info, is_dylib, output, symlink_dir, t, up_to_da use crate::LLVM_TOOLS; use crate::{CLang, Compiler, DependencyType, GitRepo, Mode}; -#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, PartialOrd, Ord, Copy, Clone, PartialEq, Eq, Hash)] pub struct Std { pub target: TargetSelection, pub compiler: Compiler, - /// Whether to build only a subset of crates in the standard library. - /// - /// This shouldn't be used from other steps; see the comment on [`Rustc`]. - crates: Interned>, -} - -impl Std { - pub fn new(compiler: Compiler, target: TargetSelection) -> Self { - Self { target, compiler, crates: Default::default() } - } -} - -/// Return a `-p=x -p=y` string suitable for passing to a cargo invocation. -fn build_crates_in_set(run: &RunConfig<'_>) -> Interned> { - let mut crates = Vec::new(); - for krate in &run.paths { - let path = krate.assert_single_path(); - let crate_name = run.builder.crate_paths[&path.path]; - crates.push(format!("-p={crate_name}")); - } - INTERNER.intern_list(crates) } impl Step for Std { @@ -64,22 +43,15 @@ impl Step for Std { // When downloading stage1, the standard library has already been copied to the sysroot, so // there's no need to rebuild it. let builder = run.builder; - run.crate_or_deps("test") + run.all_krates("test") .path("library") .lazy_default_condition(Box::new(|| !builder.download_rustc())) } fn make_run(run: RunConfig<'_>) { - // Normally, people will pass *just* library if they pass it. - // But it's possible (although strange) to pass something like `library std core`. - // Build all crates anyway, as if they hadn't passed the other args. - let has_library = - run.paths.iter().any(|set| set.assert_single_path().path.ends_with("library")); - let crates = if has_library { Default::default() } else { build_crates_in_set(&run) }; run.builder.ensure(Std { compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()), target: run.target, - crates, }); } @@ -114,7 +86,7 @@ impl Step for Std { let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target); if compiler_to_use != compiler { - builder.ensure(Std::new(compiler_to_use, target)); + builder.ensure(Std { compiler: compiler_to_use, target }); builder.info(&format!("Uplifting stage1 std ({} -> {})", compiler_to_use.host, target)); // Even if we're not building std this stage, the new sysroot must @@ -143,7 +115,7 @@ impl Step for Std { run_cargo( builder, cargo, - self.crates.to_vec(), + vec![], &libstd_stamp(builder, compiler, target), target_deps, false, @@ -552,18 +524,6 @@ impl Step for StartupObjects { pub struct Rustc { pub target: TargetSelection, pub compiler: Compiler, - /// Whether to build a subset of crates, rather than the whole compiler. - /// - /// This should only be requested by the user, not used within rustbuild itself. - /// Using it within rustbuild can lead to confusing situation where lints are replayed - /// in two different steps. - crates: Interned>, -} - -impl Rustc { - pub fn new(compiler: Compiler, target: TargetSelection) -> Self { - Self { target, compiler, crates: Default::default() } - } } impl Step for Rustc { @@ -572,22 +532,13 @@ impl Step for Rustc { const DEFAULT: bool = false; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { - let mut crates = run.builder.in_tree_crates("rustc-main", None); - for (i, krate) in crates.iter().enumerate() { - if krate.name == "rustc-main" { - crates.swap_remove(i); - break; - } - } - run.crates(crates) + run.never() } fn make_run(run: RunConfig<'_>) { - let crates = build_crates_in_set(&run); run.builder.ensure(Rustc { compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()), target: run.target, - crates, }); } @@ -609,7 +560,7 @@ impl Step for Rustc { return; } - builder.ensure(Std::new(compiler, target)); + builder.ensure(Std { compiler, target }); if builder.config.keep_stage.contains(&compiler.stage) { builder.info("Warning: Using a potentially old librustc. This may not behave well."); @@ -620,7 +571,7 @@ impl Step for Rustc { let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target); if compiler_to_use != compiler { - builder.ensure(Rustc::new(compiler_to_use, target)); + builder.ensure(Rustc { compiler: compiler_to_use, target }); builder .info(&format!("Uplifting stage1 rustc ({} -> {})", builder.config.build, target)); builder.ensure(RustcLink { @@ -632,10 +583,10 @@ impl Step for Rustc { } // Ensure that build scripts and proc macros have a std / libproc_macro to link against. - builder.ensure(Std::new( - builder.compiler(self.compiler.stage, builder.config.build), - builder.config.build, - )); + builder.ensure(Std { + compiler: builder.compiler(self.compiler.stage, builder.config.build), + target: builder.config.build, + }); let mut cargo = builder.cargo(compiler, Mode::Rustc, SourceType::InTree, target, "build"); rustc_cargo(builder, &mut cargo, target); @@ -682,7 +633,7 @@ impl Step for Rustc { run_cargo( builder, cargo, - self.crates.to_vec(), + vec![], &librustc_stamp(builder, compiler, target), vec![], false, @@ -870,7 +821,7 @@ impl Step for CodegenBackend { let target = self.target; let backend = self.backend; - builder.ensure(Rustc::new(compiler, target)); + builder.ensure(Rustc { compiler, target }); if builder.config.keep_stage.contains(&compiler.stage) { builder.info( @@ -1152,7 +1103,7 @@ impl Step for Assemble { // link to these. (FIXME: Is that correct? It seems to be correct most // of the time but I think we do link to these for stage2/bin compilers // when not performing a full bootstrap). - builder.ensure(Rustc::new(build_compiler, target_compiler.host)); + builder.ensure(Rustc { compiler: build_compiler, target: target_compiler.host }); for &backend in builder.config.rust_codegen_backends.iter() { if backend == "llvm" { diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs index 4aadc3943c94a..cd85654db0167 100644 --- a/src/bootstrap/dist.rs +++ b/src/bootstrap/dist.rs @@ -557,7 +557,7 @@ impl Step for Std { return None; } - builder.ensure(compile::Std::new(compiler, target)); + builder.ensure(compile::Std { compiler, target }); let mut tarball = Tarball::new(builder, "rust-std", &target.triple); tarball.include_target_in_component_name(true); @@ -603,7 +603,7 @@ impl Step for RustcDev { return None; } - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Rustc { compiler, target }); let tarball = Tarball::new(builder, "rustc-dev", &target.triple); @@ -666,7 +666,7 @@ impl Step for Analysis { return None; } - builder.ensure(compile::Std::new(compiler, target)); + builder.ensure(compile::Std { compiler, target }); let src = builder .stage_out(compiler, Mode::Std) .join(target.triple) diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 5b96145607611..3cf0f9b9f9927 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -534,9 +534,7 @@ impl Step for Rustc { fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; - run.crate_or_deps("rustc-main") - .path("compiler") - .default_condition(builder.config.compiler_docs) + run.krate("rustc-main").path("compiler").default_condition(builder.config.compiler_docs) } fn make_run(run: RunConfig<'_>) { @@ -569,7 +567,7 @@ impl Step for Rustc { // Build the standard library, so that proc-macros can use it. // (Normally, only the metadata would be necessary, but proc-macros are special since they run at compile-time.) let compiler = builder.compiler(stage, builder.config.build); - builder.ensure(compile::Std::new(compiler, builder.config.build)); + builder.ensure(compile::Std { compiler, target: builder.config.build }); builder.info(&format!("Documenting stage{} compiler ({})", stage, target)); @@ -658,7 +656,7 @@ macro_rules! tool_doc { fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; - run.crate_or_deps($should_run).default_condition(builder.config.compiler_docs) + run.krate($should_run).default_condition(builder.config.compiler_docs) } fn make_run(run: RunConfig<'_>) { @@ -685,7 +683,7 @@ macro_rules! tool_doc { // FIXME: is there a way to only ensure `check::Rustc` here? Last time I tried it failed // with strange errors, but only on a full bors test ... let compiler = builder.compiler(stage, builder.config.build); - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Rustc { compiler, target }); builder.info( &format!( @@ -892,7 +890,7 @@ impl Step for RustcBook { let rustc = builder.rustc(self.compiler); // The tool runs `rustc` for extracting output examples, so it needs a // functional sysroot. - builder.ensure(compile::Std::new(self.compiler, self.target)); + builder.ensure(compile::Std { compiler: self.compiler, target: self.target }); let mut cmd = builder.tool_cmd(Tool::LintDocs); cmd.arg("--src"); cmd.arg(builder.src.join("compiler")); diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index 6be3da552919d..f3395507bb08b 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -225,7 +225,7 @@ impl Step for Cargotest { /// test` to ensure that we don't regress the test suites there. fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(self.stage, self.host); - builder.ensure(compile::Rustc::new(compiler, compiler.host)); + builder.ensure(compile::Rustc { compiler, target: compiler.host }); let cargo = builder.ensure(tool::Cargo { compiler, target: compiler.host }); // Note that this is a short, cryptic, and not scoped directory name. This @@ -603,7 +603,7 @@ impl Step for CompiletestTest { // We need `ToolStd` for the locally-built sysroot because // compiletest uses unstable features of the `test` crate. - builder.ensure(compile::Std::new(compiler, host)); + builder.ensure(compile::Std { compiler, target: host }); let cargo = tool::prepare_tool_cargo( builder, compiler, @@ -896,7 +896,7 @@ impl Step for RustdocGUI { let nodejs = builder.config.nodejs.as_ref().expect("nodejs isn't available"); let npm = builder.config.npm.as_ref().expect("npm isn't available"); - builder.ensure(compile::Std::new(self.compiler, self.target)); + builder.ensure(compile::Std { compiler: self.compiler, target: self.target }); // The goal here is to check if the necessary packages are installed, and if not, we // panic. @@ -1273,12 +1273,12 @@ note: if you're sure you want to do this, please open an issue as to why. In the } if suite.ends_with("fulldeps") { - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Rustc { compiler, target }); } - builder.ensure(compile::Std::new(compiler, target)); + builder.ensure(compile::Std { compiler, target }); // ensure that `libproc_macro` is available on the host. - builder.ensure(compile::Std::new(compiler, compiler.host)); + builder.ensure(compile::Std { compiler, target: compiler.host }); // Also provide `rust_test_helpers` for the host. builder.ensure(native::TestHelpers { target: compiler.host }); @@ -1643,7 +1643,7 @@ impl BookTest { fn run_ext_doc(self, builder: &Builder<'_>) { let compiler = self.compiler; - builder.ensure(compile::Std::new(compiler, compiler.host)); + builder.ensure(compile::Std { compiler, target: compiler.host }); // mdbook just executes a binary named "rustdoc", so we need to update // PATH so that it points to our rustdoc. @@ -1671,7 +1671,7 @@ impl BookTest { fn run_local_doc(self, builder: &Builder<'_>) { let compiler = self.compiler; - builder.ensure(compile::Std::new(compiler, compiler.host)); + builder.ensure(compile::Std { compiler, target: compiler.host }); // Do a breadth-first traversal of the `src/doc` directory and just run // tests for all files that end in `*.md` @@ -1790,7 +1790,7 @@ impl Step for ErrorIndex { builder.run_quiet(&mut tool); // The tests themselves need to link to std, so make sure it is // available. - builder.ensure(compile::Std::new(compiler, compiler.host)); + builder.ensure(compile::Std { compiler, target: compiler.host }); markdown_test(builder, compiler, &output); } } @@ -1867,7 +1867,7 @@ impl Step for CrateLibrustc { const ONLY_HOSTS: bool = true; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { - run.crate_or_deps("rustc-main") + run.krate("rustc-main") } fn make_run(run: RunConfig<'_>) { @@ -1909,7 +1909,7 @@ impl Step for Crate { const DEFAULT: bool = true; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { - run.crate_or_deps("test") + run.krate("test") } fn make_run(run: RunConfig<'_>) { @@ -1940,7 +1940,7 @@ impl Step for Crate { let mode = self.mode; let test_kind = self.test_kind; - builder.ensure(compile::Std::new(compiler, target)); + builder.ensure(compile::Std { compiler, target }); builder.ensure(RemoteCopyLibs { compiler, target }); // If we're not doing a full bootstrap but we're testing a stage2 @@ -2062,7 +2062,7 @@ impl Step for CrateRustdoc { // isn't really necessary. builder.compiler_for(builder.top_stage, target, target) }; - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Rustc { compiler, target }); let mut cargo = tool::prepare_tool_cargo( builder, @@ -2177,7 +2177,7 @@ impl Step for CrateRustdocJsonTypes { // `compiler`, then it would cause rustdoc to be built *again*, which // isn't really necessary. let compiler = builder.compiler_for(builder.top_stage, target, target); - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Rustc { compiler, target }); let mut cargo = tool::prepare_tool_cargo( builder, @@ -2245,7 +2245,7 @@ impl Step for RemoteCopyLibs { return; } - builder.ensure(compile::Std::new(compiler, target)); + builder.ensure(compile::Std { compiler, target }); builder.info(&format!("REMOTE copy libs to emulator ({})", target)); @@ -2415,7 +2415,7 @@ impl Step for TierCheck { /// Tests the Platform Support page in the rustc book. fn run(self, builder: &Builder<'_>) { - builder.ensure(compile::Std::new(self.compiler, self.compiler.host)); + builder.ensure(compile::Std { compiler: self.compiler, target: self.compiler.host }); let mut cargo = tool::prepare_tool_cargo( builder, self.compiler, diff --git a/src/bootstrap/tool.rs b/src/bootstrap/tool.rs index 74a793d257e22..5be6841e988ae 100644 --- a/src/bootstrap/tool.rs +++ b/src/bootstrap/tool.rs @@ -51,10 +51,10 @@ impl Step for ToolBuild { match self.mode { Mode::ToolRustc => { - builder.ensure(compile::Std::new(compiler, compiler.host)); - builder.ensure(compile::Rustc::new(compiler, target)); + builder.ensure(compile::Std { compiler, target: compiler.host }); + builder.ensure(compile::Rustc { compiler, target }); } - Mode::ToolStd => builder.ensure(compile::Std::new(compiler, target)), + Mode::ToolStd => builder.ensure(compile::Std { compiler, target }), Mode::ToolBootstrap => {} // uses downloaded stage0 compiler libs _ => panic!("unexpected Mode for tool build"), } @@ -512,8 +512,8 @@ impl Step for Rustdoc { // When using `download-rustc` and a stage0 build_compiler, copying rustc doesn't actually // build stage0 libstd (because the libstd in sysroot has the wrong ABI). Explicitly build // it. - builder.ensure(compile::Std::new(build_compiler, target_compiler.host)); - builder.ensure(compile::Rustc::new(build_compiler, target_compiler.host)); + builder.ensure(compile::Std { compiler: build_compiler, target: target_compiler.host }); + builder.ensure(compile::Rustc { compiler: build_compiler, target: target_compiler.host }); // NOTE: this implies that `download-rustc` is pretty useless when compiling with the stage0 // compiler, since you do just as much work. if !builder.config.dry_run && builder.download_rustc() && build_compiler.stage == 0 {