teach clippy::author format args

Author: Niki4tap

clippy_lints/src/utils/author.rs

@@ -1,6 +1,7 @@
 //! A group of attributes that can be attached to Rust code in order
 //! to generate a clippy lint detecting said code automatically.
 
+use clippy_utils::macros::{collect_format_args, is_format_macro, root_macro_call_first_node};
 use clippy_utils::{get_attr, higher};
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_ast::LitIntType;
@@ -333,6 +334,24 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
     #[allow(clippy::too_many_lines)]
     fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {
+        if let Some(macro_call) = root_macro_call_first_node(self.cx, expr.value)
+            && is_format_macro(self.cx, macro_call.def_id)
+        {
+            let diag = self.cx.tcx.item_name(macro_call.def_id);
+            bind!(self, macro_call);
+            chain!(self, "let Some({macro_call}) = macros::root_macro_call_first_node(cx, {expr})");
+            chain!(self, "cx.tcx.is_diagnostic_item(sym::{diag}_macro, {macro_call}.def_id)");
+            let exprs: Vec<_> = collect_format_args(expr.value).collect();
+            let args = exprs.as_slice();
+            bind!(self, args);
+            chain!(self, "let {args} = macros::collect_format_args({expr}).collect()");
+            self.slice(args, |e| {
+                let expr = Binding { name: e.name.clone(), value: *e.value };
+                self.expr(&expr);
+            });
+            return;
+        }
+
         if let Some(higher::While { condition, body }) = higher::While::hir(expr.value) {
             bind!(self, condition, body);
             chain!(

clippy_utils/src/macros.rs

@@ -1,11 +1,11 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
-use crate::visitors::{for_each_expr, Descend};
+use crate::visitors::{for_each_expr, Descend, Visitable};
 
 use arrayvec::ArrayVec;
 use rustc_ast::{FormatArgs, FormatArgument, FormatPlaceholder};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
+use rustc_hir::{self as hir, Expr, ExprKind, HirId, LangItem, Node, QPath};
 use rustc_lint::LateContext;
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
@@ -425,6 +425,39 @@ pub fn find_format_arg_expr<'hir, 'ast>(
     .ok_or(&target.expr)
 }
 
+/// Given a start node, finds and extracts all format arguments from first occurance.
+///
+/// ```ignore
+/// // vvvvv any format-like macro
+/// println!("Hello, {}!", "ferris")
+/// //                     ^^^^^^^^ returns these expressions
+/// ```
+pub fn collect_format_args<'hir>(node: impl Visitable<'hir>) -> impl Iterator<Item = &'hir Expr<'hir>> {
+    let args = for_each_expr(node, |expr| {
+        if let ExprKind::Call(
+            Expr {
+                kind:
+                    ExprKind::Path(QPath::TypeRelative(
+                        rustc_hir::Ty {
+                            kind: rustc_hir::TyKind::Path(QPath::LangItem(LangItem::FormatArgument, ..)),
+                            ..
+                        },
+                        ..,
+                    )),
+                ..
+            },
+            args,
+        ) = expr.kind
+        {
+            ControlFlow::Break(args)
+        } else {
+            ControlFlow::Continue(Descend::Yes)
+        }
+    })
+    .unwrap_or_default();
+    args.iter()
+}
+
 /// Span of the `:` and format specifiers
 ///
 /// ```ignore