Inline format-args

nyurik · nyurik · commit eca7344db427 · 2025-08-24T11:07:06.000-04:00
This makes the code a bit easier to read and smaller.

Some of it was done with this command, and later fixed by hand:

```
 cargo clippy --workspace --allow-dirty --fix --benches --tests --bins -- -A clippy::all -W clippy::uninlined_format_args
 ```
diff --git a/regex-lite/src/hir/parse.rs b/regex-lite/src/hir/parse.rs
@@ -593,8 +593,7 @@ impl<'a> Parser<'a> {
             'u' => 4,
             'U' => 8,
             unk => unreachable!(
-                "invalid start of fixed length hexadecimal number {}",
-                unk
+                "invalid start of fixed length hexadecimal number {unk}"
             ),
         };
         if !self.bump_and_bump_space() {
@@ -720,7 +719,7 @@ impl<'a> Parser<'a> {
             '?' => (0, Some(1)),
             '*' => (0, None),
             '+' => (1, None),
-            unk => unreachable!("unrecognized repetition operator '{}'", unk),
+            unk => unreachable!("unrecognized repetition operator '{unk}'"),
         };
         let mut greedy = true;
         if self.bump() && self.char() == '?' {
@@ -1216,7 +1215,7 @@ impl<'a> Parser<'a> {
             'd' | 'D' => posix_class("digit").unwrap(),
             's' | 'S' => posix_class("space").unwrap(),
             'w' | 'W' => posix_class("word").unwrap(),
-            unk => unreachable!("invalid Perl class \\{}", unk),
+            unk => unreachable!("invalid Perl class \\{unk}"),
         });
         if ch.is_ascii_uppercase() {
             class.negate();
diff --git a/regex-lite/src/nfa.rs b/regex-lite/src/nfa.rs
@@ -136,7 +136,7 @@ impl core::fmt::Debug for NFA {
         writeln!(f, "NFA(")?;
         writeln!(f, "pattern: {}", self.pattern)?;
         for (sid, state) in self.states.iter().enumerate() {
-            writeln!(f, "{:07?}: {:?}", sid, state)?;
+            writeln!(f, "{sid:07?}: {state:?}")?;
         }
         writeln!(f, ")")?;
         Ok(())
@@ -206,14 +206,14 @@ impl core::fmt::Debug for State {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match *self {
             State::Char { target, ch } => {
-                write!(f, "{:?} => {:?}", ch, target)
+                write!(f, "{ch:?} => {target:?}")
             }
             State::Ranges { target, ref ranges } => {
                 for (i, &(start, end)) in ranges.iter().enumerate() {
                     if i > 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{:?}-{:?} => {:?}", start, end, target)?;
+                    write!(f, "{start:?}-{end:?} => {target:?}")?;
                 }
                 Ok(())
             }
@@ -225,18 +225,18 @@ impl core::fmt::Debug for State {
                     if i > 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{:?}", sid)?;
+                    write!(f, "{sid:?}")?;
                 }
                 write!(f, ")")
             }
             State::Goto { target, look: None } => {
-                write!(f, "goto({:?})", target)
+                write!(f, "goto({target:?})")
             }
             State::Goto { target, look: Some(look) } => {
-                write!(f, "{:?} => {:?}", look, target)
+                write!(f, "{look:?} => {target:?}")
             }
             State::Capture { target, slot } => {
-                write!(f, "capture(slot={:?}) => {:?}", slot, target,)
+                write!(f, "capture(slot={slot:?}) => {target:?}")
             }
             State::Fail => write!(f, "FAIL"),
             State::Match => {
diff --git a/regex-lite/src/string.rs b/regex-lite/src/string.rs
@@ -1798,7 +1798,7 @@ impl<'h> Captures<'h> {
             .nfa()
             .static_explicit_captures_len()
             .expect("number of capture groups can vary in a match");
-        assert_eq!(N, len, "asked for {} groups, but must ask for {}", N, len);
+        assert_eq!(N, len, "asked for {N} groups, but must ask for {len}");
         let mut matched = self.iter().flatten();
         let whole_match = matched.next().expect("a match").as_str();
         let group_matches = [0; N].map(|_| {
@@ -1965,7 +1965,7 @@ impl<'h> core::fmt::Debug for Captures<'h> {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                 write!(f, "{}", self.0)?;
                 if let Some(name) = self.1 {
-                    write!(f, "/{:?}", name)?;
+                    write!(f, "/{name:?}")?;
                 }
                 Ok(())
             }
@@ -2013,7 +2013,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {
     fn index(&self, i: usize) -> &str {
         self.get(i)
             .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+            .unwrap_or_else(|| panic!("no group at index '{i}'"))
     }
 }
 
@@ -2039,7 +2039,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
     fn index<'a>(&'a self, name: &'n str) -> &'a str {
         self.name(name)
             .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group named '{}'", name))
+            .unwrap_or_else(|| panic!("no group named '{name}'"))
     }
 }
 
diff --git a/regex-lite/tests/string.rs b/regex-lite/tests/string.rs
@@ -23,8 +23,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
         Ok(hay) => hay,
         Err(err) => {
             return TestResult::fail(&format!(
-                "haystack is not valid UTF-8: {}",
-                err
+                "haystack is not valid UTF-8: {err}",
             ));
         }
     };
@@ -45,7 +44,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
                 .map(|caps| testify_captures(&caps));
             TestResult::captures(it)
         }
-        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+        name => TestResult::fail(&format!("unrecognized test name: {name}")),
     }
 }
 
diff --git a/regex-test/lib.rs b/regex-test/lib.rs
@@ -151,17 +151,17 @@ impl RegexTests {
     /// The given group name is assigned to all loaded tests.
     pub fn load_slice(&mut self, group_name: &str, data: &[u8]) -> Result<()> {
         let data = std::str::from_utf8(&data).with_context(|| {
-            format!("data in {} is not valid UTF-8", group_name)
+            format!("data in {group_name} is not valid UTF-8")
         })?;
         let mut index = 1;
         let mut tests: RegexTests =
             toml::from_str(&data).with_context(|| {
-                format!("error decoding TOML for '{}'", group_name)
+                format!("error decoding TOML for '{group_name}'")
             })?;
         for t in &mut tests.tests {
             t.group = group_name.to_string();
             if t.name.is_empty() {
-                t.name = format!("{}", index);
+                t.name = format!("{index}");
                 index += 1;
             }
             t.full_name = format!("{}/{}", t.group, t.name);
@@ -1101,7 +1101,7 @@ impl RegexTestFailureKind {
         let mut buf = String::new();
         match *self {
             RegexTestFailureKind::UserFailure { ref why } => {
-                write!(buf, "failed by implementor because: {}", why)?;
+                write!(buf, "failed by implementor because: {why}")?;
             }
             RegexTestFailureKind::IsMatch => {
                 if test.is_match() {
@@ -1140,13 +1140,13 @@ impl RegexTestFailureKind {
                 write!(buf, "expected regex to NOT compile, but it did")?;
             }
             RegexTestFailureKind::CompileError { ref err } => {
-                write!(buf, "expected regex to compile, failed: {}", err)?;
+                write!(buf, "expected regex to compile, failed: {err}")?;
             }
             RegexTestFailureKind::UnexpectedPanicCompile(ref msg) => {
-                write!(buf, "got unexpected panic while compiling:\n{}", msg)?;
+                write!(buf, "got unexpected panic while compiling:\n{msg}")?;
             }
             RegexTestFailureKind::UnexpectedPanicSearch(ref msg) => {
-                write!(buf, "got unexpected panic while searching:\n{}", msg)?;
+                write!(buf, "got unexpected panic while searching:\n{msg}")?;
             }
         }
         Ok(buf)
diff --git a/src/error.rs b/src/error.rs
@@ -71,7 +71,7 @@ impl core::fmt::Display for Error {
             Error::Syntax(ref err) => err.fmt(f),
             Error::CompiledTooBig(limit) => write!(
                 f,
-                "Compiled regex exceeds size limit of {limit} bytes."
+                "Compiled regex exceeds size limit of {limit} bytes.",
             ),
         }
     }
diff --git a/src/regex/bytes.rs b/src/regex/bytes.rs
@@ -1992,7 +1992,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {
     fn index<'a>(&'a self, i: usize) -> &'a [u8] {
         self.get(i)
             .map(|m| m.as_bytes())
-            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+            .unwrap_or_else(|| panic!("no group at index '{i}'"))
     }
 }
 
@@ -2018,7 +2018,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
     fn index<'a>(&'a self, name: &'n str) -> &'a [u8] {
         self.name(name)
             .map(|m| m.as_bytes())
-            .unwrap_or_else(|| panic!("no group named '{}'", name))
+            .unwrap_or_else(|| panic!("no group named '{name}'"))
     }
 }
 
diff --git a/src/regex/string.rs b/src/regex/string.rs
@@ -2000,7 +2000,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {
     fn index<'a>(&'a self, i: usize) -> &'a str {
         self.get(i)
             .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+            .unwrap_or_else(|| panic!("no group at index '{i}'"))
     }
 }
 
@@ -2026,7 +2026,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
     fn index<'a>(&'a self, name: &'n str) -> &'a str {
         self.name(name)
             .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group named '{}'", name))
+            .unwrap_or_else(|| panic!("no group named '{name}'"))
     }
 }
 
diff --git a/tests/suite_string.rs b/tests/suite_string.rs
@@ -23,7 +23,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
         Ok(hay) => hay,
         Err(err) => {
             return TestResult::fail(&format!(
-                "haystack is not valid UTF-8: {err}"
+                "haystack is not valid UTF-8: {err}",
             ));
         }
     };
diff --git a/tests/suite_string_set.rs b/tests/suite_string_set.rs
@@ -21,7 +21,7 @@ fn run_test(re: &RegexSet, test: &RegexTest) -> TestResult {
         Ok(hay) => hay,
         Err(err) => {
             return TestResult::fail(&format!(
-                "haystack is not valid UTF-8: {err}"
+                "haystack is not valid UTF-8: {err}",
             ));
         }
     };

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ impl core::fmt::Debug for NFA {`
`136`	`136`	`writeln!(f, "NFA(")?;`
`137`	`137`	`writeln!(f, "pattern: {}", self.pattern)?;`
`138`	`138`	`for (sid, state) in self.states.iter().enumerate() {`
`139`		`- writeln!(f, "{:07?}: {:?}", sid, state)?;`
	`139`	`+ writeln!(f, "{sid:07?}: {state:?}")?;`
`140`	`140`	`}`
`141`	`141`	`writeln!(f, ")")?;`
`142`	`142`	`Ok(())`
`@@ -206,14 +206,14 @@ impl core::fmt::Debug for State {`
`206`	`206`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`207`	`207`	`match *self {`
`208`	`208`	`State::Char { target, ch } => {`
`209`		`- write!(f, "{:?} => {:?}", ch, target)`
	`209`	`+ write!(f, "{ch:?} => {target:?}")`
`210`	`210`	`}`
`211`	`211`	`State::Ranges { target, ref ranges } => {`
`212`	`212`	`for (i, &(start, end)) in ranges.iter().enumerate() {`
`213`	`213`	`if i > 0 {`
`214`	`214`	`write!(f, ", ")?;`
`215`	`215`	`}`
`216`		`- write!(f, "{:?}-{:?} => {:?}", start, end, target)?;`
	`216`	`+ write!(f, "{start:?}-{end:?} => {target:?}")?;`
`217`	`217`	`}`
`218`	`218`	`Ok(())`
`219`	`219`	`}`
`@@ -225,18 +225,18 @@ impl core::fmt::Debug for State {`
`225`	`225`	`if i > 0 {`
`226`	`226`	`write!(f, ", ")?;`
`227`	`227`	`}`
`228`		`- write!(f, "{:?}", sid)?;`
	`228`	`+ write!(f, "{sid:?}")?;`
`229`	`229`	`}`
`230`	`230`	`write!(f, ")")`
`231`	`231`	`}`
`232`	`232`	`State::Goto { target, look: None } => {`
`233`		`- write!(f, "goto({:?})", target)`
	`233`	`+ write!(f, "goto({target:?})")`
`234`	`234`	`}`
`235`	`235`	`State::Goto { target, look: Some(look) } => {`
`236`		`- write!(f, "{:?} => {:?}", look, target)`
	`236`	`+ write!(f, "{look:?} => {target:?}")`
`237`	`237`	`}`
`238`	`238`	`State::Capture { target, slot } => {`
`239`		`- write!(f, "capture(slot={:?}) => {:?}", slot, target,)`
	`239`	`+ write!(f, "capture(slot={slot:?}) => {target:?}")`
`240`	`240`	`}`
`241`	`241`	`State::Fail => write!(f, "FAIL"),`
`242`	`242`	`State::Match => {`
Original file line number	Diff line number	Diff line change
`@@ -1798,7 +1798,7 @@ impl<'h> Captures<'h> {`
`1798`	`1798`	`.nfa()`
`1799`	`1799`	`.static_explicit_captures_len()`
`1800`	`1800`	`.expect("number of capture groups can vary in a match");`
`1801`		`- assert_eq!(N, len, "asked for {} groups, but must ask for {}", N, len);`
	`1801`	`+ assert_eq!(N, len, "asked for {N} groups, but must ask for {len}");`
`1802`	`1802`	`let mut matched = self.iter().flatten();`
`1803`	`1803`	`let whole_match = matched.next().expect("a match").as_str();`
`1804`	`1804`	`let group_matches = [0; N].map(\|_\| {`
`@@ -1965,7 +1965,7 @@ impl<'h> core::fmt::Debug for Captures<'h> {`
`1965`	`1965`	`fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {`
`1966`	`1966`	`write!(f, "{}", self.0)?;`
`1967`	`1967`	`if let Some(name) = self.1 {`
`1968`		`- write!(f, "/{:?}", name)?;`
	`1968`	`+ write!(f, "/{name:?}")?;`
`1969`	`1969`	`}`
`1970`	`1970`	`Ok(())`
`1971`	`1971`	`}`
`@@ -2013,7 +2013,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {`
`2013`	`2013`	`fn index(&self, i: usize) -> &str {`
`2014`	`2014`	`self.get(i)`
`2015`	`2015`	`.map(\|m\| m.as_str())`
`2016`		`- .unwrap_or_else(\|\| panic!("no group at index '{}'", i))`
	`2016`	`+ .unwrap_or_else(\|\| panic!("no group at index '{i}'"))`
`2017`	`2017`	`}`
`2018`	`2018`	`}`
`2019`	`2019`
`@@ -2039,7 +2039,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {`
`2039`	`2039`	`fn index<'a>(&'a self, name: &'n str) -> &'a str {`
`2040`	`2040`	`self.name(name)`
`2041`	`2041`	`.map(\|m\| m.as_str())`
`2042`		`- .unwrap_or_else(\|\| panic!("no group named '{}'", name))`
	`2042`	`+ .unwrap_or_else(\|\| panic!("no group named '{name}'"))`
`2043`	`2043`	`}`
`2044`	`2044`	`}`
`2045`	`2045`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {`
`23`	`23`	`Ok(hay) => hay,`
`24`	`24`	`Err(err) => {`
`25`	`25`	`return TestResult::fail(&format!(`
`26`		`- "haystack is not valid UTF-8: {}",`
`27`		`- err`
	`26`	`+ "haystack is not valid UTF-8: {err}",`
`28`	`27`	`));`
`29`	`28`	`}`
`30`	`29`	`};`
`@@ -45,7 +44,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {`
`45`	`44`	`.map(\|caps\| testify_captures(&caps));`
`46`	`45`	`TestResult::captures(it)`
`47`	`46`	`}`
`48`		`- name => TestResult::fail(&format!("unrecognized test name: {}", name)),`
	`47`	`+ name => TestResult::fail(&format!("unrecognized test name: {name}")),`
`49`	`48`	`}`
`50`	`49`	`}`
`51`	`50`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ impl core::fmt::Display for Error {`
`71`	`71`	`Error::Syntax(ref err) => err.fmt(f),`
`72`	`72`	`Error::CompiledTooBig(limit) => write!(`
`73`	`73`	`f,`
`74`		`- "Compiled regex exceeds size limit of {limit} bytes."`
	`74`	`+ "Compiled regex exceeds size limit of {limit} bytes.",`
`75`	`75`	`),`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1992,7 +1992,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {`
`1992`	`1992`	`fn index<'a>(&'a self, i: usize) -> &'a [u8] {`
`1993`	`1993`	`self.get(i)`
`1994`	`1994`	`.map(\|m\| m.as_bytes())`
`1995`		`- .unwrap_or_else(\|\| panic!("no group at index '{}'", i))`
	`1995`	`+ .unwrap_or_else(\|\| panic!("no group at index '{i}'"))`
`1996`	`1996`	`}`
`1997`	`1997`	`}`
`1998`	`1998`
`@@ -2018,7 +2018,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {`
`2018`	`2018`	`fn index<'a>(&'a self, name: &'n str) -> &'a [u8] {`
`2019`	`2019`	`self.name(name)`
`2020`	`2020`	`.map(\|m\| m.as_bytes())`
`2021`		`- .unwrap_or_else(\|\| panic!("no group named '{}'", name))`
	`2021`	`+ .unwrap_or_else(\|\| panic!("no group named '{name}'"))`
`2022`	`2022`	`}`
`2023`	`2023`	`}`
`2024`	`2024`
Original file line number	Diff line number	Diff line change
`@@ -2000,7 +2000,7 @@ impl<'h> core::ops::Index<usize> for Captures<'h> {`
`2000`	`2000`	`fn index<'a>(&'a self, i: usize) -> &'a str {`
`2001`	`2001`	`self.get(i)`
`2002`	`2002`	`.map(\|m\| m.as_str())`
`2003`		`- .unwrap_or_else(\|\| panic!("no group at index '{}'", i))`
	`2003`	`+ .unwrap_or_else(\|\| panic!("no group at index '{i}'"))`
`2004`	`2004`	`}`
`2005`	`2005`	`}`
`2006`	`2006`
`@@ -2026,7 +2026,7 @@ impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {`
`2026`	`2026`	`fn index<'a>(&'a self, name: &'n str) -> &'a str {`
`2027`	`2027`	`self.name(name)`
`2028`	`2028`	`.map(\|m\| m.as_str())`
`2029`		`- .unwrap_or_else(\|\| panic!("no group named '{}'", name))`
	`2029`	`+ .unwrap_or_else(\|\| panic!("no group named '{name}'"))`
`2030`	`2030`	`}`
`2031`	`2031`	`}`
`2032`	`2032`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ fn run_test(re: &Regex, test: &RegexTest) -> TestResult {`
`23`	`23`	`Ok(hay) => hay,`
`24`	`24`	`Err(err) => {`
`25`	`25`	`return TestResult::fail(&format!(`
`26`		`- "haystack is not valid UTF-8: {err}"`
	`26`	`+ "haystack is not valid UTF-8: {err}",`
`27`	`27`	`));`
`28`	`28`	`}`
`29`	`29`	`};`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ fn run_test(re: &RegexSet, test: &RegexTest) -> TestResult {`
`21`	`21`	`Ok(hay) => hay,`
`22`	`22`	`Err(err) => {`
`23`	`23`	`return TestResult::fail(&format!(`
`24`		`- "haystack is not valid UTF-8: {err}"`
	`24`	`+ "haystack is not valid UTF-8: {err}",`
`25`	`25`	`));`
`26`	`26`	`}`
`27`	`27`	`};`