Improve code and apply suggestions

GuillaumeGomez · GuillaumeGomez · commit b83678b029ea · 2025-05-12T14:14:45.000+02:00
diff --git a/clippy_lints/src/useless_concat.rs b/clippy_lints/src/useless_concat.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::macro_backtrace;
 use clippy_utils::paths::CONCAT;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{match_def_path, tokenize_with_text};
+use clippy_utils::tokenize_with_text;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -43,7 +43,7 @@ impl LateLintPass<'_> for UselessConcat {
             // Get the direct parent of the expression.
             && let Some(macro_call) = macro_backtrace(expr.span).next()
             // Check if the `concat` macro from the `core` library.
-            && match_def_path(cx, macro_call.def_id, &CONCAT)
+            && CONCAT.matches(cx, macro_call.def_id)
             // We get the original code to parse it.
             && let Some(original_code) = snippet_opt(cx, macro_call.span)
             // This check allows us to ensure that the code snippet:
@@ -68,7 +68,13 @@ impl LateLintPass<'_> for UselessConcat {
                         }
                         literal = Some(token_s);
                     },
-                    TokenKind::Ident => nb_idents += 1,
+                    TokenKind::Ident => {
+                        if token_s == "true" || token_s == "false" {
+                            literal = Some(token_s);
+                        } else {
+                            nb_idents += 1;
+                        }
+                    },
                     TokenKind::Comma => {
                         nb_commas += 1;
                         if nb_commas > 1 {
@@ -82,12 +88,46 @@ impl LateLintPass<'_> for UselessConcat {
                 }
             }
             let literal = match literal {
-                Some(lit) => {
+                Some(original_lit) => {
                     // Literals can also be number, so we need to check this case too.
+                    let lit = original_lit.strip_prefix("r").unwrap_or(original_lit);
+                    let lit = lit.trim_start_matches('#');
                     if lit.starts_with('"') {
-                        lit.to_string()
+                        // It's a string, nothing to be done.
+                        original_lit.to_string()
+                    } else if original_lit.starts_with('\'') {
+                        format!(
+                            "\"{}\"",
+                            original_lit
+                                .strip_prefix('\'')
+                                .and_then(|l| l.strip_suffix('\''))
+                                .unwrap_or(original_lit)
+                        )
+                    } else if original_lit == "true" || original_lit == "false" {
+                        // It's a boolean so nothing else to be done.
+                        format!("\"{original_lit}\"")
                     } else {
-                        format!("\"{lit}\"")
+                        format!(
+                            "\"{}\"",
+                            original_lit
+                                .strip_suffix("f16")
+                                .or_else(|| original_lit.strip_suffix("f32"))
+                                .or_else(|| original_lit.strip_suffix("f64"))
+                                .or_else(|| original_lit.strip_suffix("128")) // We never know?
+                                .or_else(|| original_lit.strip_suffix("u8"))
+                                .or_else(|| original_lit.strip_suffix("u16"))
+                                .or_else(|| original_lit.strip_suffix("u32"))
+                                .or_else(|| original_lit.strip_suffix("u64"))
+                                .or_else(|| original_lit.strip_suffix("u128"))
+                                .or_else(|| original_lit.strip_suffix("usize"))
+                                .or_else(|| original_lit.strip_suffix("i8"))
+                                .or_else(|| original_lit.strip_suffix("i16"))
+                                .or_else(|| original_lit.strip_suffix("i32"))
+                                .or_else(|| original_lit.strip_suffix("i64"))
+                                .or_else(|| original_lit.strip_suffix("i128"))
+                                .or_else(|| original_lit.strip_suffix("isize"))
+                                .unwrap_or(original_lit)
+                        )
                     }
                 },
                 None => "\"\"".to_string(),
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
@@ -129,12 +129,14 @@ path_macros! {
 // Paths in `core`/`alloc`/`std`. This should be avoided and cleaned up by adding diagnostic items.
 pub static ALIGN_OF: PathLookup = value_path!(core::mem::align_of);
 pub static CHAR_TO_DIGIT: PathLookup = value_path!(char::to_digit);
-pub static CONCAT: PathLookup = value_path!(core::macros::builtin::concat);
 pub static IO_ERROR_NEW: PathLookup = value_path!(std::io::Error::new);
 pub static IO_ERRORKIND_OTHER_CTOR: PathLookup = value_path!(std::io::ErrorKind::Other);
 pub static ITER_STEP: PathLookup = type_path!(core::iter::Step);
 pub static SLICE_FROM_REF: PathLookup = value_path!(core::slice::from_ref);
 
+// This path is wrongly computed when using `PathLookup`.
+pub static CONCAT: PathLookup = macro_path!(core::concat);
+
 // Paths in external crates
 pub static FUTURES_IO_ASYNCREADEXT: PathLookup = type_path!(futures_util::AsyncReadExt);
 pub static FUTURES_IO_ASYNCWRITEEXT: PathLookup = type_path!(futures_util::AsyncWriteExt);
diff --git a/tests/ui/useless_concat.fixed b/tests/ui/useless_concat.fixed
@@ -1,6 +1,11 @@
+//@aux-build:proc_macros.rs
+
 #![warn(clippy::useless_concat)]
 #![allow(clippy::print_literal)]
 
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
 macro_rules! my_concat {
     ($fmt:literal $(, $e:expr)*) => {
         println!(concat!("ERROR: ", $fmt), $($e,)*);
@@ -9,12 +14,23 @@ macro_rules! my_concat {
 
 fn main() {
     let x = ""; //~ useless_concat
+    let x = "c"; //~ useless_concat
+    let x = "true"; //~ useless_concat
+    let x = "1"; //~ useless_concat
+    let x = "1.0000"; //~ useless_concat
     let x = "a"; //~ useless_concat
+    let x = r##"a"##; //~ useless_concat
     let x = "1"; //~ useless_concat
     println!("b: {}", "a"); //~ useless_concat
     // Should not lint.
     let x = concat!("a", "b");
     let local_i32 = 1;
     my_concat!("{}", local_i32);
     let x = concat!(file!(), "#L", line!());
+
+    external! { concat!(); }
+    with_span! {
+        span
+        concat!();
+    }
 }
diff --git a/tests/ui/useless_concat.rs b/tests/ui/useless_concat.rs
@@ -1,6 +1,11 @@
+//@aux-build:proc_macros.rs
+
 #![warn(clippy::useless_concat)]
 #![allow(clippy::print_literal)]
 
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
 macro_rules! my_concat {
     ($fmt:literal $(, $e:expr)*) => {
         println!(concat!("ERROR: ", $fmt), $($e,)*);
@@ -9,12 +14,23 @@ macro_rules! my_concat {
 
 fn main() {
     let x = concat!(); //~ useless_concat
+    let x = concat!('c'); //~ useless_concat
+    let x = concat!(true); //~ useless_concat
+    let x = concat!(1f32); //~ useless_concat
+    let x = concat!(1.0000f32); //~ useless_concat
     let x = concat!("a"); //~ useless_concat
+    let x = concat!(r##"a"##); //~ useless_concat
     let x = concat!(1); //~ useless_concat
     println!("b: {}", concat!("a")); //~ useless_concat
     // Should not lint.
     let x = concat!("a", "b");
     let local_i32 = 1;
     my_concat!("{}", local_i32);
     let x = concat!(file!(), "#L", line!());
+
+    external! { concat!(); }
+    with_span! {
+        span
+        concat!();
+    }
 }
diff --git a/tests/ui/useless_concat.stderr b/tests/ui/useless_concat.stderr
@@ -1,5 +1,5 @@
 error: unneeded use of `concat!` macro
-  --> tests/ui/useless_concat.rs:11:13
+  --> tests/ui/useless_concat.rs:16:13
    |
 LL |     let x = concat!();
    |             ^^^^^^^^^ help: replace with: `""`
@@ -8,22 +8,52 @@ LL |     let x = concat!();
    = help: to override `-D warnings` add `#[allow(clippy::useless_concat)]`
 
 error: unneeded use of `concat!` macro
-  --> tests/ui/useless_concat.rs:12:13
+  --> tests/ui/useless_concat.rs:17:13
+   |
+LL |     let x = concat!('c');
+   |             ^^^^^^^^^^^^ help: replace with: `"c"`
+
+error: unneeded use of `concat!` macro
+  --> tests/ui/useless_concat.rs:18:13
+   |
+LL |     let x = concat!(true);
+   |             ^^^^^^^^^^^^^ help: replace with: `"true"`
+
+error: unneeded use of `concat!` macro
+  --> tests/ui/useless_concat.rs:19:13
+   |
+LL |     let x = concat!(1f32);
+   |             ^^^^^^^^^^^^^ help: replace with: `"1"`
+
+error: unneeded use of `concat!` macro
+  --> tests/ui/useless_concat.rs:20:13
+   |
+LL |     let x = concat!(1.0000f32);
+   |             ^^^^^^^^^^^^^^^^^^ help: replace with: `"1.0000"`
+
+error: unneeded use of `concat!` macro
+  --> tests/ui/useless_concat.rs:21:13
    |
 LL |     let x = concat!("a");
    |             ^^^^^^^^^^^^ help: replace with: `"a"`
 
 error: unneeded use of `concat!` macro
-  --> tests/ui/useless_concat.rs:13:13
+  --> tests/ui/useless_concat.rs:22:13
+   |
+LL |     let x = concat!(r##"a"##);
+   |             ^^^^^^^^^^^^^^^^^ help: replace with: `r##"a"##`
+
+error: unneeded use of `concat!` macro
+  --> tests/ui/useless_concat.rs:23:13
    |
 LL |     let x = concat!(1);
    |             ^^^^^^^^^^ help: replace with: `"1"`
 
 error: unneeded use of `concat!` macro
-  --> tests/ui/useless_concat.rs:14:23
+  --> tests/ui/useless_concat.rs:24:23
    |
 LL |     println!("b: {}", concat!("a"));
    |                       ^^^^^^^^^^^^ help: replace with: `"a"`
 
-error: aborting due to 4 previous errors
+error: aborting due to 9 previous errors
 
