Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust: clean Rust 1.88.0's `clippy::uninlined_format_args` lint 

Starting with Rust 1.88.0 (expected 2025-06-26) [1], `rustc` may move
back the `uninlined_format_args` to `style` from `pedantic` (it was
there waiting for rust-analyzer suppotr), and thus we will start to see
lints like:

    warning: variables can be used directly in the `format!` string
       --> rust/macros/kunit.rs:105:37
        |
    105 |         let kunit_wrapper_fn_name = format!("kunit_rust_wrapper_{}", test);
        |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
    help: change this to
        |
    105 -         let kunit_wrapper_fn_name = format!("kunit_rust_wrapper_{}", test);
    105 +         let kunit_wrapper_fn_name = format!("kunit_rust_wrapper_{test}");

There is even a case that is a pure removal:

    warning: variables can be used directly in the `format!` string
      --> rust/macros/module.rs:51:13
       |
    51 |             format!("{field}={content}\0", field = field, content = content)
       |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
    help: change this to
       |
    51 -             format!("{field}={content}\0", field = field, content = content)
    51 +             format!("{field}={content}\0")

The lints all seem like nice cleanups, thus just apply them.

We may want to disable `allow-mixed-uninlined-format-args` in the future.

Cc: stable@vger.kernel.org # Needed in 6.12.y and later (Rust is pinned in older LTSs).
Link: https://github.com/rust-lang/rust-clippy/pull/14160 [1]
Acked-by: Benno Lossin <lossin@kernel.org>
Reviewed-by: Tamir Duberstein <tamird@gmail.com>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20250502140237.1659624-6-ojeda@kernel.org
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
This commit is contained in:
Miguel Ojeda 2025-05-02 16:02:37 +02:00
parent c016722fd5
commit 211dcf7785
6 changed files with 35 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/gpu/nova-core/gpu.rs
View File

@ -93,7 +93,7 @@ pub(crate) fn arch(&self) -> Architecture {
// For now, redirect to fmt::Debug for convenience. // For now, redirect to fmt::Debug for convenience.
impl fmt::Display for Chipset { impl fmt::Display for Chipset {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self) write!(f, "{self:?}")
} }
} }

46
rust/kernel/str.rs
View File

@ -73,7 +73,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
b'\r' => f.write_str("\\r")?, b'\r' => f.write_str("\\r")?,
// Printable characters. // Printable characters.
0x20..=0x7e => f.write_char(b as char)?, 0x20..=0x7e => f.write_char(b as char)?,
_ => write!(f, "\\x{:02x}", b)?, _ => write!(f, "\\x{b:02x}")?,
} }
} }
Ok(()) Ok(())
@ -109,7 +109,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
b'\\' => f.write_str("\\\\")?, b'\\' => f.write_str("\\\\")?,
// Printable characters. // Printable characters.
0x20..=0x7e => f.write_char(b as char)?, 0x20..=0x7e => f.write_char(b as char)?,
_ => write!(f, "\\x{:02x}", b)?, _ => write!(f, "\\x{b:02x}")?,
} }
} }
f.write_char('"') f.write_char('"')
@ -447,7 +447,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// Printable character. // Printable character.
f.write_char(c as char)?; f.write_char(c as char)?;
} else { } else {
write!(f, "\\x{:02x}", c)?; write!(f, "\\x{c:02x}")?;
} }
} }
Ok(()) Ok(())
@ -479,7 +479,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// Printable characters. // Printable characters.
b'\"' => f.write_str("\\\"")?, b'\"' => f.write_str("\\\"")?,
0x20..=0x7e => f.write_char(c as char)?, 0x20..=0x7e => f.write_char(c as char)?,
_ => write!(f, "\\x{:02x}", c)?, _ => write!(f, "\\x{c:02x}")?,
} }
} }
f.write_str("\"") f.write_str("\"")
@ -641,13 +641,13 @@ fn test_cstr_as_str_unchecked() {
#[test] #[test]
fn test_cstr_display() { fn test_cstr_display() {
let hello_world = CStr::from_bytes_with_nul(b"hello, world!\0").unwrap(); let hello_world = CStr::from_bytes_with_nul(b"hello, world!\0").unwrap();
assert_eq!(format!("{}", hello_world), "hello, world!"); assert_eq!(format!("{hello_world}"), "hello, world!");
let non_printables = CStr::from_bytes_with_nul(b"\x01\x09\x0a\0").unwrap(); let non_printables = CStr::from_bytes_with_nul(b"\x01\x09\x0a\0").unwrap();
assert_eq!(format!("{}", non_printables), "\\x01\\x09\\x0a"); assert_eq!(format!("{non_printables}"), "\\x01\\x09\\x0a");
let non_ascii = CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0").unwrap(); let non_ascii = CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0").unwrap();
assert_eq!(format!("{}", non_ascii), "d\\xe9j\\xe0 vu"); assert_eq!(format!("{non_ascii}"), "d\\xe9j\\xe0 vu");
let good_bytes = CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0").unwrap(); let good_bytes = CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0").unwrap();
assert_eq!(format!("{}", good_bytes), "\\xf0\\x9f\\xa6\\x80"); assert_eq!(format!("{good_bytes}"), "\\xf0\\x9f\\xa6\\x80");
} }
#[test] #[test]
@ -658,47 +658,47 @@ fn test_cstr_display_all_bytes() {
bytes[i as usize] = i.wrapping_add(1); bytes[i as usize] = i.wrapping_add(1);
} }
let cstr = CStr::from_bytes_with_nul(&bytes).unwrap(); let cstr = CStr::from_bytes_with_nul(&bytes).unwrap();
assert_eq!(format!("{}", cstr), ALL_ASCII_CHARS); assert_eq!(format!("{cstr}"), ALL_ASCII_CHARS);
} }
#[test] #[test]
fn test_cstr_debug() { fn test_cstr_debug() {
let hello_world = CStr::from_bytes_with_nul(b"hello, world!\0").unwrap(); let hello_world = CStr::from_bytes_with_nul(b"hello, world!\0").unwrap();
assert_eq!(format!("{:?}", hello_world), "\"hello, world!\""); assert_eq!(format!("{hello_world:?}"), "\"hello, world!\"");
let non_printables = CStr::from_bytes_with_nul(b"\x01\x09\x0a\0").unwrap(); let non_printables = CStr::from_bytes_with_nul(b"\x01\x09\x0a\0").unwrap();
assert_eq!(format!("{:?}", non_printables), "\"\\x01\\x09\\x0a\""); assert_eq!(format!("{non_printables:?}"), "\"\\x01\\x09\\x0a\"");
let non_ascii = CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0").unwrap(); let non_ascii = CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0").unwrap();
assert_eq!(format!("{:?}", non_ascii), "\"d\\xe9j\\xe0 vu\""); assert_eq!(format!("{non_ascii:?}"), "\"d\\xe9j\\xe0 vu\"");
let good_bytes = CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0").unwrap(); let good_bytes = CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0").unwrap();
assert_eq!(format!("{:?}", good_bytes), "\"\\xf0\\x9f\\xa6\\x80\""); assert_eq!(format!("{good_bytes:?}"), "\"\\xf0\\x9f\\xa6\\x80\"");
} }
#[test] #[test]
fn test_bstr_display() { fn test_bstr_display() {
let hello_world = BStr::from_bytes(b"hello, world!"); let hello_world = BStr::from_bytes(b"hello, world!");
assert_eq!(format!("{}", hello_world), "hello, world!"); assert_eq!(format!("{hello_world}"), "hello, world!");
let escapes = BStr::from_bytes(b"_\t_\n_\r_\\_\'_\"_"); let escapes = BStr::from_bytes(b"_\t_\n_\r_\\_\'_\"_");
assert_eq!(format!("{}", escapes), "_\\t_\\n_\\r_\\_'_\"_"); assert_eq!(format!("{escapes}"), "_\\t_\\n_\\r_\\_'_\"_");
let others = BStr::from_bytes(b"\x01"); let others = BStr::from_bytes(b"\x01");
assert_eq!(format!("{}", others), "\\x01"); assert_eq!(format!("{others}"), "\\x01");
let non_ascii = BStr::from_bytes(b"d\xe9j\xe0 vu"); let non_ascii = BStr::from_bytes(b"d\xe9j\xe0 vu");
assert_eq!(format!("{}", non_ascii), "d\\xe9j\\xe0 vu"); assert_eq!(format!("{non_ascii}"), "d\\xe9j\\xe0 vu");
let good_bytes = BStr::from_bytes(b"\xf0\x9f\xa6\x80"); let good_bytes = BStr::from_bytes(b"\xf0\x9f\xa6\x80");
assert_eq!(format!("{}", good_bytes), "\\xf0\\x9f\\xa6\\x80"); assert_eq!(format!("{good_bytes}"), "\\xf0\\x9f\\xa6\\x80");
} }
#[test] #[test]
fn test_bstr_debug() { fn test_bstr_debug() {
let hello_world = BStr::from_bytes(b"hello, world!"); let hello_world = BStr::from_bytes(b"hello, world!");
assert_eq!(format!("{:?}", hello_world), "\"hello, world!\""); assert_eq!(format!("{hello_world:?}"), "\"hello, world!\"");
let escapes = BStr::from_bytes(b"_\t_\n_\r_\\_\'_\"_"); let escapes = BStr::from_bytes(b"_\t_\n_\r_\\_\'_\"_");
assert_eq!(format!("{:?}", escapes), "\"_\\t_\\n_\\r_\\\\_'_\\\"_\""); assert_eq!(format!("{escapes:?}"), "\"_\\t_\\n_\\r_\\\\_'_\\\"_\"");
let others = BStr::from_bytes(b"\x01"); let others = BStr::from_bytes(b"\x01");
assert_eq!(format!("{:?}", others), "\"\\x01\""); assert_eq!(format!("{others:?}"), "\"\\x01\"");
let non_ascii = BStr::from_bytes(b"d\xe9j\xe0 vu"); let non_ascii = BStr::from_bytes(b"d\xe9j\xe0 vu");
assert_eq!(format!("{:?}", non_ascii), "\"d\\xe9j\\xe0 vu\""); assert_eq!(format!("{non_ascii:?}"), "\"d\\xe9j\\xe0 vu\"");
let good_bytes = BStr::from_bytes(b"\xf0\x9f\xa6\x80"); let good_bytes = BStr::from_bytes(b"\xf0\x9f\xa6\x80");
assert_eq!(format!("{:?}", good_bytes), "\"\\xf0\\x9f\\xa6\\x80\""); assert_eq!(format!("{good_bytes:?}"), "\"\\xf0\\x9f\\xa6\\x80\"");
} }
} }

13
rust/macros/kunit.rs
View File

@ -15,10 +15,7 @@ pub(crate) fn kunit_tests(attr: TokenStream, ts: TokenStream) -> TokenStream {
} }
if attr.len() > 255 { if attr.len() > 255 {
panic!( panic!("The test suite name `{attr}` exceeds the maximum length of 255 bytes")
"The test suite name `{}` exceeds the maximum length of 255 bytes",
attr
)
} }
let mut tokens: Vec<_> = ts.into_iter().collect(); let mut tokens: Vec<_> = ts.into_iter().collect();
@ -102,16 +99,14 @@ pub(crate) fn kunit_tests(attr: TokenStream, ts: TokenStream) -> TokenStream {
let mut kunit_macros = "".to_owned(); let mut kunit_macros = "".to_owned();
let mut test_cases = "".to_owned(); let mut test_cases = "".to_owned();
for test in &tests { for test in &tests {
let kunit_wrapper_fn_name = format!("kunit_rust_wrapper_{}", test); let kunit_wrapper_fn_name = format!("kunit_rust_wrapper_{test}");
let kunit_wrapper = format!( let kunit_wrapper = format!(
"unsafe extern \"C\" fn {}(_test: *mut kernel::bindings::kunit) {{ {}(); }}", "unsafe extern \"C\" fn {kunit_wrapper_fn_name}(_test: *mut kernel::bindings::kunit) {{ {test}(); }}"
kunit_wrapper_fn_name, test
); );
writeln!(kunit_macros, "{kunit_wrapper}").unwrap(); writeln!(kunit_macros, "{kunit_wrapper}").unwrap();
writeln!( writeln!(
test_cases, test_cases,
" kernel::kunit::kunit_case(kernel::c_str!(\"{}\"), {}),", " kernel::kunit::kunit_case(kernel::c_str!(\"{test}\"), {kunit_wrapper_fn_name}),"
test, kunit_wrapper_fn_name
) )
.unwrap(); .unwrap();
} }

19
rust/macros/module.rs
View File

@ -48,7 +48,7 @@ fn emit_base(&mut self, field: &str, content: &str, builtin: bool) {
) )
} else { } else {
// Loadable modules' modinfo strings go as-is. // Loadable modules' modinfo strings go as-is.
format!("{field}={content}\0", field = field, content = content) format!("{field}={content}\0")
}; };
write!( write!(
@ -126,10 +126,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
}; };
if seen_keys.contains(&key) { if seen_keys.contains(&key) {
panic!( panic!("Duplicated key \"{key}\". Keys can only be specified once.");
"Duplicated key \"{}\". Keys can only be specified once.",
key
);
} }
assert_eq!(expect_punct(it), ':'); assert_eq!(expect_punct(it), ':');
@ -143,10 +140,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
"license" => info.license = expect_string_ascii(it), "license" => info.license = expect_string_ascii(it),
"alias" => info.alias = Some(expect_string_array(it)), "alias" => info.alias = Some(expect_string_array(it)),
"firmware" => info.firmware = Some(expect_string_array(it)), "firmware" => info.firmware = Some(expect_string_array(it)),
_ => panic!( _ => panic!("Unknown key \"{key}\". Valid keys are: {EXPECTED_KEYS:?}."),
"Unknown key \"{}\". Valid keys are: {:?}.",
key, EXPECTED_KEYS
),
} }
assert_eq!(expect_punct(it), ','); assert_eq!(expect_punct(it), ',');
@ -158,7 +152,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
for key in REQUIRED_KEYS { for key in REQUIRED_KEYS {
if !seen_keys.iter().any(|e| e == key) { if !seen_keys.iter().any(|e| e == key) {
panic!("Missing required key \"{}\".", key); panic!("Missing required key \"{key}\".");
} }
} }
@ -170,10 +164,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
} }
if seen_keys != ordered_keys { if seen_keys != ordered_keys {
panic!( panic!("Keys are not ordered as expected. Order them like: {ordered_keys:?}.");
"Keys are not ordered as expected. Order them like: {:?}.",
ordered_keys
);
} }
info info

2
rust/macros/paste.rs
View File

@ -50,7 +50,7 @@ fn concat_helper(tokens: &[TokenTree]) -> Vec<(String, Span)> {
let tokens = group.stream().into_iter().collect::<Vec<TokenTree>>(); let tokens = group.stream().into_iter().collect::<Vec<TokenTree>>();
segments.append(&mut concat_helper(tokens.as_slice())); segments.append(&mut concat_helper(tokens.as_slice()));
} }
token => panic!("unexpected token in paste segments: {:?}", token), token => panic!("unexpected token in paste segments: {token:?}"),
}; };
} }

3
rust/pin-init/internal/src/pinned_drop.rs
View File

@ -28,8 +28,7 @@ pub(crate) fn pinned_drop(_args: TokenStream, input: TokenStream) -> TokenStream
// Found the end of the generics, this should be `PinnedDrop`. // Found the end of the generics, this should be `PinnedDrop`.
assert!( assert!(
matches!(tt, TokenTree::Ident(i) if i.to_string() == "PinnedDrop"), matches!(tt, TokenTree::Ident(i) if i.to_string() == "PinnedDrop"),
"expected 'PinnedDrop', found: '{:?}'", "expected 'PinnedDrop', found: '{tt:?}'"
tt
); );
pinned_drop_idx = Some(i); pinned_drop_idx = Some(i);
break; break;