Partially apply rustfmt

LukasKalbertodt · LukasKalbertodt · commit 0971b8fa5963 · 2025-08-01T13:05:59.000+02:00
Some of these are legit improvements or at least improvements in
consistency. Imports in particular I care very little about, so using
rustfmts formatting is useful.
diff --git a/src/bool/mod.rs b/src/bool/mod.rs
@@ -1,6 +1,9 @@
 use std::fmt;
 
-use crate::{ParseError, err::{perr, ParseErrorKind::*}};
+use crate::{
+    err::{perr, ParseErrorKind::*},
+    ParseError,
+};
 
 
 /// A bool literal: `true` or `false`. Also see [the reference][ref].
diff --git a/src/bool/tests.rs b/src/bool/tests.rs
@@ -1,7 +1,4 @@
-use crate::{
-    Literal, BoolLit,
-    test_util::assert_parse_ok_eq,
-};
+use crate::{test_util::assert_parse_ok_eq, BoolLit, Literal};
 
 macro_rules! assert_bool_parse {
     ($input:literal, $expected:expr) => {
diff --git a/src/byte/mod.rs b/src/byte/mod.rs
@@ -1,10 +1,10 @@
 use core::fmt;
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
     escape::unescape,
     parse::check_suffix,
+    Buffer, ParseError,
 };
 
 
@@ -55,7 +55,6 @@ impl<B: Buffer> ByteLit<B> {
     pub fn into_raw_input(self) -> B {
         self.raw
     }
-
 }
 
 impl ByteLit<&str> {
@@ -88,7 +87,7 @@ pub(crate) fn parse_impl(input: &str) -> Result<(u8, usize), ParseError> {
         b'\\' => {
             let (v, len) = unescape(&input[2..], false, true, true).map_err(|e| e.offset_span(2))?;
             (v.unwrap_byte(), len)
-        },
+        }
         other if other.is_ascii() => (*other, 1),
         _ => return Err(perr(2, NonAsciiInByteLiteral)),
     };
diff --git a/src/byte/tests.rs b/src/byte/tests.rs
@@ -1,4 +1,7 @@
-use crate::{ByteLit, Literal, test_util::{assert_parse_ok_eq, assert_roundtrip}};
+use crate::{
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
+    ByteLit, Literal,
+};
 
 // ===== Utility functions =======================================================================
 
diff --git a/src/bytestr/mod.rs b/src/bytestr/mod.rs
@@ -1,9 +1,9 @@
 use std::{fmt, ops::Range};
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
     escape::{scan_raw_string, unescape_string},
+    Buffer, ParseError,
 };
 
 
diff --git a/src/bytestr/tests.rs b/src/bytestr/tests.rs
@@ -1,4 +1,7 @@
-use crate::{Literal, ByteStringLit, test_util::{assert_parse_ok_eq, assert_roundtrip}};
+use crate::{
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
+    ByteStringLit, Literal,
+};
 
 // ===== Utility functions =======================================================================
 
diff --git a/src/char/mod.rs b/src/char/mod.rs
@@ -1,10 +1,10 @@
 use std::fmt;
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
     escape::unescape,
-    parse::{first_byte_or_empty, check_suffix},
+    parse::{check_suffix, first_byte_or_empty},
+    Buffer, ParseError,
 };
 
 
@@ -29,7 +29,7 @@ impl<B: Buffer> CharLit<B> {
             b'\'' => {
                 let (value, start_suffix) = parse_impl(&input)?;
                 Ok(Self { raw: input, value, start_suffix })
-            },
+            }
             _ => Err(perr(0, DoesNotStartWithQuote)),
         }
     }
@@ -53,7 +53,6 @@ impl<B: Buffer> CharLit<B> {
     pub fn into_raw_input(self) -> B {
         self.raw
     }
-
 }
 
 impl CharLit<&str> {
diff --git a/src/char/tests.rs b/src/char/tests.rs
@@ -1,5 +1,8 @@
-use crate::{Literal, test_util::{assert_parse_ok_eq, assert_roundtrip}};
 use super::CharLit;
+use crate::{
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
+    Literal,
+};
 
 // ===== Utility functions =======================================================================
 
diff --git a/src/cstr/mod.rs b/src/cstr/mod.rs
@@ -1,9 +1,13 @@
-use std::{ffi::{CStr, CString}, fmt, ops::Range};
+use std::{
+    ffi::{CStr, CString},
+    fmt,
+    ops::Range,
+};
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
     escape::{scan_raw_string, unescape_string},
+    Buffer, ParseError,
 };
 
 
@@ -77,7 +81,7 @@ impl<B: Buffer> CStringLit<B> {
     }
 }
 
-    /// The range within `self.raw` that excludes the quotes and potential `r#`.
+/// The range within `self.raw` that excludes the quotes and potential `r#`.
 fn inner_range(num_hashes: Option<u8>, start_suffix: usize) -> Range<usize> {
     match num_hashes {
         None => 2..start_suffix - 1,
diff --git a/src/cstr/tests.rs b/src/cstr/tests.rs
@@ -1,6 +1,9 @@
 use std::ffi::CString;
 
-use crate::{Literal, CStringLit, test_util::{assert_parse_ok_eq, assert_roundtrip}};
+use crate::{
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
+    CStringLit, Literal,
+};
 
 // ===== Utility functions =======================================================================
 
diff --git a/src/err.rs b/src/err.rs
@@ -15,7 +15,7 @@ impl InvalidToken {
     /// `"msg"` is the output of `self.to_string()`. **Panics if called outside
     /// of a proc-macro context!**
     pub fn to_compile_error(&self) -> proc_macro::TokenStream {
-        use proc_macro::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};
+        use proc_macro::{Delimiter, Group, Ident, Punct, Spacing, TokenTree};
 
         let span = match self.span {
             Span::One(s) => s,
@@ -41,7 +41,7 @@ impl InvalidToken {
     /// context.
     #[cfg(feature = "proc-macro2")]
     pub fn to_compile_error2(&self) -> proc_macro2::TokenStream {
-        use proc_macro2::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};
+        use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, TokenTree};
 
         let span = match self.span {
             Span::One(s) => proc_macro2::Span::from(s),
diff --git a/src/escape.rs b/src/escape.rs
@@ -1,4 +1,8 @@
-use crate::{ParseError, err::{perr, ParseErrorKind::*}, parse::{hex_digit_value, check_suffix}};
+use crate::{
+    err::{perr, ParseErrorKind::*},
+    parse::{check_suffix, hex_digit_value},
+    ParseError,
+};
 
 
 /// Must start with `\`. Returns the unscaped value as `E` and the number of
@@ -56,7 +60,7 @@ pub(crate) fn unescape(
             }
 
             (Unescape::Byte(value), 4)
-        },
+        }
 
         // Unicode escape
         b'u' => {
@@ -79,7 +83,7 @@ pub(crate) fn unescape(
             let mut v: u32 = 0;
             let mut digit_count = 0;
             for (i, b) in inner.bytes().enumerate() {
-                if b == b'_'{
+                if b == b'_' {
                     continue;
                 }
 
@@ -213,7 +217,7 @@ pub(crate) fn unescape_string<C: EscapeContainer>(
             b'"' => {
                 closing_quote_pos = Some(i);
                 break;
-            },
+            }
             b'\0' if !allow_nul => return Err(perr(i, NulByte)),
             b if !unicode && !b.is_ascii() => return Err(perr(i, NonAsciiInByteLiteral)),
             _ => i += 1,
diff --git a/src/float/mod.rs b/src/float/mod.rs
@@ -1,9 +1,9 @@
 use std::{fmt, str::FromStr};
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
-    parse::{end_dec_digits, first_byte_or_empty, check_suffix},
+    parse::{check_suffix, end_dec_digits, first_byte_or_empty},
+    Buffer, ParseError,
 };
 
 
@@ -72,7 +72,7 @@ impl<B: Buffer> FloatLit<B> {
                 } = parse_impl(&s)?;
 
                 Ok(Self { raw: s, end_integer_part, end_fractional_part, end_number_part })
-            },
+            }
             _ => Err(perr(0, DoesNotStartWithDigit)),
         }
     }
diff --git a/src/float/tests.rs b/src/float/tests.rs
@@ -1,8 +1,8 @@
+use super::{FloatLit, FloatType};
 use crate::{
-    Literal, ParseError,
     test_util::{assert_parse_ok_eq, assert_roundtrip},
+    Literal, ParseError,
 };
-use super::{FloatLit, FloatType};
 
 
 // ===== Utility functions =======================================================================
@@ -237,8 +237,8 @@ fn parse_err() {
     assert_err!(FloatLit, "3.7-2", UnexpectedChar, 3..5);
     assert_err!(FloatLit, "3.7e+", NoExponentDigits, 3..5);
     assert_err!(FloatLit, "3.7e-", NoExponentDigits, 3..5);
-    assert_err!(FloatLit, "3.7e-+3", NoExponentDigits, 3..5);  // suboptimal error
-    assert_err!(FloatLit, "3.7e+-3", NoExponentDigits, 3..5);  // suboptimal error
+    assert_err!(FloatLit, "3.7e-+3", NoExponentDigits, 3..5); // suboptimal error
+    assert_err!(FloatLit, "3.7e+-3", NoExponentDigits, 3..5); // suboptimal error
     assert_err_single!(FloatLit::parse("0x44.5"), InvalidSuffix, 1..6);
 
     assert_err_single!(FloatLit::parse("3"), UnexpectedIntegerLit, None);
diff --git a/src/impls.rs b/src/impls.rs
@@ -1,6 +1,9 @@
 use std::convert::TryFrom;
 
-use crate::{Literal, err::{InvalidToken, TokenKind}};
+use crate::{
+    err::{InvalidToken, TokenKind},
+    Literal,
+};
 
 
 /// Helper macro to call a `callback` macro four times for all combinations of
@@ -70,7 +73,7 @@ macro_rules! impl_tt_to_lit {
     }
 }
 
-helper!(impl_tt_to_lit, );
+helper!(impl_tt_to_lit,);
 
 
 // ==============================================================================================
@@ -107,7 +110,7 @@ macro_rules! impl_tt_to_lit {
     }
 }
 
-helper!(impl_tt_to_lit, );
+helper!(impl_tt_to_lit,);
 
 
 // ==============================================================================================
@@ -243,7 +246,7 @@ macro_rules! impl_from_tt_for_bool {
     };
 }
 
-helper!(impl_from_tt_for_bool, );
+helper!(impl_from_tt_for_bool,);
 
 // ==============================================================================================
 // ===== `From<BoolLit> for pm::Ident`
@@ -259,7 +262,7 @@ macro_rules! impl_bool_lit_to_pm_lit {
     };
 }
 
-helper_no_refs!(impl_bool_lit_to_pm_lit, );
+helper_no_refs!(impl_bool_lit_to_pm_lit,);
 
 
 mod tests {
diff --git a/src/integer/mod.rs b/src/integer/mod.rs
@@ -1,9 +1,9 @@
 use std::{fmt, str::FromStr};
 
 use crate::{
-    Buffer, ParseError,
     err::{perr, ParseErrorKind::*},
-    parse::{first_byte_or_empty, hex_digit_value, check_suffix},
+    parse::{check_suffix, first_byte_or_empty, hex_digit_value},
+    Buffer, ParseError,
 };
 
 
@@ -47,10 +47,10 @@ impl<B: Buffer> IntegerLit<B> {
                     end_main_part,
                     base,
                     ..
-                } =  parse_impl(&input, digit)?;
+                } = parse_impl(&input, digit)?;
 
                 Ok(Self { raw: input, start_main_part, end_main_part, base })
-            },
+            }
             _ => Err(perr(0, DoesNotStartWithDigit)),
         }
     }
diff --git a/src/integer/tests.rs b/src/integer/tests.rs
@@ -1,7 +1,10 @@
 use std::fmt::{Debug, Display};
+
 use crate::{
-    FromIntegerLiteral, Literal, IntegerLit, IntegerType as Ty, IntegerBase, IntegerBase::*,
     test_util::{assert_parse_ok_eq, assert_roundtrip},
+    FromIntegerLiteral, IntegerBase,
+    IntegerBase::*,
+    IntegerLit, IntegerType as Ty, Literal,
 };
 
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -169,7 +169,11 @@ mod parse;
 mod string;
 
 
-use std::{borrow::{Borrow, Cow}, fmt, ops::{Deref, Range}};
+use std::{
+    borrow::{Borrow, Cow},
+    fmt,
+    ops::{Deref, Range},
+};
 
 pub use self::{
     bool::BoolLit,
@@ -179,7 +183,7 @@ pub use self::{
     cstr::CStringLit,
     err::{InvalidToken, ParseError},
     float::{FloatLit, FloatType},
-    integer::{FromIntegerLiteral, IntegerLit, IntegerBase, IntegerType},
+    integer::{FromIntegerLiteral, IntegerBase, IntegerLit, IntegerType},
     string::StringLit,
 };
 
diff --git a/src/parse.rs b/src/parse.rs
@@ -1,16 +1,10 @@
 use crate::{
-    BoolLit,
-    Buffer,
-    ByteLit,
-    ByteStringLit,
-    CharLit,
-    ParseError,
-    FloatLit,
-    IntegerLit,
-    Literal,
-    StringLit,
-    CStringLit,
-    err::{perr, ParseErrorKind::{*, self}},
+    err::{
+        perr,
+        ParseErrorKind::{self, *},
+    },
+    BoolLit, Buffer, ByteLit, ByteStringLit, CStringLit, CharLit, FloatLit, IntegerLit, Literal,
+    ParseError, StringLit,
 };
 
 
@@ -38,7 +32,7 @@ pub fn parse<B: Buffer>(input: B) -> Result<Literal<B>, ParseError> {
 
                 _ => IntegerLit::parse(input).map(Literal::Integer),
             }
-        },
+        }
 
         b'\'' => CharLit::parse(input).map(Literal::Char),
         b'"' | b'r' => StringLit::parse(input).map(Literal::String),
diff --git a/src/string/mod.rs b/src/string/mod.rs
diff --git a/src/string/tests.rs b/src/string/tests.rs
diff --git a/src/test_util.rs b/src/test_util.rs
diff --git a/src/tests.rs b/src/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,10 @@`
`1`	`1`	`use std::fmt;`
`2`	`2`
`3`	`3`	`use crate::{`
`4`		`- Buffer, ParseError,`
`5`	`4`	`err::{perr, ParseErrorKind::*},`
`6`	`5`	`escape::unescape,`
`7`		`- parse::{first_byte_or_empty, check_suffix},`
	`6`	`+ parse::{check_suffix, first_byte_or_empty},`
	`7`	`+ Buffer, ParseError,`
`8`	`8`	`};`
`9`	`9`
`10`	`10`
`@@ -29,7 +29,7 @@ impl<B: Buffer> CharLit<B> {`
`29`	`29`	`b'\'' => {`
`30`	`30`	`let (value, start_suffix) = parse_impl(&input)?;`
`31`	`31`	`Ok(Self { raw: input, value, start_suffix })`
`32`		`- },`
	`32`	`+ }`
`33`	`33`	`_ => Err(perr(0, DoesNotStartWithQuote)),`
`34`	`34`	`}`
`35`	`35`	`}`
`@@ -53,7 +53,6 @@ impl<B: Buffer> CharLit<B> {`
`53`	`53`	`pub fn into_raw_input(self) -> B {`
`54`	`54`	`self.raw`
`55`	`55`	`}`
`56`		`-`
`57`	`56`	`}`
`58`	`57`
`59`	`58`	`impl CharLit<&str> {`