Auto merge of #114066 - matthiaskrgr:fmt_args_inline_bootstrap, r=WaffleLapkin
bootstrap: inline format!() args (0) r? `@WaffleLapkin`
This commit is contained in:
bors
commit
483ef5f4d8
@ -67,7 +67,7 @@ fn main() {
|
||||
`cp config.example.toml config.toml`"
|
||||
);
|
||||
} else if let Some(suggestion) = &changelog_suggestion {
|
||||
println!("{}", suggestion);
|
||||
println!("{suggestion}");
|
||||
}
|
||||
|
||||
let pre_commit = config.src.join(".git").join("hooks").join("pre-commit");
|
||||
@ -80,7 +80,7 @@ fn main() {
|
||||
`cp config.example.toml config.toml`"
|
||||
);
|
||||
} else if let Some(suggestion) = &changelog_suggestion {
|
||||
println!("{}", suggestion);
|
||||
println!("{suggestion}");
|
||||
}
|
||||
|
||||
// Give a warning if the pre-commit script is in pre-commit and not pre-push.
|
||||
@ -107,13 +107,13 @@ fn check_version(config: &Config) -> Option<String> {
|
||||
let suggestion = if let Some(seen) = config.changelog_seen {
|
||||
if seen != VERSION {
|
||||
msg.push_str("warning: there have been changes to x.py since you last updated.\n");
|
||||
format!("update `config.toml` to use `changelog-seen = {}` instead", VERSION)
|
||||
format!("update `config.toml` to use `changelog-seen = {VERSION}` instead")
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
} else {
|
||||
msg.push_str("warning: x.py has made several changes recently you may want to look at\n");
|
||||
format!("add `changelog-seen = {}` at the top of `config.toml`", VERSION)
|
||||
format!("add `changelog-seen = {VERSION}` at the top of `config.toml`")
|
||||
};
|
||||
|
||||
msg.push_str("help: consider looking at the changes in `src/bootstrap/CHANGELOG.md`\n");
|
||||
|
||||
@ -120,7 +120,7 @@ fn main() {
|
||||
|
||||
// Override linker if necessary.
|
||||
if let Ok(host_linker) = env::var("RUSTC_HOST_LINKER") {
|
||||
cmd.arg(format!("-Clinker={}", host_linker));
|
||||
cmd.arg(format!("-Clinker={host_linker}"));
|
||||
}
|
||||
if env::var_os("RUSTC_HOST_FUSE_LD_LLD").is_some() {
|
||||
cmd.arg("-Clink-args=-fuse-ld=lld");
|
||||
@ -206,11 +206,11 @@ fn main() {
|
||||
env::vars().filter(|(k, _)| k.starts_with("RUST") || k.starts_with("CARGO"));
|
||||
let prefix = if is_test { "[RUSTC-SHIM] rustc --test" } else { "[RUSTC-SHIM] rustc" };
|
||||
let prefix = match crate_name {
|
||||
Some(crate_name) => format!("{} {}", prefix, crate_name),
|
||||
Some(crate_name) => format!("{prefix} {crate_name}"),
|
||||
None => prefix.to_string(),
|
||||
};
|
||||
for (i, (k, v)) in rust_env_vars.enumerate() {
|
||||
eprintln!("{} env[{}]: {:?}={:?}", prefix, i, k, v);
|
||||
eprintln!("{prefix} env[{i}]: {k:?}={v:?}");
|
||||
}
|
||||
eprintln!("{} working directory: {}", prefix, env::current_dir().unwrap().display());
|
||||
eprintln!(
|
||||
@ -220,13 +220,13 @@ fn main() {
|
||||
env::join_paths(&dylib_path).unwrap(),
|
||||
cmd,
|
||||
);
|
||||
eprintln!("{} sysroot: {:?}", prefix, sysroot);
|
||||
eprintln!("{} libdir: {:?}", prefix, libdir);
|
||||
eprintln!("{prefix} sysroot: {sysroot:?}");
|
||||
eprintln!("{prefix} libdir: {libdir:?}");
|
||||
}
|
||||
|
||||
let start = Instant::now();
|
||||
let (child, status) = {
|
||||
let errmsg = format!("\nFailed to run:\n{:?}\n-------------", cmd);
|
||||
let errmsg = format!("\nFailed to run:\n{cmd:?}\n-------------");
|
||||
let mut child = cmd.spawn().expect(&errmsg);
|
||||
let status = child.wait().expect(&errmsg);
|
||||
(child, status)
|
||||
@ -259,7 +259,7 @@ fn main() {
|
||||
// should run on success, after this block.
|
||||
}
|
||||
if verbose > 0 {
|
||||
println!("\nDid not run successfully: {}\n{:?}\n-------------", status, cmd);
|
||||
println!("\nDid not run successfully: {status}\n{cmd:?}\n-------------");
|
||||
}
|
||||
|
||||
if let Some(mut on_fail) = on_fail {
|
||||
@ -271,7 +271,7 @@ fn main() {
|
||||
match status.code() {
|
||||
Some(i) => std::process::exit(i),
|
||||
None => {
|
||||
eprintln!("rustc exited with {}", status);
|
||||
eprintln!("rustc exited with {status}");
|
||||
std::process::exit(0xfe);
|
||||
}
|
||||
}
|
||||
@ -396,21 +396,20 @@ fn format_rusage_data(_child: Child) -> Option<String> {
|
||||
let minflt = rusage.ru_minflt;
|
||||
let majflt = rusage.ru_majflt;
|
||||
if minflt != 0 || majflt != 0 {
|
||||
init_str.push_str(&format!(" page reclaims: {} page faults: {}", minflt, majflt));
|
||||
init_str.push_str(&format!(" page reclaims: {minflt} page faults: {majflt}"));
|
||||
}
|
||||
|
||||
let inblock = rusage.ru_inblock;
|
||||
let oublock = rusage.ru_oublock;
|
||||
if inblock != 0 || oublock != 0 {
|
||||
init_str.push_str(&format!(" fs block inputs: {} fs block outputs: {}", inblock, oublock));
|
||||
init_str.push_str(&format!(" fs block inputs: {inblock} fs block outputs: {oublock}"));
|
||||
}
|
||||
|
||||
let nvcsw = rusage.ru_nvcsw;
|
||||
let nivcsw = rusage.ru_nivcsw;
|
||||
if nvcsw != 0 || nivcsw != 0 {
|
||||
init_str.push_str(&format!(
|
||||
" voluntary ctxt switches: {} involuntary ctxt switches: {}",
|
||||
nvcsw, nivcsw
|
||||
" voluntary ctxt switches: {nvcsw} involuntary ctxt switches: {nivcsw}"
|
||||
));
|
||||
}
|
||||
|
||||
|
||||
@ -62,7 +62,7 @@ fn main() {
|
||||
}
|
||||
if let Ok(no_threads) = env::var("RUSTDOC_LLD_NO_THREADS") {
|
||||
cmd.arg("-Clink-arg=-fuse-ld=lld");
|
||||
cmd.arg(format!("-Clink-arg=-Wl,{}", no_threads));
|
||||
cmd.arg(format!("-Clink-arg=-Wl,{no_threads}"));
|
||||
}
|
||||
// Cargo doesn't pass RUSTDOCFLAGS to proc_macros:
|
||||
// https://github.com/rust-lang/cargo/issues/4423
|
||||
@ -82,12 +82,12 @@ fn main() {
|
||||
env::join_paths(&dylib_path).unwrap(),
|
||||
cmd,
|
||||
);
|
||||
eprintln!("sysroot: {:?}", sysroot);
|
||||
eprintln!("libdir: {:?}", libdir);
|
||||
eprintln!("sysroot: {sysroot:?}");
|
||||
eprintln!("libdir: {libdir:?}");
|
||||
}
|
||||
|
||||
std::process::exit(match cmd.status() {
|
||||
Ok(s) => s.code().unwrap_or(1),
|
||||
Err(e) => panic!("\n\nfailed to run {:?}: {}\n\n", cmd, e),
|
||||
Err(e) => panic!("\n\nfailed to run {cmd:?}: {e}\n\n"),
|
||||
})
|
||||
}
|
||||
|
||||
@ -3,5 +3,5 @@
|
||||
fn main() {
|
||||
let host = env::var("HOST").unwrap();
|
||||
println!("cargo:rerun-if-changed=build.rs");
|
||||
println!("cargo:rustc-env=BUILD_TRIPLE={}", host);
|
||||
println!("cargo:rustc-env=BUILD_TRIPLE={host}");
|
||||
}
|
||||
|
||||
@ -319,7 +319,7 @@ fn maybe_run(&self, builder: &Builder<'_>, pathsets: Vec<PathSet>) {
|
||||
fn is_excluded(&self, builder: &Builder<'_>, pathset: &PathSet) -> bool {
|
||||
if builder.config.exclude.iter().any(|e| pathset.has(&e, builder.kind)) {
|
||||
if !matches!(builder.config.dry_run, DryRun::SelfCheck) {
|
||||
println!("Skipping {:?} because it is excluded", pathset);
|
||||
println!("Skipping {pathset:?} because it is excluded");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@ -473,8 +473,7 @@ pub fn alias(mut self, alias: &str) -> Self {
|
||||
// `compiler` and `library` folders respectively.
|
||||
assert!(
|
||||
self.kind == Kind::Setup || !self.builder.src.join(alias).exists(),
|
||||
"use `builder.path()` for real paths: {}",
|
||||
alias
|
||||
"use `builder.path()` for real paths: {alias}"
|
||||
);
|
||||
self.paths.insert(PathSet::Set(
|
||||
std::iter::once(TaskPath { path: alias.into(), kind: Some(self.kind) }).collect(),
|
||||
@ -1283,7 +1282,7 @@ pub fn cargo(
|
||||
out_dir.join(target.triple).join("doc")
|
||||
}
|
||||
}
|
||||
_ => panic!("doc mode {:?} not expected", mode),
|
||||
_ => panic!("doc mode {mode:?} not expected"),
|
||||
};
|
||||
let rustdoc = self.rustdoc(compiler);
|
||||
self.clear_if_dirty(&my_out, &rustdoc);
|
||||
@ -1637,15 +1636,15 @@ pub fn cargo(
|
||||
// so. Note that this is definitely a hack, and we should likely
|
||||
// flesh out rpath support more fully in the future.
|
||||
rustflags.arg("-Zosx-rpath-install-name");
|
||||
Some(format!("-Wl,-rpath,@loader_path/../{}", libdir))
|
||||
Some(format!("-Wl,-rpath,@loader_path/../{libdir}"))
|
||||
} else if !target.contains("windows") && !target.contains("aix") {
|
||||
rustflags.arg("-Clink-args=-Wl,-z,origin");
|
||||
Some(format!("-Wl,-rpath,$ORIGIN/../{}", libdir))
|
||||
Some(format!("-Wl,-rpath,$ORIGIN/../{libdir}"))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(rpath) = rpath {
|
||||
rustflags.arg(&format!("-Clink-args={}", rpath));
|
||||
rustflags.arg(&format!("-Clink-args={rpath}"));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1659,7 +1658,7 @@ pub fn cargo(
|
||||
|
||||
if let Some(target_linker) = self.linker(target) {
|
||||
let target = crate::envify(&target.triple);
|
||||
cargo.env(&format!("CARGO_TARGET_{}_LINKER", target), target_linker);
|
||||
cargo.env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
|
||||
}
|
||||
if self.is_fuse_ld_lld(target) {
|
||||
rustflags.arg("-Clink-args=-fuse-ld=lld");
|
||||
@ -1895,24 +1894,24 @@ pub fn cargo(
|
||||
};
|
||||
let triple_underscored = target.triple.replace("-", "_");
|
||||
let cc = ccacheify(&self.cc(target));
|
||||
cargo.env(format!("CC_{}", triple_underscored), &cc);
|
||||
cargo.env(format!("CC_{triple_underscored}"), &cc);
|
||||
|
||||
let cflags = self.cflags(target, GitRepo::Rustc, CLang::C).join(" ");
|
||||
cargo.env(format!("CFLAGS_{}", triple_underscored), &cflags);
|
||||
cargo.env(format!("CFLAGS_{triple_underscored}"), &cflags);
|
||||
|
||||
if let Some(ar) = self.ar(target) {
|
||||
let ranlib = format!("{} s", ar.display());
|
||||
cargo
|
||||
.env(format!("AR_{}", triple_underscored), ar)
|
||||
.env(format!("RANLIB_{}", triple_underscored), ranlib);
|
||||
.env(format!("AR_{triple_underscored}"), ar)
|
||||
.env(format!("RANLIB_{triple_underscored}"), ranlib);
|
||||
}
|
||||
|
||||
if let Ok(cxx) = self.cxx(target) {
|
||||
let cxx = ccacheify(&cxx);
|
||||
let cxxflags = self.cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");
|
||||
cargo
|
||||
.env(format!("CXX_{}", triple_underscored), &cxx)
|
||||
.env(format!("CXXFLAGS_{}", triple_underscored), cxxflags);
|
||||
.env(format!("CXX_{triple_underscored}"), &cxx)
|
||||
.env(format!("CXXFLAGS_{triple_underscored}"), cxxflags);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2025,7 +2024,7 @@ pub fn cargo(
|
||||
if let Some(limit) = limit {
|
||||
if stage == 0 || self.config.default_codegen_backend().unwrap_or_default() == "llvm"
|
||||
{
|
||||
rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={}", limit));
|
||||
rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={limit}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2033,7 +2032,7 @@ pub fn cargo(
|
||||
if matches!(mode, Mode::Std) {
|
||||
if let Some(mir_opt_level) = self.config.rust_validate_mir_opts {
|
||||
rustflags.arg("-Zvalidate-mir");
|
||||
rustflags.arg(&format!("-Zmir-opt-level={}", mir_opt_level));
|
||||
rustflags.arg(&format!("-Zmir-opt-level={mir_opt_level}"));
|
||||
}
|
||||
// Always enable inlining MIR when building the standard library.
|
||||
// Without this flag, MIR inlining is disabled when incremental compilation is enabled.
|
||||
@ -2065,9 +2064,9 @@ pub fn ensure<S: Step>(&'a self, step: S) -> S::Output {
|
||||
continue;
|
||||
}
|
||||
let mut out = String::new();
|
||||
out += &format!("\n\nCycle in build detected when adding {:?}\n", step);
|
||||
out += &format!("\n\nCycle in build detected when adding {step:?}\n");
|
||||
for el in stack.iter().rev() {
|
||||
out += &format!("\t{:?}\n", el);
|
||||
out += &format!("\t{el:?}\n");
|
||||
}
|
||||
panic!("{}", out);
|
||||
}
|
||||
@ -2094,7 +2093,7 @@ pub fn ensure<S: Step>(&'a self, step: S) -> S::Output {
|
||||
};
|
||||
|
||||
if self.config.print_step_timings && !self.config.dry_run() {
|
||||
let step_string = format!("{:?}", step);
|
||||
let step_string = format!("{step:?}");
|
||||
let brace_index = step_string.find("{").unwrap_or(0);
|
||||
let type_string = type_name::<S>();
|
||||
println!(
|
||||
@ -2174,7 +2173,7 @@ pub(crate) fn open_in_browser(&self, path: impl AsRef<Path>) {
|
||||
let path = path.as_ref();
|
||||
self.info(&format!("Opening doc {}", path.display()));
|
||||
if let Err(err) = opener::open(path) {
|
||||
self.info(&format!("{}\n", err));
|
||||
self.info(&format!("{err}\n"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -75,7 +75,7 @@ impl<T, U: ?Sized + fmt::Debug> fmt::Debug for Interned<T>
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let s: &U = &*self;
|
||||
f.write_fmt(format_args!("{:?}", s))
|
||||
f.write_fmt(format_args!("{s:?}"))
|
||||
}
|
||||
}
|
||||
|
||||
@ -236,7 +236,7 @@ pub fn put<S: Step>(&self, step: S, value: S::Output) {
|
||||
.or_insert_with(|| Box::new(HashMap::<S, S::Output>::new()))
|
||||
.downcast_mut::<HashMap<S, S::Output>>()
|
||||
.expect("invalid type mapped");
|
||||
assert!(!stepcache.contains_key(&step), "processing {:?} a second time", step);
|
||||
assert!(!stepcache.contains_key(&step), "processing {step:?} a second time");
|
||||
stepcache.insert(step, value);
|
||||
}
|
||||
|
||||
|
||||
@ -196,7 +196,7 @@ fn set_compiler(
|
||||
'0'..='6' => {}
|
||||
_ => return,
|
||||
}
|
||||
let alternative = format!("e{}", gnu_compiler);
|
||||
let alternative = format!("e{gnu_compiler}");
|
||||
if Command::new(&alternative).output().is_ok() {
|
||||
cfg.compiler(alternative);
|
||||
}
|
||||
|
||||
@ -322,7 +322,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
);
|
||||
cargo
|
||||
.arg("--manifest-path")
|
||||
.arg(builder.src.join(format!("compiler/rustc_codegen_{}/Cargo.toml", backend)));
|
||||
.arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
|
||||
rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
|
||||
|
||||
let _guard = builder.msg_check(&backend, target);
|
||||
@ -525,5 +525,5 @@ fn codegen_backend_stamp(
|
||||
) -> PathBuf {
|
||||
builder
|
||||
.cargo_out(compiler, Mode::Codegen, target)
|
||||
.join(format!(".librustc_codegen_{}-check.stamp", backend))
|
||||
.join(format!(".librustc_codegen_{backend}-check.stamp"))
|
||||
}
|
||||
|
||||
@ -815,7 +815,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
|
||||
let is_collecting = if let Some(path) = &builder.config.rust_profile_generate {
|
||||
if compiler.stage == 1 {
|
||||
cargo.rustflag(&format!("-Cprofile-generate={}", path));
|
||||
cargo.rustflag(&format!("-Cprofile-generate={path}"));
|
||||
// Apparently necessary to avoid overflowing the counters during
|
||||
// a Cargo build profile
|
||||
cargo.rustflag("-Cllvm-args=-vp-counters-per-site=4");
|
||||
@ -825,7 +825,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
}
|
||||
} else if let Some(path) = &builder.config.rust_profile_use {
|
||||
if compiler.stage == 1 {
|
||||
cargo.rustflag(&format!("-Cprofile-use={}", path));
|
||||
cargo.rustflag(&format!("-Cprofile-use={path}"));
|
||||
cargo.rustflag("-Cllvm-args=-pgo-warn-missing-function");
|
||||
true
|
||||
} else {
|
||||
@ -858,7 +858,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
RustcLto::Fat => "fat",
|
||||
_ => unreachable!(),
|
||||
};
|
||||
cargo.rustflag(&format!("-Clto={}", lto_type));
|
||||
cargo.rustflag(&format!("-Clto={lto_type}"));
|
||||
cargo.rustflag("-Cembed-bitcode=yes");
|
||||
}
|
||||
RustcLto::ThinLocal => { /* Do nothing, this is the default */ }
|
||||
@ -1192,7 +1192,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
let mut cargo = builder.cargo(compiler, Mode::Codegen, SourceType::InTree, target, "build");
|
||||
cargo
|
||||
.arg("--manifest-path")
|
||||
.arg(builder.src.join(format!("compiler/rustc_codegen_{}/Cargo.toml", backend)));
|
||||
.arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
|
||||
rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
|
||||
|
||||
let tmp_stamp = out_dir.join(".tmp.stamp");
|
||||
@ -1297,7 +1297,7 @@ fn codegen_backend_stamp(
|
||||
) -> PathBuf {
|
||||
builder
|
||||
.cargo_out(compiler, Mode::Codegen, target)
|
||||
.join(format!(".librustc_codegen_{}.stamp", backend))
|
||||
.join(format!(".librustc_codegen_{backend}.stamp"))
|
||||
}
|
||||
|
||||
pub fn compiler_file(
|
||||
@ -1312,7 +1312,7 @@ pub fn compiler_file(
|
||||
}
|
||||
let mut cmd = Command::new(compiler);
|
||||
cmd.args(builder.cflags(target, GitRepo::Rustc, c));
|
||||
cmd.arg(format!("-print-file-name={}", file));
|
||||
cmd.arg(format!("-print-file-name={file}"));
|
||||
let out = output(&mut cmd);
|
||||
PathBuf::from(out.trim())
|
||||
}
|
||||
@ -1836,10 +1836,10 @@ pub fn run_cargo(
|
||||
});
|
||||
let path_to_add = match max {
|
||||
Some(triple) => triple.0.to_str().unwrap(),
|
||||
None => panic!("no output generated for {:?} {:?}", prefix, extension),
|
||||
None => panic!("no output generated for {prefix:?} {extension:?}"),
|
||||
};
|
||||
if is_dylib(path_to_add) {
|
||||
let candidate = format!("{}.lib", path_to_add);
|
||||
let candidate = format!("{path_to_add}.lib");
|
||||
let candidate = PathBuf::from(candidate);
|
||||
if candidate.exists() {
|
||||
deps.push((candidate, DependencyType::Target));
|
||||
@ -1891,10 +1891,10 @@ pub fn stream_cargo(
|
||||
cargo.arg(arg);
|
||||
}
|
||||
|
||||
builder.verbose(&format!("running: {:?}", cargo));
|
||||
builder.verbose(&format!("running: {cargo:?}"));
|
||||
let mut child = match cargo.spawn() {
|
||||
Ok(child) => child,
|
||||
Err(e) => panic!("failed to execute command: {:?}\nerror: {}", cargo, e),
|
||||
Err(e) => panic!("failed to execute command: {cargo:?}\nerror: {e}"),
|
||||
};
|
||||
|
||||
// Spawn Cargo slurping up its JSON output. We'll start building up the
|
||||
@ -1907,12 +1907,12 @@ pub fn stream_cargo(
|
||||
Ok(msg) => {
|
||||
if builder.config.json_output {
|
||||
// Forward JSON to stdout.
|
||||
println!("{}", line);
|
||||
println!("{line}");
|
||||
}
|
||||
cb(msg)
|
||||
}
|
||||
// If this was informational, just print it out and continue
|
||||
Err(_) => println!("{}", line),
|
||||
Err(_) => println!("{line}"),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1920,9 +1920,8 @@ pub fn stream_cargo(
|
||||
let status = t!(child.wait());
|
||||
if builder.is_verbose() && !status.success() {
|
||||
eprintln!(
|
||||
"command did not execute successfully: {:?}\n\
|
||||
expected success, got: {}",
|
||||
cargo, status
|
||||
"command did not execute successfully: {cargo:?}\n\
|
||||
expected success, got: {status}"
|
||||
);
|
||||
}
|
||||
status.success()
|
||||
|
||||
@ -356,7 +356,7 @@ fn from_str(value: &str) -> Result<Self, Self::Err> {
|
||||
"no" => Ok(Self::No),
|
||||
"in-tree" => Ok(Self::InTree),
|
||||
"system" => Ok(Self::System),
|
||||
invalid => Err(format!("Invalid value '{}' for rust.llvm-libunwind config.", invalid)),
|
||||
invalid => Err(format!("Invalid value '{invalid}' for rust.llvm-libunwind config.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -420,7 +420,7 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
"thin" => Ok(RustcLto::Thin),
|
||||
"fat" => Ok(RustcLto::Fat),
|
||||
"off" => Ok(RustcLto::Off),
|
||||
_ => Err(format!("Invalid value for rustc LTO: {}", s)),
|
||||
_ => Err(format!("Invalid value for rustc LTO: {s}")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -498,7 +498,7 @@ impl fmt::Display for TargetSelection {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", self.triple)?;
|
||||
if let Some(file) = self.file {
|
||||
write!(f, "({})", file)?;
|
||||
write!(f, "({file})")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@ -506,7 +506,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
|
||||
impl fmt::Debug for TargetSelection {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", self)
|
||||
write!(f, "{self}")
|
||||
}
|
||||
}
|
||||
|
||||
@ -938,8 +938,7 @@ fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
|
||||
|
||||
fn format_optimize_error_msg(v: impl std::fmt::Display) -> String {
|
||||
format!(
|
||||
r#"unrecognized option for rust optimize: "{}", expected one of 0, 1, 2, 3, "s", "z", true, false"#,
|
||||
v
|
||||
r#"unrecognized option for rust optimize: "{v}", expected one of 0, 1, 2, 3, "s", "z", true, false"#
|
||||
)
|
||||
}
|
||||
|
||||
@ -1226,7 +1225,7 @@ fn parse_inner(args: &[String], get_toml: impl Fn(&Path) -> TomlConfig) -> Confi
|
||||
include_path.push("src");
|
||||
include_path.push("bootstrap");
|
||||
include_path.push("defaults");
|
||||
include_path.push(format!("config.{}.toml", include));
|
||||
include_path.push(format!("config.{include}.toml"));
|
||||
let included_toml = get_toml(&include_path);
|
||||
toml.merge(included_toml, ReplaceOpt::IgnoreDuplicate);
|
||||
}
|
||||
@ -1516,7 +1515,7 @@ fn get_table(option: &str) -> Result<TomlConfig, toml::de::Error> {
|
||||
let asserts = llvm_assertions.unwrap_or(false);
|
||||
config.llvm_from_ci = match llvm.download_ci_llvm {
|
||||
Some(StringOrBool::String(s)) => {
|
||||
assert!(s == "if-available", "unknown option `{}` for download-ci-llvm", s);
|
||||
assert!(s == "if-available", "unknown option `{s}` for download-ci-llvm");
|
||||
crate::llvm::is_ci_llvm_available(&config, asserts)
|
||||
}
|
||||
Some(StringOrBool::Bool(b)) => b,
|
||||
@ -1750,7 +1749,7 @@ pub(crate) fn try_run(&self, cmd: &mut Command) -> Result<(), ()> {
|
||||
if self.dry_run() {
|
||||
return Ok(());
|
||||
}
|
||||
self.verbose(&format!("running: {:?}", cmd));
|
||||
self.verbose(&format!("running: {cmd:?}"));
|
||||
build_helper::util::try_run(cmd, self.is_verbose())
|
||||
}
|
||||
|
||||
@ -1790,10 +1789,10 @@ pub(crate) fn args(&self) -> Vec<&str> {
|
||||
pub(crate) fn artifact_version_part(&self, commit: &str) -> String {
|
||||
let (channel, version) = if self.rust_info.is_managed_git_subrepository() {
|
||||
let mut channel = self.git();
|
||||
channel.arg("show").arg(format!("{}:src/ci/channel", commit));
|
||||
channel.arg("show").arg(format!("{commit}:src/ci/channel"));
|
||||
let channel = output(&mut channel);
|
||||
let mut version = self.git();
|
||||
version.arg("show").arg(format!("{}:src/version", commit));
|
||||
version.arg("show").arg(format!("{commit}:src/version"));
|
||||
let version = output(&mut version);
|
||||
(channel.trim().to_owned(), version.trim().to_owned())
|
||||
} else {
|
||||
@ -1810,10 +1809,10 @@ pub(crate) fn artifact_version_part(&self, commit: &str) -> String {
|
||||
"help: consider using a git checkout or ensure these files are readable"
|
||||
);
|
||||
if let Err(channel) = channel {
|
||||
eprintln!("reading {}/src/ci/channel failed: {:?}", src, channel);
|
||||
eprintln!("reading {src}/src/ci/channel failed: {channel:?}");
|
||||
}
|
||||
if let Err(version) = version {
|
||||
eprintln!("reading {}/src/version failed: {:?}", src, version);
|
||||
eprintln!("reading {src}/src/version failed: {version:?}");
|
||||
}
|
||||
panic!();
|
||||
}
|
||||
@ -1939,7 +1938,7 @@ pub(crate) fn initial_rustfmt(&self) -> Option<PathBuf> {
|
||||
|
||||
pub fn verbose(&self, msg: &str) {
|
||||
if self.verbose > 0 {
|
||||
println!("{}", msg);
|
||||
println!("{msg}");
|
||||
}
|
||||
}
|
||||
|
||||
@ -2016,8 +2015,7 @@ pub fn check_build_rustc_version(&self, rustc_path: &str) {
|
||||
{
|
||||
let prev_version = format!("{}.{}.x", source_version.major, source_version.minor - 1);
|
||||
eprintln!(
|
||||
"Unexpected rustc version: {}, we should use {}/{} to build source with {}",
|
||||
rustc_version, prev_version, source_version, source_version
|
||||
"Unexpected rustc version: {rustc_version}, we should use {prev_version}/{source_version} to build source with {source_version}"
|
||||
);
|
||||
exit!(1);
|
||||
}
|
||||
@ -2031,7 +2029,7 @@ fn download_ci_rustc_commit(&self, download_rustc: Option<StringOrBool>) -> Opti
|
||||
Some(StringOrBool::Bool(true)) => false,
|
||||
Some(StringOrBool::String(s)) if s == "if-unchanged" => true,
|
||||
Some(StringOrBool::String(other)) => {
|
||||
panic!("unrecognized option for download-rustc: {}", other)
|
||||
panic!("unrecognized option for download-rustc: {other}")
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -162,7 +162,7 @@ fn find_files(files: &[&str], path: &[PathBuf]) -> Vec<PathBuf> {
|
||||
if let Some(file_path) = file_path {
|
||||
found.push(file_path);
|
||||
} else {
|
||||
panic!("Could not find '{}' in {:?}", file, path);
|
||||
panic!("Could not find '{file}' in {path:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1480,8 +1480,8 @@ macro_rules! add_component {
|
||||
rtf.push('}');
|
||||
|
||||
fn filter(contents: &str, marker: &str) -> String {
|
||||
let start = format!("tool-{}-start", marker);
|
||||
let end = format!("tool-{}-end", marker);
|
||||
let start = format!("tool-{marker}-start");
|
||||
let end = format!("tool-{marker}-end");
|
||||
let mut lines = Vec::new();
|
||||
let mut omitted = false;
|
||||
for line in contents.lines() {
|
||||
@ -1862,7 +1862,7 @@ fn filter(contents: &str, marker: &str) -> String {
|
||||
builder.install(&etc.join("gfx/banner.bmp"), &exe, 0o644);
|
||||
builder.install(&etc.join("gfx/dialogbg.bmp"), &exe, 0o644);
|
||||
|
||||
builder.info(&format!("building `msi` installer with {:?}", light));
|
||||
builder.info(&format!("building `msi` installer with {light:?}"));
|
||||
let filename = format!("{}-{}.msi", pkgname(builder, "rust"), target.triple);
|
||||
let mut cmd = Command::new(&light);
|
||||
cmd.arg("-nologo")
|
||||
@ -1996,7 +1996,7 @@ fn maybe_install_llvm(builder: &Builder<'_>, target: TargetSelection, dst_libdir
|
||||
{
|
||||
let mut cmd = Command::new(llvm_config);
|
||||
cmd.arg("--libfiles");
|
||||
builder.verbose(&format!("running {:?}", cmd));
|
||||
builder.verbose(&format!("running {cmd:?}"));
|
||||
let files = if builder.config.dry_run() { "".into() } else { output(&mut cmd) };
|
||||
let build_llvm_out = &builder.llvm_out(builder.config.build);
|
||||
let target_llvm_out = &builder.llvm_out(target);
|
||||
@ -2175,7 +2175,7 @@ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
|
||||
/* run only if llvm-config isn't used */
|
||||
if let Some(config) = builder.config.target_config.get(&target) {
|
||||
if let Some(ref _s) = config.llvm_config {
|
||||
builder.info(&format!("Skipping LlvmTools ({}): external LLVM", target));
|
||||
builder.info(&format!("Skipping LlvmTools ({target}): external LLVM"));
|
||||
return None;
|
||||
}
|
||||
}
|
||||
@ -2231,7 +2231,7 @@ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
|
||||
/* run only if llvm-config isn't used */
|
||||
if let Some(config) = builder.config.target_config.get(&target) {
|
||||
if let Some(ref _s) = config.llvm_config {
|
||||
builder.info(&format!("Skipping RustDev ({}): external LLVM", target));
|
||||
builder.info(&format!("Skipping RustDev ({target}): external LLVM"));
|
||||
return None;
|
||||
}
|
||||
}
|
||||
|
||||
@ -147,7 +147,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
|
||||
if !builder.config.dry_run() && !(up_to_date(&src, &index) || up_to_date(&rustbook, &index))
|
||||
{
|
||||
builder.info(&format!("Rustbook ({}) - {}", target, name));
|
||||
builder.info(&format!("Rustbook ({target}) - {name}"));
|
||||
let _ = fs::remove_dir_all(&out);
|
||||
|
||||
builder.run(rustbook_cmd.arg("build").arg(&src).arg("-d").arg(out));
|
||||
@ -219,7 +219,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
for edition in &["first-edition", "second-edition", "2018-edition"] {
|
||||
builder.ensure(RustbookSrc {
|
||||
target,
|
||||
name: INTERNER.intern_string(format!("book/{}", edition)),
|
||||
name: INTERNER.intern_string(format!("book/{edition}")),
|
||||
src: INTERNER.intern_path(absolute_path.join(edition)),
|
||||
// There should only be one book that is marked as the parent for each target, so
|
||||
// treat the other editions as not having a parent.
|
||||
@ -966,7 +966,7 @@ fn make_run(run: RunConfig<'_>) {
|
||||
fn run(self, builder: &Builder<'_>) {
|
||||
let target = self.target;
|
||||
|
||||
builder.info(&format!("Generating unstable book md files ({})", target));
|
||||
builder.info(&format!("Generating unstable book md files ({target})"));
|
||||
let out = builder.md_doc_out(target).join("unstable-book");
|
||||
builder.create_dir(&out);
|
||||
builder.remove_dir(&out);
|
||||
|
||||
@ -64,7 +64,7 @@ pub(crate) fn check_run(&self, cmd: &mut Command) -> bool {
|
||||
if self.dry_run() {
|
||||
return true;
|
||||
}
|
||||
self.verbose(&format!("running: {:?}", cmd));
|
||||
self.verbose(&format!("running: {cmd:?}"));
|
||||
check_run(cmd, self.is_verbose())
|
||||
}
|
||||
|
||||
@ -206,7 +206,7 @@ fn download_file(&self, url: &str, dest_path: &Path, help_on_error: &str) {
|
||||
}
|
||||
|
||||
fn download_http_with_retries(&self, tempfile: &Path, url: &str, help_on_error: &str) {
|
||||
println!("downloading {}", url);
|
||||
println!("downloading {url}");
|
||||
// Try curl. If that fails and we are on windows, fallback to PowerShell.
|
||||
let mut curl = Command::new("curl");
|
||||
curl.args(&[
|
||||
@ -248,7 +248,7 @@ fn download_http_with_retries(&self, tempfile: &Path, url: &str, help_on_error:
|
||||
}
|
||||
}
|
||||
if !help_on_error.is_empty() {
|
||||
eprintln!("{}", help_on_error);
|
||||
eprintln!("{help_on_error}");
|
||||
}
|
||||
crate::exit!(1);
|
||||
}
|
||||
@ -646,7 +646,7 @@ pub(crate) fn maybe_download_ci_llvm(&self) {
|
||||
fn download_ci_llvm(&self, llvm_sha: &str) {
|
||||
let llvm_assertions = self.llvm_assertions;
|
||||
|
||||
let cache_prefix = format!("llvm-{}-{}", llvm_sha, llvm_assertions);
|
||||
let cache_prefix = format!("llvm-{llvm_sha}-{llvm_assertions}");
|
||||
let cache_dst = self.out.join("cache");
|
||||
let rustc_cache = cache_dst.join(cache_prefix);
|
||||
if !rustc_cache.exists() {
|
||||
|
||||
@ -189,7 +189,7 @@ struct HelpVerboseOnly {
|
||||
let build = Build::new(config);
|
||||
let paths = Builder::get_help(&build, subcommand);
|
||||
if let Some(s) = paths {
|
||||
println!("{}", s);
|
||||
println!("{s}");
|
||||
} else {
|
||||
panic!("No paths available for subcommand `{}`", subcommand.as_str());
|
||||
}
|
||||
|
||||
@ -22,7 +22,7 @@ fn rustfmt(src: &Path, rustfmt: &Path, paths: &[PathBuf], check: bool) -> impl F
|
||||
cmd.arg("--check");
|
||||
}
|
||||
cmd.args(paths);
|
||||
let cmd_debug = format!("{:?}", cmd);
|
||||
let cmd_debug = format!("{cmd:?}");
|
||||
let mut cmd = cmd.spawn().expect("running rustfmt");
|
||||
// poor man's async: return a closure that'll wait for rustfmt's completion
|
||||
move |block: bool| -> bool {
|
||||
@ -115,7 +115,7 @@ pub fn format(build: &Builder<'_>, check: bool, paths: &[PathBuf]) {
|
||||
let rustfmt_config: RustfmtConfig = t!(toml::from_str(&rustfmt_config));
|
||||
let mut ignore_fmt = ignore::overrides::OverrideBuilder::new(&build.src);
|
||||
for ignore in rustfmt_config.ignore {
|
||||
ignore_fmt.add(&format!("!{}", ignore)).expect(&ignore);
|
||||
ignore_fmt.add(&format!("!{ignore}")).expect(&ignore);
|
||||
}
|
||||
let git_available = match Command::new("git")
|
||||
.arg("--version")
|
||||
@ -153,13 +153,13 @@ pub fn format(build: &Builder<'_>, check: bool, paths: &[PathBuf]) {
|
||||
entry.split(' ').nth(1).expect("every git status entry should list a path")
|
||||
});
|
||||
for untracked_path in untracked_paths {
|
||||
println!("skip untracked path {} during rustfmt invocations", untracked_path);
|
||||
println!("skip untracked path {untracked_path} during rustfmt invocations");
|
||||
// The leading `/` makes it an exact match against the
|
||||
// repository root, rather than a glob. Without that, if you
|
||||
// have `foo.rs` in the repository root it will also match
|
||||
// against anything like `compiler/rustc_foo/src/foo.rs`,
|
||||
// preventing the latter from being formatted.
|
||||
ignore_fmt.add(&format!("!/{}", untracked_path)).expect(&untracked_path);
|
||||
ignore_fmt.add(&format!("!/{untracked_path}")).expect(&untracked_path);
|
||||
}
|
||||
// Only check modified files locally to speed up runtime.
|
||||
// We still check all files in CI to avoid bugs in `get_modified_rs_files` letting regressions slip through;
|
||||
|
||||
@ -484,7 +484,7 @@ pub fn new(mut config: Config) -> Build {
|
||||
.unwrap()
|
||||
.trim();
|
||||
if local_release.split('.').take(2).eq(version.split('.').take(2)) {
|
||||
build.verbose(&format!("auto-detected local-rebuild {}", local_release));
|
||||
build.verbose(&format!("auto-detected local-rebuild {local_release}"));
|
||||
build.local_rebuild = true;
|
||||
}
|
||||
|
||||
@ -713,7 +713,7 @@ pub fn build(&mut self) {
|
||||
if failures.len() > 0 {
|
||||
eprintln!("\n{} command(s) did not execute successfully:\n", failures.len());
|
||||
for failure in failures.iter() {
|
||||
eprintln!(" - {}\n", failure);
|
||||
eprintln!(" - {failure}\n");
|
||||
}
|
||||
exit!(1);
|
||||
}
|
||||
@ -959,7 +959,7 @@ fn run(&self, cmd: &mut Command) {
|
||||
if self.config.dry_run() {
|
||||
return;
|
||||
}
|
||||
self.verbose(&format!("running: {:?}", cmd));
|
||||
self.verbose(&format!("running: {cmd:?}"));
|
||||
run(cmd, self.is_verbose())
|
||||
}
|
||||
|
||||
@ -968,7 +968,7 @@ fn run_quiet(&self, cmd: &mut Command) {
|
||||
if self.config.dry_run() {
|
||||
return;
|
||||
}
|
||||
self.verbose(&format!("running: {:?}", cmd));
|
||||
self.verbose(&format!("running: {cmd:?}"));
|
||||
run_suppressed(cmd)
|
||||
}
|
||||
|
||||
@ -980,10 +980,10 @@ fn run_quiet_delaying_failure(&self, cmd: &mut Command) -> bool {
|
||||
return true;
|
||||
}
|
||||
if !self.fail_fast {
|
||||
self.verbose(&format!("running: {:?}", cmd));
|
||||
self.verbose(&format!("running: {cmd:?}"));
|
||||
if !try_run_suppressed(cmd) {
|
||||
let mut failures = self.delayed_failures.borrow_mut();
|
||||
failures.push(format!("{:?}", cmd));
|
||||
failures.push(format!("{cmd:?}"));
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
@ -998,7 +998,7 @@ pub(crate) fn run_delaying_failure(&self, cmd: &mut Command) -> bool {
|
||||
#[allow(deprecated)] // can't use Build::try_run, that's us
|
||||
if self.config.try_run(cmd).is_err() {
|
||||
let mut failures = self.delayed_failures.borrow_mut();
|
||||
failures.push(format!("{:?}", cmd));
|
||||
failures.push(format!("{cmd:?}"));
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
@ -1014,7 +1014,7 @@ pub fn is_verbose_than(&self, level: usize) -> bool {
|
||||
/// Prints a message if this build is configured in more verbose mode than `level`.
|
||||
fn verbose_than(&self, level: usize, msg: &str) {
|
||||
if self.is_verbose_than(level) {
|
||||
println!("{}", msg);
|
||||
println!("{msg}");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1022,7 +1022,7 @@ fn info(&self, msg: &str) {
|
||||
match self.config.dry_run {
|
||||
DryRun::SelfCheck => return,
|
||||
DryRun::Disabled | DryRun::UserSelected => {
|
||||
println!("{}", msg);
|
||||
println!("{msg}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1147,7 +1147,7 @@ fn debuginfo_map_to(&self, which: GitRepo) -> Option<String> {
|
||||
match which {
|
||||
GitRepo::Rustc => {
|
||||
let sha = self.rust_sha().unwrap_or(&self.version);
|
||||
Some(format!("/rustc/{}", sha))
|
||||
Some(format!("/rustc/{sha}"))
|
||||
}
|
||||
GitRepo::Llvm => Some(String::from("/rustc/llvm")),
|
||||
}
|
||||
@ -1200,10 +1200,10 @@ fn cflags(&self, target: TargetSelection, which: GitRepo, c: CLang) -> Vec<Strin
|
||||
let map = format!("{}={}", self.src.display(), map_to);
|
||||
let cc = self.cc(target);
|
||||
if cc.ends_with("clang") || cc.ends_with("gcc") {
|
||||
base.push(format!("-fdebug-prefix-map={}", map));
|
||||
base.push(format!("-fdebug-prefix-map={map}"));
|
||||
} else if cc.ends_with("clang-cl.exe") {
|
||||
base.push("-Xclang".into());
|
||||
base.push(format!("-fdebug-prefix-map={}", map));
|
||||
base.push(format!("-fdebug-prefix-map={map}"));
|
||||
}
|
||||
}
|
||||
base
|
||||
@ -1232,9 +1232,7 @@ fn cxx(&self, target: TargetSelection) -> Result<PathBuf, String> {
|
||||
}
|
||||
match self.cxx.borrow().get(&target) {
|
||||
Some(p) => Ok(p.path().into()),
|
||||
None => {
|
||||
Err(format!("target `{}` is not configured as a host, only as a target", target))
|
||||
}
|
||||
None => Err(format!("target `{target}` is not configured as a host, only as a target")),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1277,7 +1275,7 @@ fn lld_flags(&self, target: TargetSelection) -> impl Iterator<Item = String> {
|
||||
}
|
||||
|
||||
let no_threads = util::lld_flag_no_threads(target.contains("windows"));
|
||||
options[1] = Some(format!("-Clink-arg=-Wl,{}", no_threads));
|
||||
options[1] = Some(format!("-Clink-arg=-Wl,{no_threads}"));
|
||||
}
|
||||
|
||||
IntoIterator::into_iter(options).flatten()
|
||||
@ -1404,11 +1402,11 @@ fn release(&self, num: &str) -> String {
|
||||
if !self.config.omit_git_hash {
|
||||
format!("{}-beta.{}", num, self.beta_prerelease_version())
|
||||
} else {
|
||||
format!("{}-beta", num)
|
||||
format!("{num}-beta")
|
||||
}
|
||||
}
|
||||
"nightly" => format!("{}-nightly", num),
|
||||
_ => format!("{}-dev", num),
|
||||
"nightly" => format!("{num}-nightly"),
|
||||
_ => format!("{num}-dev"),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1456,7 +1454,7 @@ fn package_vers(&self, num: &str) -> String {
|
||||
"stable" => num.to_string(),
|
||||
"beta" => "beta".to_string(),
|
||||
"nightly" => "nightly".to_string(),
|
||||
_ => format!("{}-dev", num),
|
||||
_ => format!("{num}-dev"),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1487,7 +1485,7 @@ fn rust_sha(&self) -> Option<&str> {
|
||||
|
||||
/// Returns the `a.b.c` version that the given package is at.
|
||||
fn release_num(&self, package: &str) -> String {
|
||||
let toml_file_name = self.src.join(&format!("src/tools/{}/Cargo.toml", package));
|
||||
let toml_file_name = self.src.join(&format!("src/tools/{package}/Cargo.toml"));
|
||||
let toml = t!(fs::read_to_string(&toml_file_name));
|
||||
for line in toml.lines() {
|
||||
if let Some(stripped) =
|
||||
@ -1497,7 +1495,7 @@ fn release_num(&self, package: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
panic!("failed to find version in {}'s Cargo.toml", package)
|
||||
panic!("failed to find version in {package}'s Cargo.toml")
|
||||
}
|
||||
|
||||
/// Returns `true` if unstable features should be enabled for the compiler
|
||||
@ -1589,7 +1587,7 @@ fn copy_internal(&self, src: &Path, dst: &Path, dereference_symlinks: bool) {
|
||||
if self.config.dry_run() {
|
||||
return;
|
||||
}
|
||||
self.verbose_than(1, &format!("Copy {:?} to {:?}", src, dst));
|
||||
self.verbose_than(1, &format!("Copy {src:?} to {dst:?}"));
|
||||
if src == dst {
|
||||
return;
|
||||
}
|
||||
@ -1680,7 +1678,7 @@ fn install(&self, src: &Path, dstdir: &Path, perms: u32) {
|
||||
return;
|
||||
}
|
||||
let dst = dstdir.join(src.file_name().unwrap());
|
||||
self.verbose_than(1, &format!("Install {:?} to {:?}", src, dst));
|
||||
self.verbose_than(1, &format!("Install {src:?} to {dst:?}"));
|
||||
t!(fs::create_dir_all(dstdir));
|
||||
if !src.exists() {
|
||||
panic!("Error: File \"{}\" not found!", src.display());
|
||||
@ -1714,7 +1712,7 @@ fn read_dir(&self, dir: &Path) -> impl Iterator<Item = fs::DirEntry> {
|
||||
let iter = match fs::read_dir(dir) {
|
||||
Ok(v) => v,
|
||||
Err(_) if self.config.dry_run() => return vec![].into_iter(),
|
||||
Err(err) => panic!("could not read dir {:?}: {:?}", dir, err),
|
||||
Err(err) => panic!("could not read dir {dir:?}: {err:?}"),
|
||||
};
|
||||
iter.map(|e| t!(e)).collect::<Vec<_>>().into_iter()
|
||||
}
|
||||
|
||||
@ -500,8 +500,8 @@ fn run(self, builder: &Builder<'_>) -> LlvmResult {
|
||||
let version = output(cmd.arg("--version"));
|
||||
let major = version.split('.').next().unwrap();
|
||||
let lib_name = match llvm_version_suffix {
|
||||
Some(s) => format!("libLLVM-{}{}.dylib", major, s),
|
||||
None => format!("libLLVM-{}.dylib", major),
|
||||
Some(s) => format!("libLLVM-{major}{s}.dylib"),
|
||||
None => format!("libLLVM-{major}.dylib"),
|
||||
};
|
||||
|
||||
let lib_llvm = out_dir.join("build").join("lib").join(lib_name);
|
||||
@ -529,7 +529,7 @@ fn check_llvm_version(builder: &Builder<'_>, llvm_config: &Path) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
panic!("\n\nbad LLVM version: {}, need >=15.0\n\n", version)
|
||||
panic!("\n\nbad LLVM version: {version}, need >=15.0\n\n")
|
||||
}
|
||||
|
||||
fn configure_cmake(
|
||||
@ -686,10 +686,10 @@ fn configure_cmake(
|
||||
}
|
||||
}
|
||||
if builder.config.llvm_clang_cl.is_some() {
|
||||
cflags.push(&format!(" --target={}", target));
|
||||
cflags.push(&format!(" --target={target}"));
|
||||
}
|
||||
for flag in extra_compiler_flags {
|
||||
cflags.push(&format!(" {}", flag));
|
||||
cflags.push(&format!(" {flag}"));
|
||||
}
|
||||
cfg.define("CMAKE_C_FLAGS", cflags);
|
||||
let mut cxxflags: OsString = builder.cflags(target, GitRepo::Llvm, CLang::Cxx).join(" ").into();
|
||||
@ -698,10 +698,10 @@ fn configure_cmake(
|
||||
cxxflags.push(s);
|
||||
}
|
||||
if builder.config.llvm_clang_cl.is_some() {
|
||||
cxxflags.push(&format!(" --target={}", target));
|
||||
cxxflags.push(&format!(" --target={target}"));
|
||||
}
|
||||
for flag in extra_compiler_flags {
|
||||
cxxflags.push(&format!(" {}", flag));
|
||||
cxxflags.push(&format!(" {flag}"));
|
||||
}
|
||||
cfg.define("CMAKE_CXX_FLAGS", cxxflags);
|
||||
if let Some(ar) = builder.ar(target) {
|
||||
@ -772,7 +772,7 @@ fn configure_llvm(builder: &Builder<'_>, target: TargetSelection, cfg: &mut cmak
|
||||
fn get_var(var_base: &str, host: &str, target: &str) -> Option<OsString> {
|
||||
let kind = if host == target { "HOST" } else { "TARGET" };
|
||||
let target_u = target.replace("-", "_");
|
||||
env::var_os(&format!("{}_{}", var_base, target))
|
||||
env::var_os(&format!("{var_base}_{target}"))
|
||||
.or_else(|| env::var_os(&format!("{}_{}", var_base, target_u)))
|
||||
.or_else(|| env::var_os(&format!("{}_{}", kind, var_base)))
|
||||
.or_else(|| env::var_os(var_base))
|
||||
|
||||
@ -188,7 +188,7 @@ pub fn check(build: &mut Build) {
|
||||
// Externally configured LLVM requires FileCheck to exist
|
||||
let filecheck = build.llvm_filecheck(build.build);
|
||||
if !filecheck.starts_with(&build.out) && !filecheck.exists() && build.config.codegen_tests {
|
||||
panic!("FileCheck executable {:?} does not exist", filecheck);
|
||||
panic!("FileCheck executable {filecheck:?} does not exist");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -92,7 +92,7 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
Ok(Profile::Tools)
|
||||
}
|
||||
"none" => Ok(Profile::None),
|
||||
_ => Err(format!("unknown profile: '{}'", s)),
|
||||
_ => Err(format!("unknown profile: '{s}'")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -167,7 +167,7 @@ pub fn setup(config: &Config, profile: Profile) {
|
||||
|
||||
println!("To get started, try one of the following commands:");
|
||||
for cmd in suggestions {
|
||||
println!("- `x.py {}`", cmd);
|
||||
println!("- `x.py {cmd}`");
|
||||
}
|
||||
|
||||
if profile != Profile::Dist {
|
||||
@ -208,9 +208,8 @@ fn setup_config_toml(path: &PathBuf, profile: Profile, config: &Config) {
|
||||
|
||||
let settings = format!(
|
||||
"# Includes one of the default files in src/bootstrap/defaults\n\
|
||||
profile = \"{}\"\n\
|
||||
changelog-seen = {}\n",
|
||||
profile, VERSION
|
||||
profile = \"{profile}\"\n\
|
||||
changelog-seen = {VERSION}\n"
|
||||
);
|
||||
|
||||
t!(fs::write(path, settings));
|
||||
@ -341,7 +340,7 @@ fn ensure_stage1_toolchain_placeholder_exists(stage_path: &str) -> bool {
|
||||
return false;
|
||||
};
|
||||
|
||||
let pathbuf = pathbuf.join(format!("rustc{}", EXE_SUFFIX));
|
||||
let pathbuf = pathbuf.join(format!("rustc{EXE_SUFFIX}"));
|
||||
|
||||
if pathbuf.exists() {
|
||||
return true;
|
||||
@ -394,7 +393,7 @@ fn parse_with_abbrev(input: &str) -> Result<Profile, String> {
|
||||
break match parse_with_abbrev(&input) {
|
||||
Ok(profile) => profile,
|
||||
Err(err) => {
|
||||
eprintln!("error: {}", err);
|
||||
eprintln!("error: {err}");
|
||||
eprintln!("note: press Ctrl+C to exit");
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -309,7 +309,7 @@ fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> GeneratedTar
|
||||
let mut cmd = self.builder.tool_cmd(crate::tool::Tool::RustInstaller);
|
||||
|
||||
let package_name = self.package_name();
|
||||
self.builder.info(&format!("Dist {}", package_name));
|
||||
self.builder.info(&format!("Dist {package_name}"));
|
||||
let _time = crate::util::timeit(self.builder);
|
||||
|
||||
build_cli(&self, &mut cmd);
|
||||
@ -344,7 +344,7 @@ fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> GeneratedTar
|
||||
.unwrap_or("gz");
|
||||
|
||||
GeneratedTarball {
|
||||
path: crate::dist::distdir(self.builder).join(format!("{}.tar.{}", package_name, ext)),
|
||||
path: crate::dist::distdir(self.builder).join(format!("{package_name}.tar.{ext}")),
|
||||
decompressed_output,
|
||||
work: self.temp_dir,
|
||||
}
|
||||
|
||||
@ -126,7 +126,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
);
|
||||
}
|
||||
|
||||
builder.info(&format!("Linkcheck ({})", host));
|
||||
builder.info(&format!("Linkcheck ({host})"));
|
||||
|
||||
// Test the linkchecker itself.
|
||||
let bootstrap_host = builder.config.build;
|
||||
@ -557,7 +557,7 @@ pub fn build_miri_sysroot(
|
||||
if builder.config.dry_run() {
|
||||
String::new()
|
||||
} else {
|
||||
builder.verbose(&format!("running: {:?}", cargo));
|
||||
builder.verbose(&format!("running: {cargo:?}"));
|
||||
let out =
|
||||
cargo.output().expect("We already ran `cargo miri setup` before and that worked");
|
||||
assert!(out.status.success(), "`cargo miri setup` returned with non-0 exit code");
|
||||
@ -565,7 +565,7 @@ pub fn build_miri_sysroot(
|
||||
let stdout = String::from_utf8(out.stdout)
|
||||
.expect("`cargo miri setup` stdout is not valid UTF-8");
|
||||
let sysroot = stdout.trim_end();
|
||||
builder.verbose(&format!("`cargo miri setup --print-sysroot` said: {:?}", sysroot));
|
||||
builder.verbose(&format!("`cargo miri setup --print-sysroot` said: {sysroot:?}"));
|
||||
sysroot.to_owned()
|
||||
}
|
||||
}
|
||||
@ -2580,7 +2580,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
|
||||
builder.ensure(compile::Std::new(compiler, target));
|
||||
|
||||
builder.info(&format!("REMOTE copy libs to emulator ({})", target));
|
||||
builder.info(&format!("REMOTE copy libs to emulator ({target})"));
|
||||
|
||||
let server = builder.ensure(tool::RemoteTestServer { compiler, target });
|
||||
|
||||
|
||||
@ -83,13 +83,13 @@ fn days_since_beta_promotion() -> u64 {
|
||||
|
||||
fn print_error(tool: &str, submodule: &str) {
|
||||
eprintln!();
|
||||
eprintln!("We detected that this PR updated '{}', but its tests failed.", tool);
|
||||
eprintln!("We detected that this PR updated '{tool}', but its tests failed.");
|
||||
eprintln!();
|
||||
eprintln!("If you do intend to update '{}', please check the error messages above and", tool);
|
||||
eprintln!("If you do intend to update '{tool}', please check the error messages above and");
|
||||
eprintln!("commit another update.");
|
||||
eprintln!();
|
||||
eprintln!("If you do NOT intend to update '{}', please ensure you did not accidentally", tool);
|
||||
eprintln!("change the submodule at '{}'. You may ask your reviewer for the", submodule);
|
||||
eprintln!("If you do NOT intend to update '{tool}', please ensure you did not accidentally");
|
||||
eprintln!("change the submodule at '{submodule}'. You may ask your reviewer for the");
|
||||
eprintln!("proper steps.");
|
||||
crate::exit!(3);
|
||||
}
|
||||
@ -105,7 +105,7 @@ fn check_changed_files(toolstates: &HashMap<Box<str>, ToolState>) {
|
||||
let output = match output {
|
||||
Ok(o) => o,
|
||||
Err(e) => {
|
||||
eprintln!("Failed to get changed files: {:?}", e);
|
||||
eprintln!("Failed to get changed files: {e:?}");
|
||||
crate::exit!(1);
|
||||
}
|
||||
};
|
||||
@ -114,12 +114,12 @@ fn check_changed_files(toolstates: &HashMap<Box<str>, ToolState>) {
|
||||
|
||||
for (tool, submodule) in STABLE_TOOLS.iter().chain(NIGHTLY_TOOLS.iter()) {
|
||||
let changed = output.lines().any(|l| l.starts_with('M') && l.ends_with(submodule));
|
||||
eprintln!("Verifying status of {}...", tool);
|
||||
eprintln!("Verifying status of {tool}...");
|
||||
if !changed {
|
||||
continue;
|
||||
}
|
||||
|
||||
eprintln!("This PR updated '{}', verifying if status is 'test-pass'...", submodule);
|
||||
eprintln!("This PR updated '{submodule}', verifying if status is 'test-pass'...");
|
||||
if toolstates[*tool] != ToolState::TestPass {
|
||||
print_error(tool, submodule);
|
||||
}
|
||||
@ -172,7 +172,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
for (tool, _) in STABLE_TOOLS.iter().chain(NIGHTLY_TOOLS.iter()) {
|
||||
if !toolstates.contains_key(*tool) {
|
||||
did_error = true;
|
||||
eprintln!("error: Tool `{}` was not recorded in tool state.", tool);
|
||||
eprintln!("error: Tool `{tool}` was not recorded in tool state.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -190,7 +190,7 @@ fn run(self, builder: &Builder<'_>) {
|
||||
if state != ToolState::TestPass {
|
||||
if !is_nightly {
|
||||
did_error = true;
|
||||
eprintln!("error: Tool `{}` should be test-pass but is {}", tool, state);
|
||||
eprintln!("error: Tool `{tool}` should be test-pass but is {state}");
|
||||
} else if in_beta_week {
|
||||
let old_state = old_toolstate
|
||||
.iter()
|
||||
@ -200,17 +200,15 @@ fn run(self, builder: &Builder<'_>) {
|
||||
if state < old_state {
|
||||
did_error = true;
|
||||
eprintln!(
|
||||
"error: Tool `{}` has regressed from {} to {} during beta week.",
|
||||
tool, old_state, state
|
||||
"error: Tool `{tool}` has regressed from {old_state} to {state} during beta week."
|
||||
);
|
||||
} else {
|
||||
// This warning only appears in the logs, which most
|
||||
// people won't read. It's mostly here for testing and
|
||||
// debugging.
|
||||
eprintln!(
|
||||
"warning: Tool `{}` is not test-pass (is `{}`), \
|
||||
this should be fixed before beta is branched.",
|
||||
tool, state
|
||||
"warning: Tool `{tool}` is not test-pass (is `{state}`), \
|
||||
this should be fixed before beta is branched."
|
||||
);
|
||||
}
|
||||
}
|
||||
@ -323,7 +321,7 @@ fn checkout_toolstate_repo() {
|
||||
Err(_) => false,
|
||||
};
|
||||
if !success {
|
||||
panic!("git clone unsuccessful (status: {:?})", status);
|
||||
panic!("git clone unsuccessful (status: {status:?})");
|
||||
}
|
||||
}
|
||||
|
||||
@ -336,7 +334,7 @@ fn git_config(key: &str, value: &str) {
|
||||
Err(_) => false,
|
||||
};
|
||||
if !success {
|
||||
panic!("git config key={} value={} failed (status: {:?})", key, value, status);
|
||||
panic!("git config key={key} value={value} failed (status: {status:?})");
|
||||
}
|
||||
}
|
||||
|
||||
@ -346,7 +344,7 @@ fn git_config(key: &str, value: &str) {
|
||||
git_config("user.name", "Rust Toolstate Update");
|
||||
git_config("credential.helper", "store");
|
||||
|
||||
let credential = format!("https://{}:x-oauth-basic@github.com\n", token,);
|
||||
let credential = format!("https://{token}:x-oauth-basic@github.com\n",);
|
||||
let git_credential_path = PathBuf::from(t!(env::var("HOME"))).join(".git-credentials");
|
||||
t!(fs::write(&git_credential_path, credential));
|
||||
}
|
||||
|
||||
@ -46,9 +46,9 @@ macro_rules! t {
|
||||
/// executable for a particular target.
|
||||
pub fn exe(name: &str, target: TargetSelection) -> String {
|
||||
if target.contains("windows") {
|
||||
format!("{}.exe", name)
|
||||
format!("{name}.exe")
|
||||
} else if target.contains("uefi") {
|
||||
format!("{}.efi", name)
|
||||
format!("{name}.efi")
|
||||
} else {
|
||||
name.to_string()
|
||||
}
|
||||
@ -161,9 +161,8 @@ pub fn forcing_clang_based_tests() -> bool {
|
||||
other => {
|
||||
// Let's make sure typos don't go unnoticed
|
||||
panic!(
|
||||
"Unrecognized option '{}' set in \
|
||||
RUSTBUILD_FORCE_CLANG_BASED_TESTS",
|
||||
other
|
||||
"Unrecognized option '{other}' set in \
|
||||
RUSTBUILD_FORCE_CLANG_BASED_TESTS"
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -227,15 +226,14 @@ pub fn check_run(cmd: &mut Command, print_cmd_on_fail: bool) -> bool {
|
||||
let status = match cmd.status() {
|
||||
Ok(status) => status,
|
||||
Err(e) => {
|
||||
println!("failed to execute command: {:?}\nerror: {}", cmd, e);
|
||||
println!("failed to execute command: {cmd:?}\nerror: {e}");
|
||||
return false;
|
||||
}
|
||||
};
|
||||
if !status.success() && print_cmd_on_fail {
|
||||
println!(
|
||||
"\n\ncommand did not execute successfully: {:?}\n\
|
||||
expected success, got: {}\n\n",
|
||||
cmd, status
|
||||
"\n\ncommand did not execute successfully: {cmd:?}\n\
|
||||
expected success, got: {status}\n\n"
|
||||
);
|
||||
}
|
||||
status.success()
|
||||
@ -250,7 +248,7 @@ pub fn run_suppressed(cmd: &mut Command) {
|
||||
pub fn try_run_suppressed(cmd: &mut Command) -> bool {
|
||||
let output = match cmd.output() {
|
||||
Ok(status) => status,
|
||||
Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}", cmd, e)),
|
||||
Err(e) => fail(&format!("failed to execute command: {cmd:?}\nerror: {e}")),
|
||||
};
|
||||
if !output.status.success() {
|
||||
println!(
|
||||
@ -283,7 +281,7 @@ pub fn make(host: &str) -> PathBuf {
|
||||
pub fn output(cmd: &mut Command) -> String {
|
||||
let output = match cmd.stderr(Stdio::inherit()).output() {
|
||||
Ok(status) => status,
|
||||
Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}", cmd, e)),
|
||||
Err(e) => fail(&format!("failed to execute command: {cmd:?}\nerror: {e}")),
|
||||
};
|
||||
if !output.status.success() {
|
||||
panic!(
|
||||
@ -298,7 +296,7 @@ pub fn output(cmd: &mut Command) -> String {
|
||||
pub fn output_result(cmd: &mut Command) -> Result<String, String> {
|
||||
let output = match cmd.stderr(Stdio::inherit()).output() {
|
||||
Ok(status) => status,
|
||||
Err(e) => return Err(format!("failed to run command: {:?}: {}", cmd, e)),
|
||||
Err(e) => return Err(format!("failed to run command: {cmd:?}: {e}")),
|
||||
};
|
||||
if !output.status.success() {
|
||||
return Err(format!(
|
||||
@ -328,7 +326,7 @@ pub fn up_to_date(src: &Path, dst: &Path) -> bool {
|
||||
let threshold = mtime(dst);
|
||||
let meta = match fs::metadata(src) {
|
||||
Ok(meta) => meta,
|
||||
Err(e) => panic!("source {:?} failed to get metadata: {}", src, e),
|
||||
Err(e) => panic!("source {src:?} failed to get metadata: {e}"),
|
||||
};
|
||||
if meta.is_dir() {
|
||||
dir_up_to_date(src, threshold)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user