Simplify code for this lint

Author: pmnoxx

clippy_lints/src/methods/iter_overeager_cloned.rs

@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy};
+use clippy_utils::ty::{get_iterator_item_ty, is_copy};
+use itertools::Itertools;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::sym;
+use std::ops::Not;
 
 use super::ITER_OVEREAGER_CLONED;
 use crate::redundant_clone::REDUNDANT_CLONE;
@@ -19,72 +20,46 @@ pub(super) fn check<'tcx>(
     map_arg: &[hir::Expr<'_>],
 ) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
+    // Check if it's iterator and get type associated with `Item`.
     let inner_ty = match get_iterator_item_ty(cx, recv_ty) {
         Some(ty) => ty,
         _ => return,
     };
 
     match inner_ty.kind() {
-        ty::Ref(_, ty, _) if is_copy(cx, ty) => return,
-        _ => {},
+        ty::Ref(_, ty, _) if !is_copy(cx, ty) => {},
+        _ => return,
     };
 
-    // lint if callee is an Iterator
-    let recv_impls_iterator = cx.tcx.get_diagnostic_item(sym::Iterator).map_or(false, |id| {
-        implements_trait(cx, cx.typeck_results().expr_ty(recv), id, &[])
-    });
-    if recv_impls_iterator {
-        let (lint, msg) = match name {
-            "count" => (
-                REDUNDANT_CLONE,
-                format!(
-                    "called `cloned().{}()` on an `Iterator`. It may be more efficient to call\
-                    `.{}()` instead",
-                    name, name
-                ),
-            ),
-            _ if map_arg.is_empty() => (
-                ITER_OVEREAGER_CLONED,
-                format!(
-                    "called `cloned().{}()` on an `Iterator`. It may be more efficient to call\
-                    `.{}().cloned()` instead",
-                    name, name
-                ),
-            ),
-            _ => (
-                ITER_OVEREAGER_CLONED,
-                format!(
-                    "called `cloned().{}(...)` on an `Iterator`. It may be more efficient to call\
-                    `.{}(...).cloned()` instead",
-                    name, name
-                ),
-            ),
-        };
+    let (lint, msg, preserve_clopned) = match name {
+        "count" => (REDUNDANT_CLONE, false),
+        _ => (ITER_OVEREAGER_CLONED, true),
+    };
+    let wildcard_params = map_arg.is_empty().not().then(|| "...").unwrap_or_default();
+    let msg = format!(
+        "called `cloned().{}({})` on an `Iterator`. It may be more efficient to call\
+                    `.{}({}){}` instead",
+        name,
+        wildcard_params,
+        name,
+        wildcard_params,
+        preserve_clopned.then(|| ".cloned()").unwrap_or_default(),
+    );
 
-        let iter_snippet = snippet(cx, recv.span, "..");
-        span_lint_and_sugg(
-            cx,
-            lint,
-            expr.span,
-            &msg,
-            "try this",
-            match name {
-                "count" => {
-                    format!("{}.{}()", iter_snippet, name)
-                },
-                _ if map_arg.is_empty() => {
-                    format!("{}.{}().cloned()", iter_snippet, name)
-                },
-                _ => {
-                    format!(
-                        "{}.{}({}).cloned()",
-                        iter_snippet,
-                        name,
-                        snippet(cx, map_arg[0].span, "..")
-                    )
-                },
-            },
-            Applicability::MachineApplicable,
-        );
-    }
+    let iter_snippet = snippet(cx, recv.span, "..");
+    span_lint_and_sugg(
+        cx,
+        lint,
+        expr.span,
+        &msg,
+        "try this",
+        format!(
+            "{}.{}({}){}",
+            iter_snippet,
+            name,
+            map_arg.iter().map(|a| snippet(cx, a.span, "..")).join(", "),
+            preserve_clopned.then(|| ".cloned()").unwrap_or_default(),
+        ),
+        Applicability::MachineApplicable,
+    );
 }

clippy_lints/src/methods/mod.rs

@@ -2302,6 +2302,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 string_extend_chars::check(cx, expr, recv, arg);
                 extend_with_drain::check(cx, expr, recv, arg);
             },
+            (name @ "filter", args @ []) => match method_call!(recv) {
+                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                _ => {},
+            },
             ("filter_map", [arg]) => {
                 unnecessary_filter_map::check(cx, expr, arg);
                 filter_map_identity::check(cx, expr, arg, span);