use clippy_utils::diagnostics::span_lint_and_sugg;

use clippy_utils::macros::macro_backtrace;

use clippy_utils::source::snippet_opt;

use clippy_utils::{sym, tokenize_with_text};

use rustc_ast::LitKind;

use rustc_errors::Applicability;

use rustc_hir::{Expr, ExprKind};

use rustc_lexer::TokenKind;

use rustc_lint::{LateContext, LateLintPass};

use rustc_session::declare_lint_pass;

declare_clippy_lint! {

/// ### What it does

/// Checks that the `concat!` macro has at least two arguments.

///

/// ### Why is this bad?

/// If there are less than 2 arguments, then calling the macro is doing nothing.

///

/// ### Example

/// ```no_run

/// let x = concat!("a");

/// ```

/// Use instead:

/// ```no_run

/// let x = "a";

/// ```

#[clippy::version = "1.89.0"]

pub USELESS_CONCAT,

complexity,

"checks that the `concat` macro has at least two arguments"

}

declare_lint_pass!(UselessConcat => [USELESS_CONCAT]);

impl LateLintPass<'_> for UselessConcat {

fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {

// Check that the expression is generated by a macro.

if expr.span.from_expansion()

// Check that it's a string literal.

&& let ExprKind::Lit(lit) = expr.kind

&& let LitKind::Str(lit_s, _) = lit.node

// 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.

&& cx.tcx.is_diagnostic_item(sym::macro_concat, 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:

// 1. Doesn't come from proc-macro expansion.

// 2. Doesn't come from foreign macro expansion.

//

// It works as follows: if the snippet we get doesn't contain `concat!(`, then it

// means it's not code written in the current crate so we shouldn't lint.

&& let mut parts = original_code.split('!')

&& parts.next().is_some_and(|p| p.trim() == "concat")

&& parts.next().is_some_and(|p| p.trim().starts_with('('))

{

let mut literal = None;

let mut nb_commas = 0;

let mut nb_idents = 0;

for (token_kind, token_s, _) in tokenize_with_text(&original_code) {

match token_kind {

TokenKind::Eof => break,

TokenKind::Literal { .. } => {

if literal.is_some() {

return;

}

literal = Some(token_s);

},

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 {

return;

}

},

// We're inside a macro definition and we are manipulating something we likely

// shouldn't, so aborting.

TokenKind::Dollar => return,

_ => {},

}

}

// There should always be the ident of the `concat` macro.

if nb_idents == 1 {

span_lint_and_sugg(

cx,

USELESS_CONCAT,

macro_call.span,

"unneeded use of `concat!` macro",

"replace with",

format!("{lit_s:?}"),

Applicability::MachineApplicable,

);

}

}

}

}