Fix Clippy

Author: Kobzol

collector/benchlib/src/benchmark.rs

@@ -58,7 +58,7 @@ impl<'a> BenchmarkGroup<'a> {
             profile_fn: Box::new(move || profile_function(constructor2.as_ref())),
         };
         if self.benchmarks.insert(name, benchmark_fns).is_some() {
-            panic!("Benchmark '{}' was registered twice", name);
+            panic!("Benchmark '{name}' was registered twice");
         }
     }
 

collector/src/bin/collector.rs

@@ -62,7 +62,7 @@ use database::{ArtifactId, ArtifactIdNumber, Commit, CommitType, Connection, Poo
 
 fn n_normal_benchmarks_remaining(n: usize) -> String {
     let suffix = if n == 1 { "" } else { "s" };
-    format!("{} normal benchmark{} remaining", n, suffix)
+    format!("{n} normal benchmark{suffix} remaining")
 }
 
 struct BenchmarkErrors(usize);
@@ -160,7 +160,7 @@ fn generate_diffs(
                         vec![format!("{:?}", scenario)]
                     }
                     Scenario::IncrPatched => (0..benchmark.patches.len())
-                        .map(|i| format!("{:?}{}", scenario, i))
+                        .map(|i| format!("{scenario:?}{i}"))
                         .collect::<Vec<_>>(),
                 }
             }) {
@@ -175,15 +175,15 @@ fn generate_diffs(
                         profiler.postfix()
                     )
                 };
-                let id_diff = format!("{}-{}", id1, id2);
+                let id_diff = format!("{id1}-{id2}");
                 let prefix = profiler.prefix();
                 let left = out_dir.join(filename(prefix, id1));
                 let right = out_dir.join(filename(prefix, id2));
                 let output = out_dir.join(filename(&format!("{prefix}-diff"), &id_diff));
 
                 if let Err(e) = profiler.diff(&left, &right, &output) {
                     errors.incr();
-                    eprintln!("collector error: {:?}", e);
+                    eprintln!("collector error: {e:?}");
                     continue;
                 }
 
@@ -249,7 +249,7 @@ fn main() {
     match main_result() {
         Ok(code) => process::exit(code),
         Err(err) => {
-            eprintln!("collector error: {:?}", err);
+            eprintln!("collector error: {err:?}");
             process::exit(1);
         }
     }
@@ -998,7 +998,7 @@ fn main_result() -> anyhow::Result<i32> {
             println!("processing artifacts");
             let client = reqwest::blocking::Client::new();
             let response: collector::api::next_artifact::Response = client
-                .get(format!("{}/perf/next_artifact", site_url))
+                .get(format!("{site_url}/perf/next_artifact"))
                 .send()?
                 .json()?;
             let next = if let Some(c) = response.artifact {
@@ -1065,7 +1065,7 @@ fn main_result() -> anyhow::Result<i32> {
                         let sysroot = rt
                             .block_on(Sysroot::install(sha.clone(), &host_target_tuple, &backends))
                             .with_context(|| {
-                                format!("failed to install sysroot for {:?}", commit)
+                                format!("failed to install sysroot for {commit:?}")
                             })?;
 
                         let mut benchmarks = get_compile_benchmarks(
@@ -1126,7 +1126,7 @@ fn main_result() -> anyhow::Result<i32> {
                 }
             });
             // We need to send a message to this endpoint even if the collector panics
-            client.post(format!("{}/perf/onpush", site_url)).send()?;
+            client.post(format!("{site_url}/perf/onpush")).send()?;
 
             match res {
                 Ok(res) => res?,
@@ -1366,7 +1366,7 @@ Make sure to modify `{dir}/perf-config.json` if the category/artifact don't matc
 
             if let Some(benchmark_job) = benchmark_job {
                 // TODO; process the job
-                println!("{:?}", benchmark_job);
+                println!("{benchmark_job:?}");
             }
 
             Ok(0)
@@ -1658,7 +1658,7 @@ fn print_binary_stats(
                 .corner_top_right('│'),
         ),
     );
-    println!("{}", table);
+    println!("{table}");
 }
 
 fn get_local_toolchain_for_runtime_benchmarks(
@@ -1929,15 +1929,14 @@ async fn bench_compile(
         let result = measure(&mut processor).await;
         if let Err(s) = result {
             eprintln!(
-                "collector error: Failed to benchmark '{}', recorded: {:#}",
-                benchmark_name, s
+                "collector error: Failed to benchmark '{benchmark_name}', recorded: {s:#}"
             );
             errors.incr();
             tx.conn()
                 .record_error(
                     collector.artifact_row_id,
                     &benchmark_name.0,
-                    &format!("{:?}", s),
+                    &format!("{s:?}"),
                 )
                 .await;
         };

collector/src/bin/rustc-fake.rs

@@ -30,8 +30,7 @@ fn run_with_determinism_env(mut cmd: Command) {
     let status = cmd.status().expect("failed to spawn");
     assert!(
         status.success(),
-        "command did not complete successfully: {:?}",
-        cmd
+        "command did not complete successfully: {cmd:?}"
     );
 }
 
@@ -70,7 +69,7 @@ fn main() {
         .ok()
         .and_then(|v| v.parse::<u32>().ok())
     {
-        args.push(OsString::from(format!("-Zthreads={}", count)));
+        args.push(OsString::from(format!("-Zthreads={count}")));
     }
 
     args.push(OsString::from("-Adeprecated"));
@@ -408,7 +407,7 @@ fn main() {
             }
 
             _ => {
-                panic!("unknown wrapper: {}", wrapper);
+                panic!("unknown wrapper: {wrapper}");
             }
         }
     } else if args.iter().any(|arg| arg == "--skip-this-rustc") {
@@ -421,7 +420,7 @@ fn main() {
                 .iter()
                 .any(|arg| arg == "-vV" || arg == "--print=file-names")
             {
-                eprintln!("{:?} {:?}", tool, args);
+                eprintln!("{tool:?} {args:?}");
                 eprintln!("exiting -- non-wrapped rustc");
                 std::process::exit(1);
             }
@@ -441,7 +440,7 @@ fn process_self_profile_output(prof_out_dir: PathBuf, args: &[OsString]) {
         .and_then(|args| args[1].to_str())
         .expect("rustc to be invoked with crate name");
     println!("!self-profile-dir:{}", prof_out_dir.to_str().unwrap());
-    println!("!self-profile-crate:{}", crate_name);
+    println!("!self-profile-crate:{crate_name}");
 }
 
 #[cfg(windows)]
@@ -456,9 +455,9 @@ fn exec(cmd: &mut Command) -> ! {
 #[cfg(unix)]
 fn exec(cmd: &mut Command) -> ! {
     use std::os::unix::prelude::*;
-    let cmd_d = format!("{:?}", cmd);
+    let cmd_d = format!("{cmd:?}");
     let error = cmd.exec();
-    panic!("failed to exec `{}`: {}", cmd_d, error);
+    panic!("failed to exec `{cmd_d}`: {error}");
 }
 
 #[cfg(unix)]

collector/src/codegen.rs

@@ -203,7 +203,7 @@ fn write_diff<W: Write>(writer: &mut W, use_color: bool, diff: &CodegenDiff) ->
                 style.apply_to(change)
             )?;
         } else {
-            write!(writer, "{}{}", sign, change)?;
+            write!(writer, "{sign}{change}")?;
         }
     }
     writeln!(writer, "-----------------------------")?;
@@ -227,7 +227,7 @@ fn get_codegen(
         }
         CodegenType::LLVM | CodegenType::MIR => {}
     }
-    cmd.arg(format!("{}", function_index));
+    cmd.arg(format!("{function_index}"));
 
     Ok(String::from_utf8(command_output(&mut cmd)?.stdout)?)
 }

collector/src/compile/benchmark/mod.rs

@@ -141,9 +141,9 @@ impl Benchmark {
         let config: BenchmarkConfig = if config_path.exists() {
             serde_json::from_reader(
                 File::open(&config_path)
-                    .with_context(|| format!("failed to open {:?}", config_path))?,
+                    .with_context(|| format!("failed to open {config_path:?}"))?,
             )
-            .with_context(|| format!("failed to parse {:?}", config_path))?
+            .with_context(|| format!("failed to parse {config_path:?}"))?
         } else {
             bail!("missing a perf-config.json file for `{}`", name);
         };
@@ -207,7 +207,7 @@ impl Benchmark {
             .ok()
             .and_then(|v| v.parse::<u32>().ok())
         {
-            cargo_args.push(format!("-j{}", count));
+            cargo_args.push(format!("-j{count}"));
         }
 
         CargoProcess {
@@ -478,7 +478,7 @@ impl Benchmark {
 
                             // An incremental build with some changes (realistic
                             // incremental case).
-                            let scenario_str = format!("IncrPatched{}", i);
+                            let scenario_str = format!("IncrPatched{i}");
                             self.mk_cargo_process(toolchain, cwd, profile, backend, target)
                                 .incremental(true)
                                 .processor(
@@ -734,8 +734,8 @@ mod tests {
 
         for benchmark in benchmarks {
             let dir = benchmark_dir.join(&benchmark.name.0);
-            let cargo_toml = std::fs::read_to_string(&dir.join("Cargo.toml"))
-                .expect(&format!("Cannot read Cargo.toml of {}", benchmark.name));
+            let cargo_toml = std::fs::read_to_string(dir.join("Cargo.toml"))
+                .unwrap_or_else(|_| panic!("Cannot read Cargo.toml of {}", benchmark.name));
             assert!(
                 cargo_toml.contains("[workspace]"),
                 "{} does not contain [workspace] in its Cargo.toml",

collector/src/compile/benchmark/target.rs

@@ -22,7 +22,7 @@ impl FromStr for Target {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(match s.to_ascii_lowercase().as_str() {
             "x86_64-unknown-linux-gnu" => Target::X86_64UnknownLinuxGnu,
-            _ => return Err(format!("{} is not a valid target", s)),
+            _ => return Err(format!("{s} is not a valid target")),
         })
     }
 }

collector/src/compile/execute/bencher.rs

@@ -244,7 +244,7 @@ impl Processor for BenchProcessor<'_> {
                     | DeserializeStatError::XperfError(..)
                     | DeserializeStatError::IOError(..)),
                 ) => {
-                    panic!("process_perf_stat_output failed: {:?}", e);
+                    panic!("process_perf_stat_output failed: {e:?}");
                 }
             }
         })
@@ -320,7 +320,7 @@ impl SelfProfileS3Upload {
                 data.read_to_end(&mut compressed).expect("compressed");
                 std::fs::write(upload.path(), &compressed).expect("write compressed profile data");
 
-                format!("self-profile-{}.mm_profdata.sz", collection)
+                format!("self-profile-{collection}.mm_profdata.sz")
             }
         };
 
@@ -345,7 +345,7 @@ impl SelfProfileS3Upload {
         let start = std::time::Instant::now();
         let status = self.0.wait().expect("waiting for child");
         if !status.success() {
-            panic!("S3 upload failed: {:?}", status);
+            panic!("S3 upload failed: {status:?}");
         }
 
         log::trace!("uploaded to S3, additional wait: {:?}", start.elapsed());

collector/src/compile/execute/etw_parser.rs

@@ -169,7 +169,7 @@ fn parse_events(r: &mut dyn BufRead, headers: Vec<EventHeader>) -> anyhow::Resul
             .columns
             .iter()
             .position(|c| c == name)
-            .unwrap_or_else(|| panic!("failed to find column {}", name))
+            .unwrap_or_else(|| panic!("failed to find column {name}"))
             + 1
     };
 
@@ -222,7 +222,7 @@ fn parse_events(r: &mut dyn BufRead, headers: Vec<EventHeader>) -> anyhow::Resul
 
         let pid = process_name[l_paren + 1..r_paran].trim();
         pid.parse()
-            .unwrap_or_else(|_| panic!("failed to parse '{}' to pid", pid))
+            .unwrap_or_else(|_| panic!("failed to parse '{pid}' to pid"))
     }
 
     let mut buffer = Vec::new();

collector/src/compile/execute/mod.rs

@@ -38,8 +38,8 @@ pub enum PerfTool {
 impl PerfTool {
     fn name(&self) -> String {
         match self {
-            PerfTool::BenchTool(b) => format!("{:?}", b),
-            PerfTool::ProfileTool(p) => format!("{:?}", p),
+            PerfTool::BenchTool(b) => format!("{b:?}"),
+            PerfTool::ProfileTool(p) => format!("{p:?}"),
         }
     }
 
@@ -265,7 +265,7 @@ impl<'a> CargoProcess<'a> {
         }
 
         let out = command_output(&mut pkgid_cmd)
-            .with_context(|| format!("failed to obtain pkgid in '{:?}'", cwd))?
+            .with_context(|| format!("failed to obtain pkgid in '{cwd:?}'"))?
             .stdout;
         let package_id = str::from_utf8(&out).unwrap();
         Ok(package_id.trim().to_string())
@@ -671,8 +671,7 @@ fn process_stat_output(
         }
         if !pct.starts_with("100.") {
             panic!(
-                "measurement of `{}` only active for {}% of the time",
-                name, pct
+                "measurement of `{name}` only active for {pct}% of the time"
             );
         }
         stats.insert(

collector/src/compile/execute/profiler.rs

@@ -173,7 +173,7 @@ impl Processor for ProfileProcessor<'_> {
                         } else if filename_str.ends_with(".mm_profdata") {
                             utils::fs::rename(path, filepath(&zsp_dir, "Zsp.mm_profdata"))?;
                         } else {
-                            panic!("unexpected file {:?}", path);
+                            panic!("unexpected file {path:?}");
                         }
                     }
                     assert!(num_files == 3 || num_files == 1);
@@ -357,7 +357,7 @@ impl Processor for ProfileProcessor<'_> {
                             continue;
                         }
 
-                        writeln!(&mut final_file, "{}", line)?;
+                        writeln!(&mut final_file, "{line}")?;
                     }
                 }
 
@@ -399,10 +399,10 @@ impl Processor for ProfileProcessor<'_> {
                         let cgu_file = filepath(&out_dir, cgu);
                         let mut file = io::BufWriter::new(
                             fs::File::create(&cgu_file)
-                                .with_context(|| format!("{:?}", cgu_file))?,
+                                .with_context(|| format!("{cgu_file:?}"))?,
                         );
                         for (name, linkage) in items {
-                            writeln!(&mut file, "{} {}", name, linkage)?;
+                            writeln!(&mut file, "{name} {linkage}")?;
                         }
                     }
                 }