Apply clippy::uninlined_format_args fix

nyurik · nyurik · commit 9172eb4f80f3 · 2023-07-02T15:17:47.000+02:00
diff --git a/build.rs b/build.rs
@@ -13,15 +13,15 @@ fn build_android() {
     let expansion = match cc::Build::new().file("src/android-api.c").try_expand() {
         Ok(result) => result,
         Err(e) => {
-            println!("failed to run C compiler: {}", e);
+            println!("failed to run C compiler: {e}");
             return;
         }
     };
     let expansion = match std::str::from_utf8(&expansion) {
         Ok(s) => s,
         Err(_) => return,
     };
-    println!("expanded android version detection:\n{}", expansion);
+    println!("expanded android version detection:\n{expansion}");
     let marker = "APIVERSION";
     let i = match expansion.find(marker) {
         Some(i) => i,
diff --git a/crates/cpp_smoke_test/tests/smoke.rs b/crates/cpp_smoke_test/tests/smoke.rs
@@ -49,13 +49,13 @@ fn smoke_test_cpp() {
             .take(2)
             .collect();
 
-        println!("actual names = {:#?}", names);
+        println!("actual names = {names:#?}");
 
         let expected = [
             "void space::templated_trampoline<void (*)()>(void (*)())",
             "cpp_trampoline",
         ];
-        println!("expected names = {:#?}", expected);
+        println!("expected names = {expected:#?}");
 
         assert_eq!(names.len(), expected.len());
         for (actual, expected) in names.iter().zip(expected.iter()) {
diff --git a/examples/raw.rs b/examples/raw.rs
@@ -21,7 +21,7 @@ fn print() {
     let mut cnt = 0;
     backtrace::trace(|frame| {
         let ip = frame.ip();
-        print!("frame #{:<2} - {:#02$x}", cnt, ip as usize, HEX_WIDTH);
+        print!("frame #{cnt:<2} - {:#0HEX_WIDTH$x}", ip as usize);
         cnt += 1;
 
         let mut resolved = false;
@@ -33,13 +33,13 @@ fn print() {
             }
 
             if let Some(name) = symbol.name() {
-                print!(" - {}", name);
+                print!(" - {name}");
             } else {
                 print!(" - <unknown>");
             }
             if let Some(file) = symbol.filename() {
                 if let Some(l) = symbol.lineno() {
-                    print!("\n{:13}{:4$}@ {}:{}", "", "", file.display(), l, HEX_WIDTH);
+                    print!("\n{:13}{:HEX_WIDTH$}@ {}:{l}", "", "", file.display());
                 }
             }
             println!("");
diff --git a/src/print.rs b/src/print.rs
@@ -247,7 +247,7 @@ impl BacktraceFrameFmt<'_, '_, '_> {
         if self.symbol_index == 0 {
             write!(self.fmt.fmt, "{:4}: ", self.fmt.frame_index)?;
             if let PrintFmt::Full = self.fmt.format {
-                write!(self.fmt.fmt, "{:1$?} - ", frame_ip, HEX_WIDTH)?;
+                write!(self.fmt.fmt, "{frame_ip:HEX_WIDTH$?} - ")?;
             }
         } else {
             write!(self.fmt.fmt, "      ")?;
@@ -260,8 +260,8 @@ impl BacktraceFrameFmt<'_, '_, '_> {
         // more information if we're a full backtrace. Here we also handle
         // symbols which don't have a name,
         match (symbol_name, &self.fmt.format) {
-            (Some(name), PrintFmt::Short) => write!(self.fmt.fmt, "{:#}", name)?,
-            (Some(name), PrintFmt::Full) => write!(self.fmt.fmt, "{}", name)?,
+            (Some(name), PrintFmt::Short) => write!(self.fmt.fmt, "{name:#}")?,
+            (Some(name), PrintFmt::Full) => write!(self.fmt.fmt, "{name}")?,
             (None, _) | (_, PrintFmt::__Nonexhaustive) => write!(self.fmt.fmt, "<unknown>")?,
         }
         self.fmt.fmt.write_str("\n")?;
@@ -283,18 +283,18 @@ impl BacktraceFrameFmt<'_, '_, '_> {
         // Filename/line are printed on lines under the symbol name, so print
         // some appropriate whitespace to sort of right-align ourselves.
         if let PrintFmt::Full = self.fmt.format {
-            write!(self.fmt.fmt, "{:1$}", "", HEX_WIDTH)?;
+            write!(self.fmt.fmt, "{:HEX_WIDTH$}", "")?;
         }
         write!(self.fmt.fmt, "             at ")?;
 
         // Delegate to our internal callback to print the filename and then
         // print out the line number.
         (self.fmt.print_path)(self.fmt.fmt, file)?;
-        write!(self.fmt.fmt, ":{}", line)?;
+        write!(self.fmt.fmt, ":{line}")?;
 
         // Add column number, if available.
         if let Some(colno) = colno {
-            write!(self.fmt.fmt, ":{}", colno)?;
+            write!(self.fmt.fmt, ":{colno}")?;
         }
 
         write!(self.fmt.fmt, "\n")?;
@@ -305,7 +305,7 @@ impl BacktraceFrameFmt<'_, '_, '_> {
         // We only care about the first symbol of a frame
         if self.symbol_index == 0 {
             self.fmt.fmt.write_str("{{{bt:")?;
-            write!(self.fmt.fmt, "{}:{:?}", self.fmt.frame_index, frame_ip)?;
+            write!(self.fmt.fmt, "{}:{frame_ip:?}", self.fmt.frame_index)?;
             self.fmt.fmt.write_str("}}}\n")?;
         }
         Ok(())
diff --git a/tests/accuracy/main.rs b/tests/accuracy/main.rs
@@ -94,16 +94,16 @@ fn verify(filelines: &[Pos]) {
     println!("-----------------------------------");
     println!("looking for:");
     for (file, line) in filelines.iter().rev() {
-        println!("\t{}:{}", file, line);
+        println!("\t{file}:{line}");
     }
-    println!("found:\n{:?}", trace);
+    println!("found:\n{trace:?}");
     let mut symbols = trace.frames().iter().flat_map(|frame| frame.symbols());
     let mut iter = filelines.iter().rev();
     while let Some((file, line)) = iter.next() {
         loop {
             let sym = match symbols.next() {
                 Some(sym) => sym,
-                None => panic!("failed to find {}:{}", file, line),
+                None => panic!("{}", "failed to find {file}:{line}"),
             };
             if let Some(filename) = sym.filename() {
                 if let Some(lineno) = sym.lineno() {
diff --git a/tests/skip_inner_frames.rs b/tests/skip_inner_frames.rs
@@ -18,7 +18,7 @@ fn backtrace_new_unresolved_should_start_with_call_site_trace() {
     }
     let mut b = Backtrace::new_unresolved();
     b.resolve();
-    println!("{:?}", b);
+    println!("{b:?}");
 
     assert!(!b.frames().is_empty());
 
@@ -34,7 +34,7 @@ fn backtrace_new_should_start_with_call_site_trace() {
         return;
     }
     let b = Backtrace::new();
-    println!("{:?}", b);
+    println!("{b:?}");
 
     assert!(!b.frames().is_empty());
 
diff --git a/tests/smoke.rs b/tests/smoke.rs
@@ -90,16 +90,16 @@ fn smoke_test_frames() {
         backtrace::resolve_frame(frame, |sym| {
             print!("symbol  ip:{:?} address:{:?} ", frame.ip(), frame.symbol_address());
             if let Some(name) = sym.name() {
-                print!("name:{} ", name);
+                print!("name:{name} ");
             }
             if let Some(file) = sym.filename() {
                 print!("file:{} ", file.display());
             }
             if let Some(lineno) = sym.lineno() {
-                print!("lineno:{} ", lineno);
+                print!("lineno:{lineno} ");
             }
             if let Some(colno) = sym.colno() {
-                print!("colno:{} ", colno);
+                print!("colno:{colno} ");
             }
             println!();
         });
@@ -257,12 +257,12 @@ fn sp_smoke_test() {
 
         if refs.len() < 5 {
             recursive_stack_references(refs);
-            eprintln!("exiting: {}", x);
+            eprintln!("exiting: {x}");
             return;
         }
 
         backtrace::trace(make_trace_closure(refs));
-        eprintln!("exiting: {}", x);
+        eprintln!("exiting: {x}");
     }
 
     // NB: the following `make_*` functions are pulled out of line, rather than
@@ -284,7 +284,7 @@ fn sp_smoke_test() {
                     sym.name()
                         .and_then(|name| name.as_str())
                         .map_or(false, |name| {
-                            eprintln!("name = {}", name);
+                            eprintln!("name = {name}");
                             name.contains("recursive_stack_references")
                         })
             });

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ fn print() {`
`21`	`21`	`let mut cnt = 0;`
`22`	`22`	`backtrace::trace(\|frame\| {`
`23`	`23`	`let ip = frame.ip();`
`24`		`- print!("frame #{:<2} - {:#02$x}", cnt, ip as usize, HEX_WIDTH);`
	`24`	`+ print!("frame #{cnt:<2} - {:#0HEX_WIDTH$x}", ip as usize);`
`25`	`25`	`cnt += 1;`
`26`	`26`
`27`	`27`	`let mut resolved = false;`
`@@ -33,13 +33,13 @@ fn print() {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`if let Some(name) = symbol.name() {`
`36`		`- print!(" - {}", name);`
	`36`	`+ print!(" - {name}");`
`37`	`37`	`} else {`
`38`	`38`	`print!(" - <unknown>");`
`39`	`39`	`}`
`40`	`40`	`if let Some(file) = symbol.filename() {`
`41`	`41`	`if let Some(l) = symbol.lineno() {`
`42`		`- print!("\n{:13}{:4$}@ {}:{}", "", "", file.display(), l, HEX_WIDTH);`
	`42`	`+ print!("\n{:13}{:HEX_WIDTH$}@ {}:{l}", "", "", file.display());`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`println!("");`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ fn backtrace_new_unresolved_should_start_with_call_site_trace() {`
`18`	`18`	`}`
`19`	`19`	`let mut b = Backtrace::new_unresolved();`
`20`	`20`	`b.resolve();`
`21`		`- println!("{:?}", b);`
	`21`	`+ println!("{b:?}");`
`22`	`22`
`23`	`23`	`assert!(!b.frames().is_empty());`
`24`	`24`
`@@ -34,7 +34,7 @@ fn backtrace_new_should_start_with_call_site_trace() {`
`34`	`34`	`return;`
`35`	`35`	`}`
`36`	`36`	`let b = Backtrace::new();`
`37`		`- println!("{:?}", b);`
	`37`	`+ println!("{b:?}");`
`38`	`38`
`39`	`39`	`assert!(!b.frames().is_empty());`
`40`	`40`