handle clippy lints

bolero-engine/src/panic.rs

@@ -202,7 +202,7 @@ impl Display for Backtrace {
         for (i, frame) in self.frames.iter().enumerate() {
             writeln!(f, "   {}: {}", i, frame.symbol)?;
             if let Some(location) = frame.location.as_ref() {
-                writeln!(f, "             at {}", location)?;
+                writeln!(f, "             at {location}")?;
             }
         }
 
@@ -223,7 +223,7 @@ impl BacktraceFrame {
             symbol: name,
             location: symbol.filename().map(|filename| {
                 if let Some(lineno) = symbol.lineno() {
-                    format!("{}:{}", filename.display(), lineno)
+                    format!("{}:{lineno}", filename.display())
                 } else {
                     filename.display().to_string()
                 }

bolero-engine/src/rng.rs

@@ -138,14 +138,14 @@ where
                         )
                         .expect("test should fail");
 
-                    eprintln!("{}", failure);
+                    eprintln!("{failure}");
 
                     std::panic::resume_unwind(Box::new(failure));
                 }
                 #[cfg(miri)]
                 Err(failure) => {
                     // don't shrink in Miri execution
-                    eprintln!("{}", failure);
+                    eprintln!("{failure}");
                     std::panic::resume_unwind(Box::new(failure));
                 }
             }

bolero-engine/src/shrink.rs

@@ -263,8 +263,7 @@ impl<'a, T: Test> Shrinker<'a, T> {
         {
             if self.execute().is_ok() {
                 eprintln!(
-                    "transform created non-failing test: {}\nBEFORE: {:?}\nAFTER: {:?}",
-                    transform,
+                    "transform created non-failing test: {transform}\nBEFORE: {:?}\nAFTER: {:?}",
                     &self.snapshot_input,
                     &self.input[..self.end],
                 );

bolero-engine/src/test_failure.rs

@@ -16,14 +16,14 @@ impl<Input: Debug> Display for TestFailure<Input> {
             "\n======================== Test Failure ========================\n"
         )?;
         if let Some(seed) = &self.seed {
-            writeln!(f, "BOLERO_RANDOM_SEED={}\n", seed)?;
+            writeln!(f, "BOLERO_RANDOM_SEED={seed}\n")?;
         }
         writeln!(f, "Input: \n{:#?}\n", self.input)?;
         writeln!(f, "Error: \n{}", self.error)?;
 
         if f.alternate() {
             if let Some(backtrace) = self.error.backtrace.as_ref().filter(|_| rust_backtrace()) {
-                writeln!(f, "{}", backtrace)?;
+                writeln!(f, "{backtrace}")?;
             } else {
                 writeln!(f, "note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.")?;
             }

bolero-generator-derive/src/lib.rs

@@ -307,7 +307,7 @@ fn generate_fields_unnamed_type_mutate(
     fields: &FieldsUnnamed,
 ) -> TokenStream2 {
     let fields = fields.unnamed.iter().enumerate().map(|(index, field)| {
-        let value = Ident::new(&format!("__bolero_unnamed_{}", index), field.span());
+        let value = Ident::new(&format!("__bolero_unnamed_{index}"), field.span());
         let generator = GeneratorAttr::from_attrs(krate, field.attrs.iter());
 
         let span = generator.span();
@@ -334,7 +334,7 @@ fn generate_fields_unnamed_type_destructure<C: ToTokens>(
         .unnamed
         .iter()
         .enumerate()
-        .map(|(index, field)| Ident::new(&format!("__bolero_unnamed_{}", index), field.span()));
+        .map(|(index, field)| Ident::new(&format!("__bolero_unnamed_{index}"), field.span()));
     quote!(#constructor (#(#fields),*))
 }
 

bolero-honggfuzz/build.rs

@@ -27,17 +27,17 @@ fn build(target: &str, file: &str, lib: &str) -> String {
     assert!(status.success());
 
     std::fs::copy(
-        format!("honggfuzz/{}", target),
-        format!("{}/{}", out_dir, file),
+        format!("honggfuzz/{target}"),
+        format!("{out_dir}/{file}"),
     )
     .expect("could not copy target");
 
-    println!("cargo:rustc-link-lib=static={}", lib);
-    println!("cargo:rustc-link-search=native={}", &out_dir);
+    println!("cargo:rustc-link-lib=static={lib}");
+    println!("cargo:rustc-link-search=native={out_dir}");
 
     std::fs::copy(
         "honggfuzz/libhfcommon/libhfcommon.a",
-        format!("{}/libhfcommon.a", out_dir),
+        format!("{out_dir}/libhfcommon.a"),
     )
     .expect("could not copy libhfcommon.a");
 
@@ -82,7 +82,7 @@ fn main() {
             ]
             .iter()
             {
-                println!("cargo:rustc-link-lib=framework={}", framework);
+                println!("cargo:rustc-link-lib=framework={framework}");
             }
         }
 
@@ -96,7 +96,7 @@ fn main() {
             ]
             .iter()
             {
-                println!("cargo:rustc-link-lib={}", lib);
+                println!("cargo:rustc-link-lib={lib}");
             }
         }
     }

bolero-libfuzzer/src/lib.rs

@@ -65,7 +65,7 @@ pub mod fuzzer {
                             test.shrink(slice.to_vec(), None, driver_mode, self.shrink_time);
 
                         if let Some(shrunken) = shrunken {
-                            eprintln!("{:#}", shrunken);
+                            eprintln!("{shrunken:#}");
                         } else {
                             eprintln!(
                                 "{:#}",

bolero/src/test/mod.rs

@@ -77,7 +77,7 @@ impl TestEngine {
                 Some(seed)
             })
             .map(move |seed| NamedTest {
-                name: format!("[BOLERO_RANDOM_SEED={}]", seed),
+                name: format!("[BOLERO_RANDOM_SEED={seed}]"),
                 data: TestInput::RngTest(RngTest {
                     seed,
                     max_len: rng_info.max_len,
@@ -137,7 +137,7 @@ where
                             test.shrink(buffer.clone(), data.seed(), driver_mode, shrink_time);
 
                         if let Some(shrunken) = shrunken {
-                            format!("{:#}", shrunken)
+                            format!("{shrunken:#}")
                         } else {
                             format!(
                                 "{:#}",
@@ -165,7 +165,7 @@ where
                         );
 
                         if let Some(shrunken) = shrunken {
-                            format!("{:#}", shrunken)
+                            format!("{shrunken:#}")
                         } else {
                             buffer.clear();
                             let mut input = conf.input(&mut buffer);
@@ -194,7 +194,7 @@ where
 
             if let Err(err) = testfn(&test.data) {
                 bolero_engine::panic::forward_panic(true);
-                eprintln!("{}", err);
+                eprintln!("{err}");
                 panic!("test failed: {:?}", test.name);
             }
         }

cargo-bolero/src/afl.rs

@@ -35,7 +35,7 @@ pub(crate) fn test(selection: &Selection, test_args: &test::Args) -> Result<()>
     if let Some(runs) = test_args.runs {
         std::env::set_var("AFL_EXIT_WHEN_DONE", "1");
         let cycles = runs / 100_000; // a cycle is about 100,000 runs
-        std::env::set_var("BOLERO_AFL_MAX_CYCLES", format!("{}", cycles));
+        std::env::set_var("BOLERO_AFL_MAX_CYCLES", format!("{cycles}"));
     }
 
     let mut args = vec![

cargo-bolero/src/engine.rs

@@ -64,7 +64,7 @@ impl FromStr for Engine {
             #[cfg(feature = "kani")]
             "kani" => Ok(Self::Kani),
 
-            _ => Err(format!("invalid fuzzer {:?}", value)),
+            _ => Err(format!("invalid fuzzer {value:?}")),
         }
     }
 }

cargo-bolero/src/honggfuzz.rs

@@ -25,7 +25,7 @@ macro_rules! optional_arg {
     ($cmd:ident, $harg:expr, $arg:expr) => {
         if let Some(value) = $arg {
             $cmd.push($harg.to_string());
-            $cmd.push(format!("{}", value));
+            $cmd.push(format!("{value}"));
         }
     };
 }

cargo-bolero/src/list.rs

@@ -26,7 +26,7 @@ impl List {
         // ignore the status in case any tests failed
 
         for target in TestTarget::all_from_stdout(&output.stdout)? {
-            println!("{}", target);
+            println!("{target}");
         }
 
         Ok(())

cargo-bolero/src/main.rs

@@ -52,7 +52,7 @@ fn main() {
 
     if let Err(err) = Commands::from_iter(args).exec() {
         // Formatting anyhow error with {:#} to print all the error causes.
-        eprintln!("error: {:#}", err);
+        eprintln!("error: {err:#}");
         std::process::exit(1);
     }
 }

cargo-bolero/src/new.rs

@@ -85,5 +85,5 @@ fn mkdir<P: AsRef<Path>>(path: P) {
 fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) {
     let path = path.as_ref();
     fs::write(path, contents).expect("could not create file");
-    println!("wrote {:?}", path);
+    println!("wrote {path:?}");
 }

cargo-bolero/src/project.rs

@@ -160,7 +160,7 @@ impl Project {
                     .arg("-vV")
                     .output()
                     .with_context(|| {
-                        format!("failed to determine {} toolchain version", toolchain)
+                        format!("failed to determine {toolchain} toolchain version")
                     })?
                     .stdout;
                 let stdout = core::str::from_utf8(&stdout)?;
@@ -210,7 +210,7 @@ impl Project {
 
     fn sanitizer_flags(&self) -> impl Iterator<Item = String> + '_ {
         self.sanitizers()
-            .map(|sanitizer| format!("-Zsanitizer={}", sanitizer))
+            .map(|sanitizer| format!("-Zsanitizer={sanitizer}"))
     }
 
     fn release(&self) -> bool {

cargo-bolero/src/test_target.rs

@@ -26,7 +26,7 @@ impl TestTarget {
             1 => Ok(targets.pop().unwrap()),
             _ => {
                 for target in targets {
-                    eprintln!("{}", target);
+                    eprintln!("{target}");
                 }
                 Err(anyhow!("multiple targets matched"))
             }