perf: skip redundant clone analysis for clone-free functions (#17486)

On master, `redundant_clone` requests optimized MIR for every function.
It turns out this is fairly expensive. This PR adds a pre-filter that
scans each function’s HIR first and skips MIR analysis _unless_ the body
contains a `.clone()`, `.to_owned()`, `.to_string()`, `.to_path_buf()`,
or `.to_os_string()` call. (It's just a pre-filter so false positives
are acceptable.)

Benchmarking on my M4, incremental Clippy checks in `codex-rs` went from
4.19 s to 3.98 s (~5% improvement). A more contrived workload (4,096
functions) went from 220 ms to 178 ms (~19% improvement).

changelog: none

Author: rustbot

clippy_lints/src/redundant_clone.rs

@@ -3,16 +3,18 @@ use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 use clippy_utils::res::MaybeDef as _;
 use clippy_utils::source::SpanExt as _;
 use clippy_utils::ty::{has_drop, is_copy, peel_and_count_ty_refs};
+use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{fn_has_unsatisfiable_clauses, sym};
 use rustc_errors::Applicability;
 use rustc_hir::attrs::lang_items::LangItem;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, def_id};
+use rustc_hir::{Body, ExprKind, FnDecl, def_id};
 use rustc_lint::{LateContext, LateLintPass, declare_lint_pass};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{BytePos, Span};
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -60,12 +62,13 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
         cx: &LateContext<'tcx>,
         _: FnKind<'tcx>,
         _: &'tcx FnDecl<'_>,
-        _: &'tcx Body<'_>,
+        body: &'tcx Body<'_>,
         _: Span,
         def_id: LocalDefId,
     ) {
+        // Closures receive their own `check_fn` callback and are checked separately.
         // Building MIR for `fn`s with unsatisfiable clauses results in ICE.
-        if fn_has_unsatisfiable_clauses(cx, def_id.to_def_id()) {
+        if !contains_clone_like_call(body) || fn_has_unsatisfiable_clauses(cx, def_id.to_def_id()) {
             return;
         }
 
@@ -244,6 +247,22 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
     }
 }
 
+fn contains_clone_like_call(body: &Body<'_>) -> bool {
+    for_each_expr_without_closures(body, |expr| {
+        if let ExprKind::MethodCall(method, ..) = expr.kind
+            && matches!(
+                method.ident.name,
+                sym::clone | sym::to_owned | sym::to_string | sym::to_path_buf | sym::to_os_string
+            )
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
+
 /// If `kind` is `y = func(x: &T)` where `T: !Copy`, returns `(DefId of func, x, T, y)`.
 fn is_call_with_ref_arg<'tcx>(
     cx: &LateContext<'tcx>,

tests/ui/redundant_clone.fixed

@@ -291,3 +291,25 @@ mod issue13900 {
         }
     }
 }
+
+mod hir_prefilter {
+    fn nested_closure() {
+        let _ = || {
+            let value = String::from("closure");
+            let _: String = value;
+            //~^ redundant_clone
+        };
+    }
+
+    macro_rules! identity {
+        ($expression:expr) => {
+            $expression
+        };
+    }
+
+    fn macro_expression() {
+        let value = String::from("macro");
+        let _ = identity!(value);
+        //~^ redundant_clone
+    }
+}

tests/ui/redundant_clone.rs

@@ -291,3 +291,25 @@ mod issue13900 {
         }
     }
 }
+
+mod hir_prefilter {
+    fn nested_closure() {
+        let _ = || {
+            let value = String::from("closure");
+            let _: String = value.clone();
+            //~^ redundant_clone
+        };
+    }
+
+    macro_rules! identity {
+        ($expression:expr) => {
+            $expression
+        };
+    }
+
+    fn macro_expression() {
+        let value = String::from("macro");
+        let _ = identity!(value.clone());
+        //~^ redundant_clone
+    }
+}

tests/ui/redundant_clone.stderr

@@ -180,5 +180,29 @@ note: this value is dropped without further use
 LL |     foo(&x.clone(), move || {
    |          ^
 
-error: aborting due to 15 previous errors
+error: redundant clone
+  --> tests/ui/redundant_clone.rs:299:34
+   |
+LL |             let _: String = value.clone();
+   |                                  ^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> tests/ui/redundant_clone.rs:299:29
+   |
+LL |             let _: String = value.clone();
+   |                             ^^^^^
+
+error: redundant clone
+  --> tests/ui/redundant_clone.rs:312:32
+   |
+LL |         let _ = identity!(value.clone());
+   |                                ^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> tests/ui/redundant_clone.rs:312:27
+   |
+LL |         let _ = identity!(value.clone());
+   |                           ^^^^^
+
+error: aborting due to 17 previous errors