From 6343d6bc0da7ebeadb008f9184f9171fa6d8b900 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 25 Feb 2019 19:30:32 +0900 Subject: [PATCH] bootstrap: deny(rust_2018_idioms) --- src/bootstrap/builder.rs | 24 +++--- src/bootstrap/cache.rs | 6 +- src/bootstrap/cc_detect.rs | 3 +- src/bootstrap/check.rs | 56 +++++++++----- src/bootstrap/compile.rs | 113 ++++++++++++++++------------ src/bootstrap/dist.rs | 126 +++++++++++++++---------------- src/bootstrap/doc.rs | 89 +++++++++++----------- src/bootstrap/install.rs | 36 ++++----- src/bootstrap/lib.rs | 4 +- src/bootstrap/native.rs | 22 +++--- src/bootstrap/test.rs | 150 ++++++++++++++++++------------------- src/bootstrap/tool.rs | 36 ++++----- src/bootstrap/util.rs | 2 +- 13 files changed, 352 insertions(+), 315 deletions(-) diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index c94d6cb4c1f5a..7e6c0a9f52aa2 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -62,13 +62,13 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash { /// Primary function to execute this rule. Can call `builder.ensure()` /// with other steps to run those. - fn run(self, builder: &Builder) -> Self::Output; + fn run(self, builder: &Builder<'_>) -> Self::Output; /// When bootstrap is passed a set of paths, this controls whether this rule /// will execute. However, it does not get called in a "default" context /// when we are not passed any paths; in that case, `make_run` is called /// directly. - fn should_run(run: ShouldRun) -> ShouldRun; + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_>; /// Builds up a "root" rule, either as a default rule or from a path passed /// to us. @@ -76,7 +76,7 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash { /// When path is `None`, we are executing in a context where no paths were /// passed. When `./x.py build` is run, for example, this rule could get /// called if it is in the correct list below with a path of `None`. - fn make_run(_run: RunConfig) { + fn make_run(_run: RunConfig<'_>) { // It is reasonable to not have an implementation of make_run for rules // who do not want to get called from the root context. This means that // they are likely dependencies (e.g., sysroot creation) or similar, and @@ -95,8 +95,8 @@ pub struct RunConfig<'a> { struct StepDescription { default: bool, only_hosts: bool, - should_run: fn(ShouldRun) -> ShouldRun, - make_run: fn(RunConfig), + should_run: fn(ShouldRun<'_>) -> ShouldRun<'_>, + make_run: fn(RunConfig<'_>), name: &'static str, } @@ -124,7 +124,7 @@ impl PathSet { } } - fn path(&self, builder: &Builder) -> PathBuf { + fn path(&self, builder: &Builder<'_>) -> PathBuf { match self { PathSet::Set(set) => set .iter() @@ -147,7 +147,7 @@ impl StepDescription { } } - fn maybe_run(&self, builder: &Builder, pathset: &PathSet) { + fn maybe_run(&self, builder: &Builder<'_>, pathset: &PathSet) { if builder.config.exclude.iter().any(|e| pathset.has(e)) { eprintln!("Skipping {:?} because it is excluded", pathset); return; @@ -183,7 +183,7 @@ impl StepDescription { } } - fn run(v: &[StepDescription], builder: &Builder, paths: &[PathBuf]) { + fn run(v: &[StepDescription], builder: &Builder<'_>, paths: &[PathBuf]) { let should_runs = v .iter() .map(|desc| (desc.should_run)(ShouldRun::new(builder))) @@ -245,7 +245,7 @@ pub struct ShouldRun<'a> { } impl<'a> ShouldRun<'a> { - fn new(builder: &'a Builder) -> ShouldRun<'a> { + fn new(builder: &'a Builder<'_>) -> ShouldRun<'a> { ShouldRun { builder, paths: BTreeSet::new(), @@ -511,7 +511,7 @@ impl<'a> Builder<'a> { Some(help) } - pub fn new(build: &Build) -> Builder { + pub fn new(build: &Build) -> Builder<'_> { let (kind, paths) = match build.config.cmd { Subcommand::Build { ref paths } => (Kind::Build, &paths[..]), Subcommand::Check { ref paths } => (Kind::Check, &paths[..]), @@ -591,11 +591,11 @@ impl<'a> Builder<'a> { impl Step for Libdir { type Output = Interned; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } - fn run(self, builder: &Builder) -> Interned { + fn run(self, builder: &Builder<'_>) -> Interned { let compiler = self.compiler; let config = &builder.build.config; let lib = if compiler.stage >= 1 && config.libdir_relative().is_some() { diff --git a/src/bootstrap/cache.rs b/src/bootstrap/cache.rs index 5f84816789a68..239959682cb00 100644 --- a/src/bootstrap/cache.rs +++ b/src/bootstrap/cache.rs @@ -68,20 +68,20 @@ unsafe impl Send for Interned {} unsafe impl Sync for Interned {} impl fmt::Display for Interned { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s: &str = &*self; f.write_str(s) } } impl fmt::Debug for Interned { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s: &str = &*self; f.write_fmt(format_args!("{:?}", s)) } } impl fmt::Debug for Interned { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s: &Path = &*self; f.write_fmt(format_args!("{:?}", s)) } diff --git a/src/bootstrap/cc_detect.rs b/src/bootstrap/cc_detect.rs index 37844759c7b9a..dfc243b7054ab 100644 --- a/src/bootstrap/cc_detect.rs +++ b/src/bootstrap/cc_detect.rs @@ -27,7 +27,6 @@ use std::path::{Path, PathBuf}; use std::process::Command; use build_helper::output; -use cc; use crate::{Build, GitRepo}; use crate::config::Target; @@ -157,7 +156,7 @@ fn set_compiler(cfg: &mut cc::Build, None => return, }; match output[i + 3..].chars().next().unwrap() { - '0' ... '6' => {} + '0' ..= '6' => {} _ => return, } let alternative = format!("e{}", gnu_compiler); diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs index 2a2533a3c1407..20370372082b9 100644 --- a/src/bootstrap/check.rs +++ b/src/bootstrap/check.rs @@ -17,17 +17,17 @@ impl Step for Std { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("std") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Std { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let compiler = builder.compiler(0, builder.config.build); @@ -56,11 +56,11 @@ impl Step for Rustc { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("rustc-main") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustc { target: run.target, }); @@ -71,7 +71,7 @@ impl Step for Rustc { /// This will build the compiler for a particular stage of the build using /// the `compiler` targeting the `target` architecture. The artifacts /// created will also be linked into the sysroot directory. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(0, builder.config.build); let target = self.target; @@ -103,11 +103,11 @@ impl Step for CodegenBackend { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("rustc_codegen_llvm") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let backend = run.builder.config.rust_codegen_backends.get(0); let backend = backend.cloned().unwrap_or_else(|| { INTERNER.intern_str("llvm") @@ -118,7 +118,7 @@ impl Step for CodegenBackend { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(0, builder.config.build); let target = self.target; let backend = self.backend; @@ -148,17 +148,17 @@ impl Step for Test { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("test") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Test { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(0, builder.config.build); let target = self.target; @@ -189,17 +189,17 @@ impl Step for Rustdoc { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/rustdoc") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustdoc { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(0, builder.config.build); let target = self.target; @@ -229,25 +229,37 @@ impl Step for Rustdoc { /// Cargo's output path for the standard library in a given stage, compiled /// by a particular compiler for the specified target. -pub fn libstd_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn libstd_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Std, target).join(".libstd-check.stamp") } /// Cargo's output path for libtest in a given stage, compiled by a particular /// compiler for the specified target. -pub fn libtest_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn libtest_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Test, target).join(".libtest-check.stamp") } /// Cargo's output path for librustc in a given stage, compiled by a particular /// compiler for the specified target. -pub fn librustc_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn librustc_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Rustc, target).join(".librustc-check.stamp") } /// Cargo's output path for librustc_codegen_llvm in a given stage, compiled by a particular /// compiler for the specified target and backend. -fn codegen_backend_stamp(builder: &Builder, +fn codegen_backend_stamp(builder: &Builder<'_>, compiler: Compiler, target: Interned, backend: Interned) -> PathBuf { @@ -257,7 +269,11 @@ fn codegen_backend_stamp(builder: &Builder, /// Cargo's output path for rustdoc in a given stage, compiled by a particular /// compiler for the specified target. -pub fn rustdoc_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn rustdoc_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::ToolRustc, target) .join(".rustdoc-check.stamp") } diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index 8fabb8c3fd08f..249a183189048 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -37,11 +37,11 @@ impl Step for Std { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("std") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Std { compiler: run.builder.compiler(run.builder.top_stage, run.host), target: run.target, @@ -53,7 +53,7 @@ impl Step for Std { /// This will build the standard library for a particular stage of the build /// using the `compiler` targeting the `target` architecture. The artifacts /// created will also be linked into the sysroot directory. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let compiler = self.compiler; @@ -111,7 +111,7 @@ impl Step for Std { } /// Copies third pary objects needed by various targets. -fn copy_third_party_objects(builder: &Builder, compiler: &Compiler, target: Interned) { +fn copy_third_party_objects(builder: &Builder<'_>, compiler: &Compiler, target: Interned) { let libdir = builder.sysroot_libdir(*compiler, target); // Copies the crt(1,i,n).o startup objects @@ -145,7 +145,7 @@ fn copy_third_party_objects(builder: &Builder, compiler: &Compiler, target: Inte /// Configure cargo to compile the standard library, adding appropriate env vars /// and such. -pub fn std_cargo(builder: &Builder, +pub fn std_cargo(builder: &Builder<'_>, compiler: &Compiler, target: Interned, cargo: &mut Command) { @@ -201,7 +201,7 @@ struct StdLink { impl Step for StdLink { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -213,7 +213,7 @@ impl Step for StdLink { /// Note that this assumes that `compiler` has already generated the libstd /// libraries for `target`, and this method will find them in the relevant /// output directory. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target_compiler = self.target_compiler; let target = self.target; @@ -237,7 +237,12 @@ impl Step for StdLink { } } -fn copy_apple_sanitizer_dylibs(builder: &Builder, native_dir: &Path, platform: &str, into: &Path) { +fn copy_apple_sanitizer_dylibs( + builder: &Builder<'_>, + native_dir: &Path, + platform: &str, + into: &Path, +) { for &sanitizer in &["asan", "tsan"] { let filename = format!("lib__rustc__clang_rt.{}_{}_dynamic.dylib", sanitizer, platform); let mut src_path = native_dir.join(sanitizer); @@ -258,11 +263,11 @@ pub struct StartupObjects { impl Step for StartupObjects { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/rtstartup") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(StartupObjects { compiler: run.builder.compiler(run.builder.top_stage, run.host), target: run.target, @@ -275,7 +280,7 @@ impl Step for StartupObjects { /// They don't require any library support as they're just plain old object /// files, so we just use the nightly snapshot compiler to always build them (as /// no other compilers are guaranteed to be available). - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let for_compiler = self.compiler; let target = self.target; if !target.contains("pc-windows-gnu") { @@ -323,11 +328,11 @@ impl Step for Test { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("test") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Test { compiler: run.builder.compiler(run.builder.top_stage, run.host), target: run.target, @@ -339,7 +344,7 @@ impl Step for Test { /// This will build libtest and supporting libraries for a particular stage of /// the build using the `compiler` targeting the `target` architecture. The /// artifacts created will also be linked into the sysroot directory. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let compiler = self.compiler; @@ -390,7 +395,7 @@ impl Step for Test { } /// Same as `std_cargo`, but for libtest -pub fn test_cargo(builder: &Builder, +pub fn test_cargo(builder: &Builder<'_>, _compiler: &Compiler, _target: Interned, cargo: &mut Command) { @@ -411,12 +416,12 @@ pub struct TestLink { impl Step for TestLink { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } /// Same as `std_link`, only for libtest - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target_compiler = self.target_compiler; let target = self.target; @@ -444,11 +449,11 @@ impl Step for Rustc { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("rustc-main") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustc { compiler: run.builder.compiler(run.builder.top_stage, run.host), target: run.target, @@ -460,7 +465,7 @@ impl Step for Rustc { /// This will build the compiler for a particular stage of the build using /// the `compiler` targeting the `target` architecture. The artifacts /// created will also be linked into the sysroot directory. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; @@ -516,14 +521,14 @@ impl Step for Rustc { } } -pub fn rustc_cargo(builder: &Builder, cargo: &mut Command) { +pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Command) { cargo.arg("--features").arg(builder.rustc_features()) .arg("--manifest-path") .arg(builder.src.join("src/rustc/Cargo.toml")); rustc_cargo_env(builder, cargo); } -pub fn rustc_cargo_env(builder: &Builder, cargo: &mut Command) { +pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Command) { // Set some configuration variables picked up by build scripts and // the compiler alike cargo.env("CFG_RELEASE", builder.rust_release()) @@ -572,12 +577,12 @@ struct RustcLink { impl Step for RustcLink { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } /// Same as `std_link`, only for librustc - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target_compiler = self.target_compiler; let target = self.target; @@ -605,11 +610,11 @@ impl Step for CodegenBackend { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.all_krates("rustc_codegen_llvm") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let backend = run.builder.config.rust_codegen_backends.get(0); let backend = backend.cloned().unwrap_or_else(|| { INTERNER.intern_str("llvm") @@ -621,7 +626,7 @@ impl Step for CodegenBackend { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; let backend = self.backend; @@ -684,7 +689,7 @@ impl Step for CodegenBackend { } } -pub fn build_codegen_backend(builder: &Builder, +pub fn build_codegen_backend(builder: &Builder<'_>, cargo: &mut Command, compiler: &Compiler, target: Interned, @@ -753,7 +758,7 @@ pub fn build_codegen_backend(builder: &Builder, /// This will take the codegen artifacts produced by `compiler` and link them /// into an appropriate location for `target_compiler` to be a functional /// compiler. -fn copy_codegen_backends_to_sysroot(builder: &Builder, +fn copy_codegen_backends_to_sysroot(builder: &Builder<'_>, compiler: Compiler, target_compiler: Compiler) { let target = target_compiler.host; @@ -791,7 +796,7 @@ fn copy_codegen_backends_to_sysroot(builder: &Builder, } } -fn copy_lld_to_sysroot(builder: &Builder, +fn copy_lld_to_sysroot(builder: &Builder<'_>, target_compiler: Compiler, lld_install_root: &Path) { let target = target_compiler.host; @@ -811,25 +816,37 @@ fn copy_lld_to_sysroot(builder: &Builder, /// Cargo's output path for the standard library in a given stage, compiled /// by a particular compiler for the specified target. -pub fn libstd_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn libstd_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Std, target).join(".libstd.stamp") } /// Cargo's output path for libtest in a given stage, compiled by a particular /// compiler for the specified target. -pub fn libtest_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn libtest_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Test, target).join(".libtest.stamp") } /// Cargo's output path for librustc in a given stage, compiled by a particular /// compiler for the specified target. -pub fn librustc_stamp(builder: &Builder, compiler: Compiler, target: Interned) -> PathBuf { +pub fn librustc_stamp( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, +) -> PathBuf { builder.cargo_out(compiler, Mode::Rustc, target).join(".librustc.stamp") } /// Cargo's output path for librustc_codegen_llvm in a given stage, compiled by a particular /// compiler for the specified target and backend. -fn codegen_backend_stamp(builder: &Builder, +fn codegen_backend_stamp(builder: &Builder<'_>, compiler: Compiler, target: Interned, backend: Interned) -> PathBuf { @@ -837,10 +854,12 @@ fn codegen_backend_stamp(builder: &Builder, .join(format!(".librustc_codegen_llvm-{}.stamp", backend)) } -pub fn compiler_file(builder: &Builder, - compiler: &Path, - target: Interned, - file: &str) -> PathBuf { +pub fn compiler_file( + builder: &Builder<'_>, + compiler: &Path, + target: Interned, + file: &str, +) -> PathBuf { let mut cmd = Command::new(compiler); cmd.args(builder.cflags(target, GitRepo::Rustc)); cmd.arg(format!("-print-file-name={}", file)); @@ -856,7 +875,7 @@ pub struct Sysroot { impl Step for Sysroot { type Output = Interned; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -866,7 +885,7 @@ impl Step for Sysroot { /// That is, the sysroot for the stage0 compiler is not what the compiler /// thinks it is by default, but it's the same as the default for stages /// 1-3. - fn run(self, builder: &Builder) -> Interned { + fn run(self, builder: &Builder<'_>) -> Interned { let compiler = self.compiler; let sysroot = if compiler.stage == 0 { builder.out.join(&compiler.host).join("stage0-sysroot") @@ -891,7 +910,7 @@ pub struct Assemble { impl Step for Assemble { type Output = Compiler; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -900,7 +919,7 @@ impl Step for Assemble { /// This will assemble a compiler in `build/$host/stage$stage`. The compiler /// must have been previously produced by the `stage - 1` builder.build /// compiler. - fn run(self, builder: &Builder) -> Compiler { + fn run(self, builder: &Builder<'_>) -> Compiler { let target_compiler = self.target_compiler; if target_compiler.stage == 0 { @@ -996,14 +1015,14 @@ impl Step for Assemble { /// /// For a particular stage this will link the file listed in `stamp` into the /// `sysroot_dst` provided. -pub fn add_to_sysroot(builder: &Builder, sysroot_dst: &Path, stamp: &Path) { +pub fn add_to_sysroot(builder: &Builder<'_>, sysroot_dst: &Path, stamp: &Path) { t!(fs::create_dir_all(&sysroot_dst)); for path in builder.read_stamp_file(stamp) { builder.copy(&path, &sysroot_dst.join(path.file_name().unwrap())); } } -pub fn run_cargo(builder: &Builder, +pub fn run_cargo(builder: &Builder<'_>, cargo: &mut Command, stamp: &Path, is_check: bool) @@ -1150,9 +1169,9 @@ pub fn run_cargo(builder: &Builder, } pub fn stream_cargo( - builder: &Builder, + builder: &Builder<'_>, cargo: &mut Command, - cb: &mut dyn FnMut(CargoMessage), + cb: &mut dyn FnMut(CargoMessage<'_>), ) -> bool { if builder.config.dry_run { return true; @@ -1174,7 +1193,7 @@ pub fn stream_cargo( let stdout = BufReader::new(child.stdout.take().unwrap()); for line in stdout.lines() { let line = t!(line); - match serde_json::from_str::(&line) { + match serde_json::from_str::>(&line) { Ok(msg) => cb(msg), // If this was informational, just print it out and continue Err(_) => println!("{}", line) diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs index bc1fdad356be3..2dae3f9135d84 100644 --- a/src/bootstrap/dist.rs +++ b/src/bootstrap/dist.rs @@ -25,7 +25,7 @@ use crate::tool::{self, Tool}; use crate::cache::{INTERNER, Interned}; use time::{self, Timespec}; -pub fn pkgname(builder: &Builder, component: &str) -> String { +pub fn pkgname(builder: &Builder<'_>, component: &str) -> String { if component == "cargo" { format!("{}-{}", component, builder.cargo_package_vers()) } else if component == "rls" { @@ -46,15 +46,15 @@ pub fn pkgname(builder: &Builder, component: &str) -> String { } } -fn distdir(builder: &Builder) -> PathBuf { +fn distdir(builder: &Builder<'_>) -> PathBuf { builder.out.join("dist") } -pub fn tmpdir(builder: &Builder) -> PathBuf { +pub fn tmpdir(builder: &Builder<'_>) -> PathBuf { builder.out.join("tmp/dist") } -fn rust_installer(builder: &Builder) -> Command { +fn rust_installer(builder: &Builder<'_>) -> Command { builder.tool_cmd(Tool::RustInstaller) } @@ -76,11 +76,11 @@ impl Step for Docs { type Output = PathBuf; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/doc") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Docs { stage: run.builder.top_stage, host: run.target, @@ -88,7 +88,7 @@ impl Step for Docs { } /// Builds the `rust-docs` installer component. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let host = self.host; let name = pkgname(builder, "rust-docs"); @@ -138,11 +138,11 @@ impl Step for RustcDocs { type Output = PathBuf; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/librustc") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(RustcDocs { stage: run.builder.top_stage, host: run.target, @@ -150,7 +150,7 @@ impl Step for RustcDocs { } /// Builds the `rustc-docs` installer component. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let host = self.host; let name = pkgname(builder, "rustc-docs"); @@ -210,7 +210,7 @@ fn find_files(files: &[&str], path: &[PathBuf]) -> Vec { } fn make_win_dist( - rust_root: &Path, plat_root: &Path, target_triple: Interned, builder: &Builder + rust_root: &Path, plat_root: &Path, target_triple: Interned, builder: &Builder<'_> ) { //Ask gcc where it keeps its stuff let mut cmd = Command::new(builder.cc(target_triple)); @@ -334,11 +334,11 @@ impl Step for Mingw { type Output = Option; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Mingw { host: run.target }); } @@ -346,7 +346,7 @@ impl Step for Mingw { /// /// This contains all the bits and pieces to run the MinGW Windows targets /// without any extra installed software (e.g., we bundle gcc, libraries, etc). - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let host = self.host; if !host.contains("pc-windows-gnu") { @@ -392,18 +392,18 @@ impl Step for Rustc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/librustc") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustc { compiler: run.builder.compiler(run.builder.top_stage, run.target), }); } /// Creates the `rustc` installer component. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let compiler = self.compiler; let host = self.compiler.host; @@ -470,7 +470,7 @@ impl Step for Rustc { return distdir(builder).join(format!("{}-{}.tar.gz", name, host)); - fn prepare_image(builder: &Builder, compiler: Compiler, image: &Path) { + fn prepare_image(builder: &Builder<'_>, compiler: Compiler, image: &Path) { let host = compiler.host; let src = builder.sysroot(compiler); let libdir = libdir(&host); @@ -580,11 +580,11 @@ pub struct DebuggerScripts { impl Step for DebuggerScripts { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/lldb_batchmode.py") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(DebuggerScripts { sysroot: run.builder.sysroot(run.builder.compiler(run.builder.top_stage, run.host)), host: run.target, @@ -592,7 +592,7 @@ impl Step for DebuggerScripts { } /// Copies debugger scripts for `target` into the `sysroot` specified. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let host = self.host; let sysroot = self.sysroot; let dst = sysroot.join("lib/rustlib/etc"); @@ -639,18 +639,18 @@ impl Step for Std { type Output = PathBuf; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/libstd") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Std { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let compiler = self.compiler; let target = self.target; @@ -728,12 +728,12 @@ impl Step for Analysis { type Output = PathBuf; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("analysis").default_condition(builder.config.extended) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Analysis { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, @@ -741,7 +741,7 @@ impl Step for Analysis { } /// Creates a tarball of save-analysis metadata, if available. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let compiler = self.compiler; let target = self.target; assert!(builder.config.extended); @@ -791,7 +791,7 @@ impl Step for Analysis { } } -fn copy_src_dirs(builder: &Builder, src_dirs: &[&str], exclude_dirs: &[&str], dst_dir: &Path) { +fn copy_src_dirs(builder: &Builder<'_>, src_dirs: &[&str], exclude_dirs: &[&str], dst_dir: &Path) { fn filter_fn(exclude_dirs: &[&str], dir: &str, path: &Path) -> bool { let spath = match path.to_str() { Some(path) => path, @@ -861,16 +861,16 @@ impl Step for Src { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Src); } /// Creates the `rust-src` installer component - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { builder.info("Dist src"); let name = pkgname(builder, "rust-src"); @@ -941,17 +941,17 @@ impl Step for PlainSourceTarball { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src").default_condition(builder.config.rust_dist_src) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(PlainSourceTarball); } /// Creates the plain source tarball - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { builder.info("Create plain source tarball"); // Make sure that the root folder of tarball has the correct name @@ -1069,18 +1069,18 @@ impl Step for Cargo { type Output = PathBuf; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("cargo") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Cargo { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let stage = self.stage; let target = self.target; @@ -1155,18 +1155,18 @@ impl Step for Rls { type Output = Option; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("rls") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rls { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let stage = self.stage; let target = self.target; assert!(builder.config.extended); @@ -1234,18 +1234,18 @@ impl Step for Clippy { type Output = Option; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("clippy") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Clippy { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let stage = self.stage; let target = self.target; assert!(builder.config.extended); @@ -1318,18 +1318,18 @@ impl Step for Miri { type Output = Option; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("miri") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Miri { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let stage = self.stage; let target = self.target; assert!(builder.config.extended); @@ -1402,18 +1402,18 @@ impl Step for Rustfmt { type Output = Option; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("rustfmt") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustfmt { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let stage = self.stage; let target = self.target; @@ -1485,12 +1485,12 @@ impl Step for Extended { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("extended").default_condition(builder.config.extended) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Extended { stage: run.builder.top_stage, host: run.builder.config.build, @@ -1499,7 +1499,7 @@ impl Step for Extended { } /// Creates a combined installer for the specified target in the provided stage. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; @@ -1949,7 +1949,7 @@ impl Step for Extended { } } -fn add_env(builder: &Builder, cmd: &mut Command, target: Interned) { +fn add_env(builder: &Builder<'_>, cmd: &mut Command, target: Interned) { let mut parts = channel::CFG_RELEASE_NUM.split('.'); cmd.env("CFG_RELEASE_INFO", builder.rust_version()) .env("CFG_RELEASE_NUM", channel::CFG_RELEASE_NUM) @@ -1985,15 +1985,15 @@ impl Step for HashSign { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("hash-and-sign") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(HashSign); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let mut cmd = builder.tool_cmd(Tool::BuildManifest); if builder.config.dry_run { return; @@ -2037,7 +2037,7 @@ impl Step for HashSign { // LLVM tools are linked dynamically. // Note: This function does no yet support Windows but we also don't support // linking LLVM tools dynamically on Windows yet. -pub fn maybe_install_llvm_dylib(builder: &Builder, +pub fn maybe_install_llvm_dylib(builder: &Builder<'_>, target: Interned, sysroot: &Path) { let src_libdir = builder @@ -2079,18 +2079,18 @@ impl Step for LlvmTools { type Output = Option; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("llvm-tools") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(LlvmTools { stage: run.builder.top_stage, target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let stage = self.stage; let target = self.target; assert!(builder.config.extended); @@ -2163,17 +2163,17 @@ impl Step for Lldb { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/llvm-project/lldb").path("src/tools/lldb") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Lldb { target: run.target, }); } - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let target = self.target; if builder.config.dry_run { diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 660f9b9ef578a..40f0e5ede8bd7 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -34,18 +34,18 @@ macro_rules! book { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path($path).default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure($name { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(Rustbook { target: self.target, name: INTERNER.intern_str($book_name), @@ -87,7 +87,7 @@ impl Step for Rustbook { // rustbook is never directly called, and only serves as a shim for the nomicon and the // reference. - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -95,7 +95,7 @@ impl Step for Rustbook { /// /// This will not actually generate any documentation if the documentation has /// already been generated. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let src = builder.src.join("src/doc"); builder.ensure(RustbookSrc { target: self.target, @@ -115,18 +115,18 @@ impl Step for UnstableBook { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/doc/unstable-book").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(UnstableBook { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(UnstableBookGen { target: self.target, }); @@ -149,19 +149,19 @@ impl Step for CargoBook { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/tools/cargo/src/doc/book").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(CargoBook { target: run.target, name: INTERNER.intern_str("cargo"), }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let name = self.name; let src = builder.src.join("src/tools/cargo/src/doc"); @@ -194,7 +194,7 @@ struct RustbookSrc { impl Step for RustbookSrc { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -202,7 +202,7 @@ impl Step for RustbookSrc { /// /// This will not actually generate any documentation if the documentation has /// already been generated. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let name = self.name; let src = self.src; @@ -246,12 +246,12 @@ impl Step for TheBook { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/doc/book").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(TheBook { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, @@ -268,7 +268,7 @@ impl Step for TheBook { /// * Version info and CSS /// * Index page /// * Redirect pages - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; let name = self.name; @@ -321,7 +321,12 @@ impl Step for TheBook { } } -fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned, markdown: &str) { +fn invoke_rustdoc( + builder: &Builder<'_>, + compiler: Compiler, + target: Interned, + markdown: &str, +) { let out = builder.doc_out(target); let path = builder.src.join("src/doc").join(markdown); @@ -358,12 +363,12 @@ impl Step for Standalone { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/doc").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Standalone { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, @@ -378,7 +383,7 @@ impl Step for Standalone { /// `STAMP` along with providing the various header/footer HTML we've customized. /// /// In the end, this is just a glorified wrapper around rustdoc! - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; let compiler = self.compiler; builder.info(&format!("Documenting standalone ({})", target)); @@ -452,12 +457,12 @@ impl Step for Std { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.all_krates("std").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Std { stage: run.builder.top_stage, target: run.target @@ -468,7 +473,7 @@ impl Step for Std { /// /// This will generate all documentation for the standard library and its /// dependencies. This is largely just a wrapper around `cargo doc`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; builder.info(&format!("Documenting stage{} std ({})", stage, target)); @@ -539,12 +544,12 @@ impl Step for Test { type Output = (); const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.krate("test").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Test { stage: run.builder.top_stage, target: run.target, @@ -555,7 +560,7 @@ impl Step for Test { /// /// This will generate all documentation for libtest and its dependencies. This /// is largely just a wrapper around `cargo doc`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; builder.info(&format!("Documenting stage{} test ({})", stage, target)); @@ -602,12 +607,12 @@ impl Step for WhitelistedRustc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.krate("rustc-main").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(WhitelistedRustc { stage: run.builder.top_stage, target: run.target, @@ -623,7 +628,7 @@ impl Step for WhitelistedRustc { /// documentation. We don't build other compiler documentation /// here as we want to be able to keep it separate from the standard /// documentation. This is largely just a wrapper around `cargo doc`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; builder.info(&format!("Documenting stage{} whitelisted compiler ({})", stage, target)); @@ -674,12 +679,12 @@ impl Step for Rustc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.krate("rustc-main").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustc { stage: run.builder.top_stage, target: run.target, @@ -692,7 +697,7 @@ impl Step for Rustc { /// Compiler documentation is distributed separately, so we make sure /// we do not merge it with the other documentation from std, test and /// proc_macros. This is largely just a wrapper around `cargo doc`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; builder.info(&format!("Documenting stage{} compiler ({})", stage, target)); @@ -750,7 +755,7 @@ impl Step for Rustc { } fn find_compiler_crates( - builder: &Builder, + builder: &Builder<'_>, name: &Interned, crates: &mut HashSet> ) { @@ -776,11 +781,11 @@ impl Step for Rustdoc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.krate("rustdoc-tool") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustdoc { stage: run.builder.top_stage, target: run.target, @@ -793,7 +798,7 @@ impl Step for Rustdoc { /// Compiler documentation is distributed separately, so we make sure /// we do not merge it with the other documentation from std, test and /// proc_macros. This is largely just a wrapper around `cargo doc`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; builder.info(&format!("Documenting stage{} rustdoc ({})", stage, target)); @@ -859,12 +864,12 @@ impl Step for ErrorIndex { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/tools/error_index_generator").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(ErrorIndex { target: run.target, }); @@ -872,7 +877,7 @@ impl Step for ErrorIndex { /// Generates the HTML rendered error-index by running the /// `error_index_generator` tool. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; builder.info(&format!("Documenting error index ({})", target)); @@ -900,18 +905,18 @@ impl Step for UnstableBookGen { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/tools/unstable-book-gen").default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(UnstableBookGen { target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let target = self.target; builder.ensure(compile::Std { diff --git a/src/bootstrap/install.rs b/src/bootstrap/install.rs index 1265fa9eff45b..2d040d60e5fd7 100644 --- a/src/bootstrap/install.rs +++ b/src/bootstrap/install.rs @@ -14,45 +14,45 @@ use crate::builder::{Builder, RunConfig, ShouldRun, Step}; use crate::cache::Interned; use crate::config::Config; -pub fn install_docs(builder: &Builder, stage: u32, host: Interned) { +pub fn install_docs(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "docs", "rust-docs", stage, Some(host)); } -pub fn install_std(builder: &Builder, stage: u32, target: Interned) { +pub fn install_std(builder: &Builder<'_>, stage: u32, target: Interned) { install_sh(builder, "std", "rust-std", stage, Some(target)); } -pub fn install_cargo(builder: &Builder, stage: u32, host: Interned) { +pub fn install_cargo(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "cargo", "cargo", stage, Some(host)); } -pub fn install_rls(builder: &Builder, stage: u32, host: Interned) { +pub fn install_rls(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "rls", "rls", stage, Some(host)); } -pub fn install_clippy(builder: &Builder, stage: u32, host: Interned) { +pub fn install_clippy(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "clippy", "clippy", stage, Some(host)); } -pub fn install_miri(builder: &Builder, stage: u32, host: Interned) { +pub fn install_miri(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "miri", "miri", stage, Some(host)); } -pub fn install_rustfmt(builder: &Builder, stage: u32, host: Interned) { +pub fn install_rustfmt(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "rustfmt", "rustfmt", stage, Some(host)); } -pub fn install_analysis(builder: &Builder, stage: u32, host: Interned) { +pub fn install_analysis(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "analysis", "rust-analysis", stage, Some(host)); } -pub fn install_src(builder: &Builder, stage: u32) { +pub fn install_src(builder: &Builder<'_>, stage: u32) { install_sh(builder, "src", "rust-src", stage, None); } -pub fn install_rustc(builder: &Builder, stage: u32, host: Interned) { +pub fn install_rustc(builder: &Builder<'_>, stage: u32, host: Interned) { install_sh(builder, "rustc", "rustc", stage, Some(host)); } fn install_sh( - builder: &Builder, + builder: &Builder<'_>, package: &str, name: &str, stage: u32, @@ -155,7 +155,7 @@ macro_rules! install { } #[allow(dead_code)] - fn should_install(builder: &Builder) -> bool { + fn should_install(builder: &Builder<'_>) -> bool { builder.config.tools.as_ref().map_or(false, |t| t.contains($path)) } } @@ -166,12 +166,12 @@ macro_rules! install { const ONLY_HOSTS: bool = $only_hosts; $(const $c: bool = true;)* - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let $_config = &run.builder.config; run.path($path).default_condition($default_cond) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure($name { stage: run.builder.top_stage, target: run.target, @@ -179,7 +179,7 @@ macro_rules! install { }); } - fn run($sel, $builder: &Builder) { + fn run($sel, $builder: &Builder<'_>) { $run_item } })+ @@ -262,20 +262,20 @@ impl Step for Src { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let config = &run.builder.config; let cond = config.extended && config.tools.as_ref().map_or(true, |t| t.contains("src")); run.path("src").default_condition(cond) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Src { stage: run.builder.top_stage, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(dist::Src); install_src(builder, self.stage); } diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs index 2dceb30c4ad7d..84e2c5aab54a3 100644 --- a/src/bootstrap/lib.rs +++ b/src/bootstrap/lib.rs @@ -103,7 +103,7 @@ //! More documentation can be found in each respective module below, and you can //! also check out the `src/bootstrap/README.md` file for more information. -#![deny(bare_trait_objects)] +#![deny(rust_2018_idioms)] #![deny(warnings)] #![feature(core_intrinsics)] #![feature(drain_filter)] @@ -164,8 +164,6 @@ mod job; #[cfg(all(unix, not(target_os = "haiku")))] mod job { - use libc; - pub unsafe fn setup(build: &mut crate::Build) { if build.config.low_priority { libc::setpriority(libc::PRIO_PGRP as _, 0, 10); diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index f48f9ee752e93..192b1cd1fbb75 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -35,14 +35,14 @@ impl Step for Llvm { const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/llvm-project") .path("src/llvm-project/llvm") .path("src/llvm") .path("src/llvm-emscripten") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let emscripten = run.path.ends_with("llvm-emscripten"); run.builder.ensure(Llvm { target: run.target, @@ -51,7 +51,7 @@ impl Step for Llvm { } /// Compile LLVM for `target`. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let target = self.target; let emscripten = self.emscripten; @@ -261,7 +261,7 @@ impl Step for Llvm { } } -fn check_llvm_version(builder: &Builder, llvm_config: &Path) { +fn check_llvm_version(builder: &Builder<'_>, llvm_config: &Path) { if !builder.config.llvm_version_check { return } @@ -282,7 +282,7 @@ fn check_llvm_version(builder: &Builder, llvm_config: &Path) { panic!("\n\nbad LLVM version: {}, need >=6.0\n\n", version) } -fn configure_cmake(builder: &Builder, +fn configure_cmake(builder: &Builder<'_>, target: Interned, cfg: &mut cmake::Config) { if builder.config.ninja { @@ -417,16 +417,16 @@ impl Step for Lld { type Output = PathBuf; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/llvm-project/lld").path("src/tools/lld") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Lld { target: run.target }); } /// Compile LLVM for `target`. - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { if builder.config.dry_run { return PathBuf::from("lld-out-dir-test-gen"); } @@ -489,17 +489,17 @@ pub struct TestHelpers { impl Step for TestHelpers { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/test/auxiliary/rust_test_helpers.c") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(TestHelpers { target: run.target }) } /// Compiles the `rust_test_helpers.c` library which we used in various /// `run-pass` test suites for ABI testing. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { if builder.config.dry_run { return; } diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index a882550f734f4..51412f79c3d0c 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -57,7 +57,7 @@ impl TestKind { } impl fmt::Display for TestKind { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(match *self { TestKind::Test => "Testing", TestKind::Bench => "Benchmarking", @@ -65,7 +65,7 @@ impl fmt::Display for TestKind { } } -fn try_run(builder: &Builder, cmd: &mut Command) -> bool { +fn try_run(builder: &Builder<'_>, cmd: &mut Command) -> bool { if !builder.fail_fast { if !builder.try_run(cmd) { let mut failures = builder.delayed_failures.borrow_mut(); @@ -78,7 +78,7 @@ fn try_run(builder: &Builder, cmd: &mut Command) -> bool { true } -fn try_run_quiet(builder: &Builder, cmd: &mut Command) -> bool { +fn try_run_quiet(builder: &Builder<'_>, cmd: &mut Command) -> bool { if !builder.fail_fast { if !builder.try_run_quiet(cmd) { let mut failures = builder.delayed_failures.borrow_mut(); @@ -105,7 +105,7 @@ impl Step for Linkcheck { /// /// This tool in `src/tools` will verify the validity of all our links in the /// documentation to ensure we don't have a bunch of dead ones. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let host = self.host; builder.info(&format!("Linkcheck ({})", host)); @@ -121,13 +121,13 @@ impl Step for Linkcheck { ); } - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/tools/linkchecker") .default_condition(builder.config.docs) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Linkcheck { host: run.target }); } } @@ -142,11 +142,11 @@ impl Step for Cargotest { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/cargotest") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Cargotest { stage: run.builder.top_stage, host: run.target, @@ -157,7 +157,7 @@ impl Step for Cargotest { /// /// This tool in `src/tools` will check out a few Rust projects and run `cargo /// test` to ensure that we don't regress the test suites there. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(self.stage, self.host); builder.ensure(compile::Rustc { compiler, @@ -192,11 +192,11 @@ impl Step for Cargo { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/cargo") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Cargo { stage: run.builder.top_stage, host: run.target, @@ -204,7 +204,7 @@ impl Step for Cargo { } /// Runs `cargo test` for `cargo` packaged with Rust. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = builder.compiler(self.stage, self.host); builder.ensure(tool::Cargo { @@ -247,11 +247,11 @@ impl Step for Rls { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/rls") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rls { stage: run.builder.top_stage, host: run.target, @@ -259,7 +259,7 @@ impl Step for Rls { } /// Runs `cargo test` for the rls. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let host = self.host; let compiler = builder.compiler(stage, host); @@ -303,11 +303,11 @@ impl Step for Rustfmt { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/rustfmt") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustfmt { stage: run.builder.top_stage, host: run.target, @@ -315,7 +315,7 @@ impl Step for Rustfmt { } /// Runs `cargo test` for rustfmt. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let host = self.host; let compiler = builder.compiler(stage, host); @@ -362,12 +362,12 @@ impl Step for Miri { const ONLY_HOSTS: bool = true; const DEFAULT: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let test_miri = run.builder.config.test_miri; run.path("src/tools/miri").default_condition(test_miri) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Miri { stage: run.builder.top_stage, host: run.target, @@ -375,7 +375,7 @@ impl Step for Miri { } /// Runs `cargo test` for miri. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let host = self.host; let compiler = builder.compiler(stage, host); @@ -421,11 +421,11 @@ pub struct CompiletestTest { impl Step for CompiletestTest { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/compiletest") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(CompiletestTest { stage: run.builder.top_stage, host: run.target, @@ -433,7 +433,7 @@ impl Step for CompiletestTest { } /// Runs `cargo test` for compiletest. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let host = self.host; let compiler = builder.compiler(stage, host); @@ -462,11 +462,11 @@ impl Step for Clippy { const ONLY_HOSTS: bool = true; const DEFAULT: bool = false; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/clippy") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Clippy { stage: run.builder.top_stage, host: run.target, @@ -474,7 +474,7 @@ impl Step for Clippy { } /// Runs `cargo test` for clippy. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let stage = self.stage; let host = self.host; let compiler = builder.compiler(stage, host); @@ -516,7 +516,7 @@ impl Step for Clippy { } } -fn path_for_cargo(builder: &Builder, compiler: Compiler) -> OsString { +fn path_for_cargo(builder: &Builder<'_>, compiler: Compiler) -> OsString { // Configure PATH to find the right rustc. NB. we have to use PATH // and not RUSTC because the Cargo test suite has tests that will // fail if rustc is not spelled `rustc`. @@ -535,17 +535,17 @@ impl Step for RustdocTheme { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/rustdoc-themes") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let compiler = run.builder.compiler(run.builder.top_stage, run.host); run.builder.ensure(RustdocTheme { compiler }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let rustdoc = builder.out.join("bootstrap/debug/rustdoc"); let mut cmd = builder.tool_cmd(Tool::RustdocTheme); cmd.arg(rustdoc.to_str().unwrap()) @@ -584,18 +584,18 @@ impl Step for RustdocJS { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/test/rustdoc-js") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(RustdocJS { host: run.host, target: run.target, }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { if let Some(ref nodejs) = builder.config.nodejs { let mut command = Command::new(nodejs); command.args(&["src/tools/rustdoc-js/tester.js", &*self.host]); @@ -624,11 +624,11 @@ impl Step for RustdocUi { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/test/rustdoc-ui") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let compiler = run.builder.compiler(run.builder.top_stage, run.host); run.builder.ensure(RustdocUi { host: run.host, @@ -637,7 +637,7 @@ impl Step for RustdocUi { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(Compiletest { compiler: self.compiler, target: self.target, @@ -662,7 +662,7 @@ impl Step for Tidy { /// This tool in `src/tools` checks up on various bits and pieces of style and /// otherwise just implements a few lint-like checks that are specific to the /// compiler itself. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let mut cmd = builder.tool_cmd(Tool::Tidy); cmd.arg(builder.src.join("src")); cmd.arg(&builder.initial_cargo); @@ -678,16 +678,16 @@ impl Step for Tidy { try_run(builder, &mut cmd); } - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/tidy") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Tidy); } } -fn testdir(builder: &Builder, host: Interned) -> PathBuf { +fn testdir(builder: &Builder<'_>, host: Interned) -> PathBuf { builder.out.join(host).join("test") } @@ -747,11 +747,11 @@ macro_rules! test_definitions { const DEFAULT: bool = $default; const ONLY_HOSTS: bool = $host; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.suite_path($path) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let compiler = run.builder.compiler(run.builder.top_stage, run.host); run.builder.ensure($name { @@ -760,7 +760,7 @@ macro_rules! test_definitions { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(Compiletest { compiler: self.compiler, target: self.target, @@ -908,7 +908,7 @@ struct Compiletest { impl Step for Compiletest { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -917,7 +917,7 @@ impl Step for Compiletest { /// Compiles all tests with `compiler` for `target` with the specified /// compiletest `mode` and `suite` arguments. For example `mode` can be /// "run-pass" or `suite` can be something like `debuginfo`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; let mode = self.mode; @@ -1284,7 +1284,7 @@ impl Step for DocTest { type Output = (); const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -1293,7 +1293,7 @@ impl Step for DocTest { /// This will run all tests in our markdown documentation (e.g., the book) /// located in `src/doc`. The `rustdoc` that's run is the one that sits next to /// `compiler`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; builder.ensure(compile::Test { @@ -1354,17 +1354,17 @@ macro_rules! test_book { const DEFAULT: bool = $default; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path($path) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure($name { compiler: run.builder.compiler(run.builder.top_stage, run.host), }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(DocTest { compiler: self.compiler, path: $path, @@ -1398,11 +1398,11 @@ impl Step for ErrorIndex { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/error_index_generator") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(ErrorIndex { compiler: run.builder.compiler(run.builder.top_stage, run.host), }); @@ -1414,7 +1414,7 @@ impl Step for ErrorIndex { /// The `error_index_generator` tool lives in `src/tools` and is used to /// generate a markdown file from the error indexes of the code base which is /// then passed to `rustdoc --test`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; builder.ensure(compile::Std { @@ -1440,7 +1440,7 @@ impl Step for ErrorIndex { } } -fn markdown_test(builder: &Builder, compiler: Compiler, markdown: &Path) -> bool { +fn markdown_test(builder: &Builder<'_>, compiler: Compiler, markdown: &Path) -> bool { match fs::read_to_string(markdown) { Ok(contents) => { if !contents.contains("```") { @@ -1480,11 +1480,11 @@ impl Step for CrateLibrustc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.krate("rustc-main") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let builder = run.builder; let compiler = builder.compiler(builder.top_stage, run.host); @@ -1502,7 +1502,7 @@ impl Step for CrateLibrustc { } } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(Crate { compiler: self.compiler, target: self.target, @@ -1524,14 +1524,14 @@ pub struct CrateNotDefault { impl Step for CrateNotDefault { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/librustc_asan") .path("src/librustc_lsan") .path("src/librustc_msan") .path("src/librustc_tsan") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let builder = run.builder; let compiler = builder.compiler(builder.top_stage, run.host); @@ -1551,7 +1551,7 @@ impl Step for CrateNotDefault { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.ensure(Crate { compiler: self.compiler, target: self.target, @@ -1575,7 +1575,7 @@ impl Step for Crate { type Output = (); const DEFAULT: bool = true; - fn should_run(mut run: ShouldRun) -> ShouldRun { + fn should_run(mut run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run = run.krate("test"); for krate in run.builder.in_tree_crates("std") { @@ -1586,7 +1586,7 @@ impl Step for Crate { run } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let builder = run.builder; let compiler = builder.compiler(builder.top_stage, run.host); @@ -1622,7 +1622,7 @@ impl Step for Crate { /// /// Currently this runs all tests for a DAG by passing a bunch of `-p foo` /// arguments, and those arguments are discovered from `cargo metadata`. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; let mode = self.mode; @@ -1763,11 +1763,11 @@ impl Step for CrateRustdoc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.paths(&["src/librustdoc", "src/tools/rustdoc"]) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { let builder = run.builder; let test_kind = builder.kind.into(); @@ -1778,7 +1778,7 @@ impl Step for CrateRustdoc { }); } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let test_kind = self.test_kind; let compiler = builder.compiler(builder.top_stage, self.host); @@ -1846,11 +1846,11 @@ pub struct RemoteCopyLibs { impl Step for RemoteCopyLibs { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let compiler = self.compiler; let target = self.target; if !builder.remote_tested(target) { @@ -1896,16 +1896,16 @@ pub struct Distcheck; impl Step for Distcheck { type Output = (); - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("distcheck") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Distcheck); } /// Runs "distcheck", a 'make check' from a tarball - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { builder.info("Distcheck"); let dir = builder.out.join("tmp").join("distcheck"); let _ = fs::remove_dir_all(&dir); @@ -1966,7 +1966,7 @@ impl Step for Bootstrap { const ONLY_HOSTS: bool = true; /// Tests the build system itself. - fn run(self, builder: &Builder) { + fn run(self, builder: &Builder<'_>) { let mut cmd = Command::new(&builder.initial_cargo); cmd.arg("test") .current_dir(builder.src.join("src/bootstrap")) @@ -1990,11 +1990,11 @@ impl Step for Bootstrap { try_run(builder, &mut cmd); } - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/bootstrap") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Bootstrap); } } diff --git a/src/bootstrap/tool.rs b/src/bootstrap/tool.rs index 6383a2ecc7583..fc1a17d546675 100644 --- a/src/bootstrap/tool.rs +++ b/src/bootstrap/tool.rs @@ -36,7 +36,7 @@ struct ToolBuild { impl Step for ToolBuild { type Output = Option; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.never() } @@ -44,7 +44,7 @@ impl Step for ToolBuild { /// /// This will build the specified tool with the specified `host` compiler in /// `stage` into the normal cargo output directory. - fn run(self, builder: &Builder) -> Option { + fn run(self, builder: &Builder<'_>) -> Option { let compiler = self.compiler; let target = self.target; let tool = self.tool; @@ -192,7 +192,7 @@ impl Step for ToolBuild { } pub fn prepare_tool_cargo( - builder: &Builder, + builder: &Builder<'_>, compiler: Compiler, mode: Mode, target: Interned, @@ -315,18 +315,18 @@ macro_rules! tool { impl Step for $name { type Output = PathBuf; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path($path) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure($name { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { builder.ensure(ToolBuild { compiler: self.compiler, target: self.target, @@ -371,18 +371,18 @@ pub struct RemoteTestServer { impl Step for RemoteTestServer { type Output = PathBuf; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/remote-test-server") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(RemoteTestServer { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { builder.ensure(ToolBuild { compiler: self.compiler, target: self.target, @@ -406,17 +406,17 @@ impl Step for Rustdoc { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("src/tools/rustdoc") } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Rustdoc { host: run.host, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { let target_compiler = builder.compiler(builder.top_stage, self.host); if target_compiler.stage == 0 { if !target_compiler.is_snapshot(builder) { @@ -490,19 +490,19 @@ impl Step for Cargo { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path("src/tools/cargo").default_condition(builder.config.extended) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure(Cargo { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, }); } - fn run(self, builder: &Builder) -> PathBuf { + fn run(self, builder: &Builder<'_>) -> PathBuf { // Cargo depends on procedural macros, which requires a full host // compiler to be available, so we need to depend on that. builder.ensure(compile::Rustc { @@ -542,12 +542,12 @@ macro_rules! tool_extended { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - fn should_run(run: ShouldRun) -> ShouldRun { + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder; run.path($path).default_condition(builder.config.extended) } - fn make_run(run: RunConfig) { + fn make_run(run: RunConfig<'_>) { run.builder.ensure($name { compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build), target: run.target, @@ -556,7 +556,7 @@ macro_rules! tool_extended { } #[allow(unused_mut)] - fn run(mut $sel, $builder: &Builder) -> Option { + fn run(mut $sel, $builder: &Builder<'_>) -> Option { $extra_deps $builder.ensure(ToolBuild { compiler: $sel.compiler, diff --git a/src/bootstrap/util.rs b/src/bootstrap/util.rs index 29aa98971fb56..bda1e56e1e73b 100644 --- a/src/bootstrap/util.rs +++ b/src/bootstrap/util.rs @@ -95,7 +95,7 @@ pub fn push_exe_path(mut buf: PathBuf, components: &[&str]) -> PathBuf { pub struct TimeIt(bool, Instant); /// Returns an RAII structure that prints out how long it took to drop. -pub fn timeit(builder: &Builder) -> TimeIt { +pub fn timeit(builder: &Builder<'_>) -> TimeIt { TimeIt(builder.config.dry_run, Instant::now()) }