fix clippy warnings reported from rules that were newly enabled in Rust 1.88

Author: rhysd

assets/builder/src/main.rs

@@ -37,19 +37,19 @@ const THEME_PATHS: &[&str] = &[
 const THEME_BIN_PATH: &str = "../themes.bin";
 
 fn main() {
-    println!("Building theme set for syntect-printer: {}", THEME_BIN_PATH);
+    println!("Building theme set for syntect-printer: {THEME_BIN_PATH}");
 
     let mut set = ThemeSet::new();
 
     for path in THEME_PATHS {
         let path = PathBuf::from_slash(path);
-        println!("Loading theme from {:?}", path);
+        println!("Loading theme from {path:?}");
 
         let name = path.file_stem().and_then(OsStr::to_str).expect("File stem was not found in .tmTheme file. Did you specify incorrect file in THEME_PATHS?");
         let theme = ThemeSet::get_theme(&path).expect("Theme file was not found. Did you forget fetching submodules in ./submodules directory?");
         set.themes.insert(name.to_string(), theme);
 
-        println!("Loaded theme from {:?}", path);
+        println!("Loaded theme from {path:?}");
     }
 
     println!("Compressing theme set");
@@ -68,5 +68,5 @@ fn main() {
     fs::write(PathBuf::from_slash(THEME_BIN_PATH), &buf)
         .expect("Could not write compressed theme set");
 
-    println!("Built successfully: {}", THEME_BIN_PATH);
+    println!("Built successfully: {THEME_BIN_PATH}");
 }

bench/benches/chunk.rs

@@ -17,7 +17,7 @@ fn prepare() -> Vec<u8> {
             if line.ends_with('*') {
                 let l = idx + 1;
                 let s = path.as_os_str().to_str().unwrap();
-                buf += &format!("{}:{}: {}\n", s, l, line);
+                buf += &format!("{s}:{l}: {line}\n");
             }
         }
     }

src/bat.rs

@@ -99,7 +99,7 @@ impl<'main> BatPrinter<'main> {
         let mut themes: Vec<_> = self.assets.themes().collect();
         themes.sort_unstable();
         for theme in themes.into_iter() {
-            println!("\x1b[1m{:?}\x1b[0m", theme);
+            println!("\x1b[1m{theme:?}\x1b[0m");
             self.config.theme = theme.to_string();
             self.print(sample.clone())?;
             println!();

src/broken_pipe.rs

@@ -43,7 +43,7 @@ mod tests {
 
     #[test]
     fn test_io_do_not_ignore_other_errors() {
-        let err = Error::new(io::ErrorKind::Other, "oops");
+        let err = Error::other("oops");
         let res = io::Result::<i32>::Err(err);
         let res = res.ignore_broken_pipe();
         res.unwrap_err();
@@ -66,7 +66,7 @@ mod tests {
 
     #[test]
     fn test_anyhow_do_not_ignore_other_io_error() {
-        let err = Error::new(io::ErrorKind::Other, "oops");
+        let err = Error::other("oops");
         let res = anyhow::Result::<i32>::Err(err.into());
         let res = res.ignore_broken_pipe();
         res.unwrap_err();

src/chunk.rs

@@ -220,7 +220,7 @@ impl<I: Iterator<Item = Result<GrepMatch>>> Files<I> {
 
         for (line, lnum) in lines {
             last_lnum = Some(lnum);
-            assert!(lnum <= after_end, "line {} > chunk {}", lnum, after_end);
+            assert!(lnum <= after_end, "line {lnum} > chunk {after_end}");
 
             let in_before = before_start <= lnum && lnum < before_end;
             let in_after = after_start < lnum && lnum <= after_end;
@@ -279,7 +279,7 @@ impl<I: Iterator<Item = Result<GrepMatch>>> Iterator for Files<I> {
             Err(e) => return self.error_item(e),
         };
         let contents = match fs::read(&path)
-            .with_context(|| format!("Could not open the matched file {:?}", path))
+            .with_context(|| format!("Could not open the matched file {path:?}"))
         {
             Ok(vec) => decode_text(vec, self.encoding),
             Err(err) => return self.error_item(err),
@@ -535,7 +535,7 @@ mod tests {
                 .unwrap()
                 .collect::<Result<Vec<_>>>()
                 .unwrap_err();
-            assert_eq!(format!("{}", err), "dummy error!");
+            assert_eq!(format!("{err}"), "dummy error!");
         }
     }
 

src/grep.rs

@@ -182,9 +182,7 @@ fn test_read_error() {
     for (got, expected) in msgs.iter().zip(expected.iter()) {
         assert!(
             got.contains(expected),
-            "expected {:?} is included in {:?}",
-            expected,
-            got
+            "expected {expected:?} is included in {got:?}"
         );
     }
 }

src/main.rs

@@ -781,9 +781,9 @@ fn main() {
         Ok(true) => 0,
         Ok(false) => 1,
         Err(err) => {
-            eprintln!("\x1b[1;91merror:\x1b[0m {}", err);
+            eprintln!("\x1b[1;91merror:\x1b[0m {err}");
             for err in err.chain().skip(1) {
-                eprintln!("  Caused by: {}", err);
+                eprintln!("  Caused by: {err}");
             }
             2
         }
@@ -983,7 +983,7 @@ mod tests {
                 &["--generate-completion-script", "unknown-shell"][..],
             ] {
                 let parsed = command().try_get_matches_from(args);
-                assert!(parsed.is_err(), "args: {:?}", args);
+                assert!(parsed.is_err(), "args: {args:?}");
             }
         }
     }
@@ -1115,7 +1115,7 @@ mod tests {
         for shell in COMPLETION_SHELLS {
             let mut v = vec![];
             generate_completion_script(shell, &mut v);
-            assert!(!v.is_empty(), "shell: {}", shell);
+            assert!(!v.is_empty(), "shell: {shell}");
         }
     }
 
@@ -1190,7 +1190,7 @@ mod tests {
             env::set_var(OPTS_ENV_VAR, "'-i");
 
             let err = Args::new().unwrap_err();
-            let msg = format!("{}", err);
+            let msg = format!("{err}");
             assert!(
                 msg.contains("cannot be parsed as a shell command"),
                 "{msg:?}",
@@ -1208,7 +1208,7 @@ mod tests {
             env::set_var(OPTS_ENV_VAR, OsStr::from_bytes(b"\xc3\x28"));
 
             let err = Args::new().unwrap_err();
-            let msg = format!("{}", err);
+            let msg = format!("{err}");
             assert!(msg.contains("is not a valid UTF-8 sequence"), "{msg:?}");
         }
     }

src/ripgrep.rs

@@ -36,7 +36,7 @@ fn parse_size(input: &str) -> Result<u64> {
 
     let u: u64 = input
         .parse()
-        .with_context(|| format!("Could not parse {:?} as unsigned integer", input))?;
+        .with_context(|| format!("Could not parse {input:?} as unsigned integer"))?;
 
     Ok(u * mag)
 }
@@ -304,11 +304,11 @@ impl<'main> Config<'main> {
         Ok(if self.fixed_strings {
             let mut s = regex_syntax::escape(pat);
             if self.line_regexp {
-                s = format!("^(?:{})$", s);
+                s = format!("^(?:{s})$");
             }
             builder.build(&s)?
         } else if self.line_regexp {
-            builder.build(&format!("^(?:{})$", pat))?
+            builder.build(&format!("^(?:{pat})$"))?
         } else {
             builder.build(pat)?
         })
@@ -339,7 +339,7 @@ impl<'main> Config<'main> {
         }
 
         if self.line_regexp {
-            Ok(builder.build(&format!("^(?:{})$", pat))?)
+            Ok(builder.build(&format!("^(?:{pat})$"))?)
         } else {
             Ok(builder.build(pat)?)
         }
@@ -526,7 +526,7 @@ impl<M: Matcher> Sink for Matches<'_, M> {
                 ranges.push((m.start(), m.end()));
                 true
             })
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?;
+            .map_err(|e| io::Error::other(format!("{e}")))?;
         let mut regions = LineRegions::new(&ranges);
 
         let mut line_number = line_number;
@@ -693,7 +693,7 @@ mod tests {
         for input in inputs.iter() {
             let mut printer = DummyPrinter::default();
             let pat = r"\*$";
-            let file = dir.join(format!("{}.in", input));
+            let file = dir.join(format!("{input}.in"));
             let paths = iter::once(file.as_path());
             let found = grep(&printer, pat, Some(paths), Config::new(3, 6)).unwrap();
             let expected = read_expected_chunks(&dir, input)
@@ -717,7 +717,7 @@ mod tests {
         let pat = r"\*$";
         let paths = inputs
             .iter()
-            .map(|s| dir.join(format!("{}.in", s)).into_os_string())
+            .map(|s| dir.join(format!("{s}.in")).into_os_string())
             .collect::<Vec<_>>();
         let paths = paths.iter().map(AsRef::as_ref);
 
@@ -743,8 +743,8 @@ mod tests {
         let pat = "^this does not match to any line!!!!!!$";
         let found = grep(&printer, pat, Some(paths), Config::new(3, 6)).unwrap();
         let files = printer.0.into_inner().unwrap();
-        assert!(!found, "result: {:?}", files);
-        assert!(files.is_empty(), "result: {:?}", files);
+        assert!(!found, "result: {files:?}");
+        assert!(files.is_empty(), "result: {files:?}");
     }
 
     #[test]
@@ -776,7 +776,7 @@ mod tests {
         let paths = iter::once(path.as_path());
         let pat = ".*";
         let err = grep(ErrorPrinter, pat, Some(paths), Config::new(3, 6)).unwrap_err();
-        let msg = format!("{}", err);
+        let msg = format!("{err}");
         assert_eq!(msg, "dummy error");
     }
 
@@ -789,7 +789,7 @@ mod tests {
 
         let re = Regex::new(r"^\x1b\[1m\w+\x1b\[0m: .+(, .+)*$").unwrap();
         for line in output.lines() {
-            assert!(re.is_match(line), "{:?} did not match to {:?}", line, re);
+            assert!(re.is_match(line), "{line:?} did not match to {re:?}");
         }
     }
 
@@ -803,8 +803,7 @@ mod tests {
             let chunks_line = lines.next().unwrap();
             assert!(
                 chunks_line.starts_with("# chunks: "),
-                "actual={:?}",
-                chunks_line
+                "actual={chunks_line:?}"
             );
             let chunks_line = &chunks_line["# chunks: ".len()..];
             for chunk in chunks_line.split(", ") {
@@ -820,8 +819,7 @@ mod tests {
             let matches_line = lines.next().unwrap();
             assert!(
                 matches_line.starts_with("# lines: "),
-                "actual={:?}",
-                matches_line
+                "actual={matches_line:?}"
             );
             let matches_line = &matches_line["# lines: ".len()..];
             for mat in matches_line.split(", ") {
@@ -849,7 +847,7 @@ mod tests {
         f(&mut config);
 
         let found = grep(&printer, pat, Some(paths), config).unwrap();
-        assert!(found, "file={}", file);
+        assert!(found, "file={file}");
 
         let mut files = printer.0.into_inner().unwrap();
         assert_eq!(files.len(), 1, "file={}", file);
@@ -1027,19 +1025,12 @@ mod tests {
                     ),
                     Err(want) => {
                         let err = err.unwrap_or_else(|| {
-                            panic!(
-                                "wanted error {:?} but no error for {:?} ({})",
-                                want, input, opt
-                            )
+                            panic!("wanted error {want:?} but no error for {input:?} ({opt})")
                         });
-                        let msg = format!("{}", err);
+                        let msg = format!("{err}");
                         assert!(
                             msg.contains(want),
-                            "wanted error {:?} but got {:?} for {:?} ({})",
-                            want,
-                            msg,
-                            input,
-                            opt,
+                            "wanted error {want:?} but got {msg:?} for {input:?} ({opt})",
                         );
                     }
                 }

src/syntect.rs

@@ -70,7 +70,7 @@ fn list_themes_with_syntaxes<W: Write>(
         .try_for_each(|(name, theme)| -> Result<()> {
             let mut drawer = Drawer::new(&mut out, opts, theme, &sample_file.chunks);
             drawer.canvas.set_bold()?;
-            write!(drawer.canvas, "{:?}", name)?;
+            write!(drawer.canvas, "{name:?}")?;
             drawer.canvas.draw_newline()?;
             drawer.canvas.draw_sample()?;
             writeln!(drawer.canvas)?;
@@ -521,7 +521,7 @@ impl<W: Write> Canvas<W> {
 
     fn draw_sample_row(&mut self, colors: &[(&str, Color)]) -> io::Result<()> {
         for (name, color) in colors {
-            write!(self.out, "    {} ", name)?;
+            write!(self.out, "    {name} ")?;
             self.set_bg(*color)?;
             self.out.write_all(b"    \x1b[0m")?;
         }
@@ -675,7 +675,7 @@ impl<'file, W: Write> Drawer<'file, W> {
         let width = num_digits(lnum);
         self.canvas
             .draw_spaces((self.lnum_width - width) as usize)?;
-        write!(self.canvas, " {}", lnum)?;
+        write!(self.canvas, " {lnum}")?;
         if self.grid {
             if matched {
                 self.canvas.set_gutter_color()?;
@@ -795,7 +795,7 @@ impl<'file, W: Write> Drawer<'file, W> {
                         self.draw_text_wrappping(matched, events.current_style, events.in_region)?;
                         width = 0;
                     }
-                    write!(self.canvas, "{}", c)?;
+                    write!(self.canvas, "{c}")?;
                     width += w;
                 }
                 DrawEvent::TokenBoundary(prev_style) => {
@@ -880,7 +880,7 @@ impl<'file, W: Write> Drawer<'file, W> {
         let path = path.as_os_str().to_string_lossy();
         self.canvas.set_default_fg()?;
         self.canvas.set_bold()?;
-        write!(self.canvas, " {}", path)?;
+        write!(self.canvas, " {path}")?;
         if self.canvas.has_background {
             self.canvas
                 .fill_spaces(path.width_cjk() + 1, self.term_width as usize)?;
@@ -1272,8 +1272,8 @@ mod tests {
             if input.starts_with("test_") {
                 input = &input["test_".len()..];
             }
-            let infile = dir.join(format!("{}.rs", input));
-            let outfile = dir.join(format!("{}.out", input));
+            let infile = dir.join(format!("{input}.rs"));
+            let outfile = dir.join(format!("{input}.out"));
             let file = read_chunks(infile);
             run_uitest(file, outfile, f);
         }
@@ -1435,7 +1435,7 @@ mod tests {
             if input.starts_with("test_") {
                 input = &input["test_".len()..];
             }
-            let file = format!("list_themes_{}.out", input);
+            let file = format!("list_themes_{input}.out");
             let expected = Path::new("testdata").join("syntect").join(file);
             let expected = fs::read(expected).unwrap();
 
@@ -1522,7 +1522,7 @@ mod tests {
         let printer =
             SyntectPrinter::with_assets(ASSETS.clone(), ErrorStdout(io::ErrorKind::Other), opts);
         let err = printer.print(file).unwrap_err();
-        assert_eq!(&format!("{}", err), "dummy error!", "message={}", err);
+        assert_eq!(&format!("{err}"), "dummy error!", "message={err}");
     }
 
     #[test]
@@ -1547,8 +1547,8 @@ mod tests {
             Err(e) => e,
             Ok(_) => panic!("error did not occur"),
         };
-        let msg = format!("{}", err);
-        assert!(msg.contains("Unknown theme"), "message={:?}", msg);
+        let msg = format!("{err}");
+        assert!(msg.contains("Unknown theme"), "message={msg:?}");
     }
 
     #[test]
@@ -1626,7 +1626,7 @@ mod tests {
             &ASSETS.syntax_set,
         )
         .unwrap_err();
-        assert_eq!(&format!("{}", err), "dummy error!", "message={}", err);
+        assert_eq!(&format!("{err}"), "dummy error!", "message={err}");
     }
 
     #[test]