Minor refactor format-args

* Move all linting logic into a single format implementations struct

This should help with the future format-args improvements.

clippy_lints/src/format_args.rs

@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::{
     find_format_arg_expr, find_format_args, format_arg_removal_span, format_placeholder_format_span, is_assert_macro,
-    is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage,
+    is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage, MacroCall,
 };
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
@@ -20,7 +20,6 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{sym, Span, Symbol};
 
@@ -189,32 +188,18 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             && is_format_macro(cx, macro_call.def_id)
             && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
         {
-            for piece in &format_args.template {
+            let linter = FormatArgsExpr {
-                if let FormatArgsPiece::Placeholder(placeholder) = piece
+                cx,
-                    && let Ok(index) = placeholder.argument.index
+                expr,
-                    && let Some(arg) = format_args.arguments.all_args().get(index)
+                macro_call,
-                {
+                format_args: &format_args,
-                    let arg_expr = find_format_arg_expr(expr, arg);
+                ignore_mixed: self.ignore_mixed,
+            };
 
-                    check_unused_format_specifier(cx, placeholder, arg_expr);
+            linter.check_templates();
-
-                    if placeholder.format_trait != FormatTrait::Display
-                        || placeholder.format_options != FormatOptions::default()
-                        || is_aliased(&format_args, index)
-                    {
-                        continue;
-                    }
-
-                    if let Ok(arg_hir_expr) = arg_expr {
-                        let name = cx.tcx.item_name(macro_call.def_id);
-                        check_format_in_format_args(cx, macro_call.span, name, arg_hir_expr);
-                        check_to_string_in_format_args(cx, name, arg_hir_expr);
-                    }
-                }
-            }
 
             if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
-                check_uninlined_args(cx, &format_args, macro_call.span, macro_call.def_id, self.ignore_mixed);
+                linter.check_uninlined_args();
             }
         }
     }
@@ -222,15 +207,47 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_unused_format_specifier(
+struct FormatArgsExpr<'a, 'tcx> {
-    cx: &LateContext<'_>,
+    cx: &'a LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    macro_call: MacroCall,
+    format_args: &'a rustc_ast::FormatArgs,
+    ignore_mixed: bool,
+}
+
+impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
+    fn check_templates(&self) {
+        for piece in &self.format_args.template {
+            if let FormatArgsPiece::Placeholder(placeholder) = piece
+                && let Ok(index) = placeholder.argument.index
+                && let Some(arg) = self.format_args.arguments.all_args().get(index)
+            {
+                let arg_expr = find_format_arg_expr(self.expr, arg);
+
+                self.check_unused_format_specifier(placeholder, arg_expr);
+
+                if let Ok(arg_expr) = arg_expr
+                    && placeholder.format_trait == FormatTrait::Display
+                    && placeholder.format_options == FormatOptions::default()
+                    && !self.is_aliased(index)
+                {
+                    let name = self.cx.tcx.item_name(self.macro_call.def_id);
+                    self.check_format_in_format_args(name, arg_expr);
+                    self.check_to_string_in_format_args(name, arg_expr);
+                }
+            }
+        }
+    }
+
+    fn check_unused_format_specifier(
+        &self,
         placeholder: &FormatPlaceholder,
         arg_expr: Result<&Expr<'_>, &rustc_ast::Expr>,
-) {
+    ) {
-    let ty_or_ast_expr = arg_expr.map(|expr| cx.typeck_results().expr_ty(expr).peel_refs());
+        let ty_or_ast_expr = arg_expr.map(|expr| self.cx.typeck_results().expr_ty(expr).peel_refs());
 
         let is_format_args = match ty_or_ast_expr {
-        Ok(ty) => is_type_lang_item(cx, ty, LangItem::FormatArguments),
+            Ok(ty) => is_type_lang_item(self.cx, ty, LangItem::FormatArguments),
             Err(expr) => matches!(expr.peel_parens_and_refs().kind, rustc_ast::ExprKind::FormatArgs(_)),
         };
 
@@ -246,7 +263,7 @@ fn check_unused_format_specifier(
             && *options != FormatOptions::default()
         {
             span_lint_and_then(
-            cx,
+                self.cx,
                 UNUSED_FORMAT_SPECS,
                 placeholder_span,
                 "format specifiers have no effect on `format_args!()`",
@@ -255,10 +272,10 @@ fn check_unused_format_specifier(
                         let message = format!("for the {spec} to apply consider using `format!()`");
 
                         if let Some(mac_call) = root_macro_call(arg_span)
-                        && cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
+                            && self.cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
                         {
                             diag.span_suggestion(
-                            cx.sess().source_map().span_until_char(mac_call.span, '!'),
+                                self.cx.sess().source_map().span_until_char(mac_call.span, '!'),
                                 message,
                                 "format",
                                 Applicability::MaybeIncorrect,
@@ -287,19 +304,15 @@ fn check_unused_format_specifier(
                 },
             );
         }
-}
+    }
 
-fn check_uninlined_args(
+    fn check_uninlined_args(&self) {
-    cx: &LateContext<'_>,
+        if self.format_args.span.from_expansion() {
-    args: &rustc_ast::FormatArgs,
-    call_site: Span,
-    def_id: DefId,
-    ignore_mixed: bool,
-) {
-    if args.span.from_expansion() {
             return;
         }
-    if call_site.edition() < Edition2021 && (is_panic(cx, def_id) || is_assert_macro(cx, def_id)) {
+        if self.macro_call.span.edition() < Edition2021
+            && (is_panic(self.cx, self.macro_call.def_id) || is_assert_macro(self.cx, self.macro_call.def_id))
+        {
             // panic!, assert!, and debug_assert! before 2021 edition considers a single string argument as
             // non-format
             return;
@@ -311,8 +324,8 @@ fn check_uninlined_args(
         // we cannot remove any other arguments in the format string,
         // because the index numbers might be wrong after inlining.
         // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-    for (pos, usage) in format_arg_positions(args) {
+        for (pos, usage) in self.format_arg_positions() {
-        if !check_one_arg(args, pos, usage, &mut fixes, ignore_mixed) {
+            if !self.check_one_arg(pos, usage, &mut fixes) {
                 return;
             }
         }
@@ -323,16 +336,18 @@ fn check_uninlined_args(
 
         // multiline span display suggestion is sometimes broken: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
         // in those cases, make the code suggestion hidden
-    let multiline_fix = fixes.iter().any(|(span, _)| cx.sess().source_map().is_multiline(*span));
+        let multiline_fix = fixes
+            .iter()
+            .any(|(span, _)| self.cx.sess().source_map().is_multiline(*span));
 
         // Suggest removing each argument only once, for example in `format!("{0} {0}", arg)`.
         fixes.sort_unstable_by_key(|(span, _)| *span);
         fixes.dedup_by_key(|(span, _)| *span);
 
         span_lint_and_then(
-        cx,
+            self.cx,
             UNINLINED_FORMAT_ARGS,
-        call_site,
+            self.macro_call.span,
             "variables can be used directly in the `format!` string",
             |diag| {
                 diag.multipart_suggestion_with_style(
@@ -343,23 +358,17 @@ fn check_uninlined_args(
                 );
             },
         );
-}
+    }
 
-fn check_one_arg(
+    fn check_one_arg(&self, pos: &FormatArgPosition, usage: FormatParamUsage, fixes: &mut Vec<(Span, String)>) -> bool {
-    args: &rustc_ast::FormatArgs,
-    pos: &FormatArgPosition,
-    usage: FormatParamUsage,
-    fixes: &mut Vec<(Span, String)>,
-    ignore_mixed: bool,
-) -> bool {
         let index = pos.index.unwrap();
-    let arg = &args.arguments.all_args()[index];
+        let arg = &self.format_args.arguments.all_args()[index];
 
         if !matches!(arg.kind, FormatArgumentKind::Captured(_))
             && let rustc_ast::ExprKind::Path(None, path) = &arg.expr.kind
             && let [segment] = path.segments.as_slice()
             && segment.args.is_none()
-        && let Some(arg_span) = format_arg_removal_span(args, index)
+            && let Some(arg_span) = format_arg_removal_span(self.format_args, index)
             && let Some(pos_span) = pos.span
         {
             let replacement = match usage {
@@ -375,23 +384,23 @@ fn check_one_arg(
             // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
             // * if allow_mixed_uninlined_format_args is false and this arg hasn't been inlined already
             pos.kind != FormatArgPositionKind::Number
-            && (!ignore_mixed || matches!(arg.kind, FormatArgumentKind::Captured(_)))
+                && (!self.ignore_mixed || matches!(arg.kind, FormatArgumentKind::Captured(_)))
+        }
     }
-}
 
-fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &Expr<'_>) {
+    fn check_format_in_format_args(&self, name: Symbol, arg: &Expr<'_>) {
         let expn_data = arg.span.ctxt().outer_expn_data();
         if expn_data.call_site.from_expansion() {
             return;
         }
         let Some(mac_id) = expn_data.macro_def_id else { return };
-    if !cx.tcx.is_diagnostic_item(sym::format_macro, mac_id) {
+        if !self.cx.tcx.is_diagnostic_item(sym::format_macro, mac_id) {
             return;
         }
         span_lint_and_then(
-        cx,
+            self.cx,
             FORMAT_IN_FORMAT_ARGS,
-        call_site,
+            self.macro_call.span,
             &format!("`format!` in `{name}!` args"),
             |diag| {
                 diag.help(format!(
@@ -400,9 +409,10 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
                 diag.help("or consider changing `format!` to `format_args!`");
             },
         );
-}
+    }
 
-fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Expr<'_>) {
+    fn check_to_string_in_format_args(&self, name: Symbol, value: &Expr<'_>) {
+        let cx = self.cx;
         if !value.span.from_expansion()
             && let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
@@ -442,12 +452,10 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                 );
             }
         }
-}
+    }
 
-fn format_arg_positions(
+    fn format_arg_positions(&self) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
-    format_args: &rustc_ast::FormatArgs,
+        self.format_args.template.iter().flat_map(|piece| match piece {
-) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
-    format_args.template.iter().flat_map(|piece| match piece {
             FormatArgsPiece::Placeholder(placeholder) => {
                 let mut positions = ArrayVec::<_, 3>::new();
 
@@ -463,14 +471,15 @@ fn format_arg_positions(
             },
             FormatArgsPiece::Literal(_) => ArrayVec::new(),
         })
-}
+    }
 
-/// Returns true if the format argument at `index` is referred to by multiple format params
+    /// Returns true if the format argument at `index` is referred to by multiple format params
-fn is_aliased(format_args: &rustc_ast::FormatArgs, index: usize) -> bool {
+    fn is_aliased(&self, index: usize) -> bool {
-    format_arg_positions(format_args)
+        self.format_arg_positions()
             .filter(|(position, _)| position.index == Ok(index))
             .at_most_one()
             .is_err()
+    }
 }
 
 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)