loops: reuse iterator checks for unused_enumerate_index

Author: cuongleqq

clippy_lints/src/loops/mod.rs

@@ -884,25 +884,38 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         if let ExprKind::MethodCall(path, recv, args, _) = expr.kind {
             let name = path.ident.name;
-            let is_iterator_method = cx
-                .ty_based_def(expr)
-                .assoc_fn_parent(cx)
-                .is_diag_item(cx, sym::Iterator);
 
+            let is_iterator_method = || {
+                cx.ty_based_def(expr)
+                    .assoc_fn_parent(cx)
+                    .is_diag_item(cx, sym::Iterator)
+            };
+
+            // is_iterator_method is a bit expensive, so we call it last in each match arm
             match (name, args) {
                 (sym::for_each | sym::all | sym::any, [arg]) => {
-                    unused_enumerate_index::check_method(cx, expr, recv, arg);
-                    if is_iterator_method {
-                        never_loop::check_iterator_reduction(cx, expr, recv, args);
+                    if let ExprKind::Closure(closure) = arg.kind
+                        && is_iterator_method()
+                    {
+                        unused_enumerate_index::check_method(cx, recv, arg, closure);
+                        never_loop::check_iterator_reduction(cx, expr, recv, closure);
                     }
                 },
 
                 (sym::filter_map | sym::find_map | sym::flat_map | sym::map, [arg]) => {
-                    unused_enumerate_index::check_method(cx, expr, recv, arg);
+                    if let ExprKind::Closure(closure) = arg.kind
+                        && is_iterator_method()
+                    {
+                        unused_enumerate_index::check_method(cx, recv, arg, closure);
+                    }
                 },
 
-                (sym::try_for_each | sym::reduce | sym::fold | sym::try_fold, args) if is_iterator_method => {
-                    never_loop::check_iterator_reduction(cx, expr, recv, args);
+                (sym::try_for_each | sym::reduce, [arg]) | (sym::fold | sym::try_fold, [_, arg]) => {
+                    if let ExprKind::Closure(closure) = arg.kind
+                        && is_iterator_method()
+                    {
+                        never_loop::check_iterator_reduction(cx, expr, recv, closure);
+                    }
                 },
 
                 _ => {},

clippy_lints/src/loops/never_loop.rs

@@ -8,7 +8,8 @@ use clippy_utils::sym;
 use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
 use rustc_errors::Applicability;
 use rustc_hir::{
-    Block, Destination, Expr, ExprKind, HirId, InlineAsm, InlineAsmOperand, Node, Pat, Stmt, StmtKind, StructTailExpr,
+    Block, Closure, Destination, Expr, ExprKind, HirId, InlineAsm, InlineAsmOperand, Node, Pat, Stmt, StmtKind,
+    StructTailExpr,
 };
 use rustc_lint::LateContext;
 use rustc_span::{BytePos, Span};
@@ -77,32 +78,9 @@ pub(super) fn check_iterator_reduction<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
     recv: &'tcx Expr<'tcx>,
-    args: &'tcx [Expr<'tcx>],
+    closure: &'tcx Closure<'tcx>,
 ) {
-    // identify which argument is the closure based on the method kind
-    let Some(method_name) = (match expr.kind {
-        ExprKind::MethodCall(path, ..) => Some(path.ident.name),
-        _ => None,
-    }) else {
-        return;
-    };
-
-    let closure_arg = match method_name {
-        sym::for_each | sym::try_for_each | sym::reduce | sym::all | sym::any => args.first(),
-        sym::fold | sym::try_fold => args.get(1),
-        _ => None,
-    };
-
-    let Some(closure_arg) = closure_arg else {
-        return;
-    };
-
-    // extract the closure body
-    let closure_body = match closure_arg.kind {
-        ExprKind::Closure(closure) => cx.tcx.hir_body(closure.body).value,
-        _ => return,
-    };
-
+    let closure_body = cx.tcx.hir_body(closure.body).value;
     let body_ty = cx.typeck_results().expr_ty(closure_body);
     if body_ty.is_never() {
         span_lint_and_then(

clippy_lints/src/loops/unused_enumerate_index.rs

@@ -1,10 +1,10 @@
 use super::UNUSED_ENUMERATE_INDEX;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
+use clippy_utils::res::MaybeDef;
 use clippy_utils::source::{SpanRangeExt, walk_span_to_context};
 use clippy_utils::{expr_or_init, pat_is_wild};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Pat, PatKind, TyKind};
+use rustc_hir::{Closure, Expr, ExprKind, Pat, PatKind, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::{Span, SyntaxContext, sym};
 
@@ -60,14 +60,12 @@ pub(super) fn check<'tcx>(
 
 pub(super) fn check_method<'tcx>(
     cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'tcx>,
     recv: &'tcx Expr<'tcx>,
     arg: &'tcx Expr<'tcx>,
+    closure: &'tcx Closure<'tcx>,
 ) {
-    if let ExprKind::Closure(closure) = arg.kind
-        && let body = cx.tcx.hir_body(closure.body)
-        && let [param] = body.params
-        && cx.ty_based_def(e).opt_parent(cx).is_diag_item(cx, sym::Iterator)
+    let body = cx.tcx.hir_body(closure.body);
+    if let [param] = body.params
         && let [input] = closure.fn_decl.inputs
         && !arg.span.from_expansion()
         && !input.span.from_expansion()