refactor(search_is_some): Move some logic for transforming closures

The lint `search_is_some` involves converting a closure that takes the
reference into one that takes the value.  The code is split between the
function for the lint and a shared function.  The new feature that we
are adding involves the same transformation.  To do so it needs some of
the same code that is currently in the `search_is_some` lint.  So it is
moved from the lint into the shared function.

Before this patch, line 799 in the file `clippy_utils/src/sugg.rs` had a
check.  It made the function return none in case the closure did not
dereference the argument.  However, the code for the lint
`search_is_some` would then fall back to using the original closure.
That achieved the same effect as the check not existing.  So the check
is now removed.

Author: ceptontech

clippy_lints/src/methods/search_is_some.rs

@@ -2,11 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::deref_closure_args;
-use clippy_utils::{is_receiver_of_method_call, strip_pat_refs, sym};
-use hir::ExprKind;
+use clippy_utils::{is_receiver_of_method_call, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::PatKind;
 use rustc_lint::LateContext;
 use rustc_span::{Span, Symbol};
 
@@ -34,25 +32,15 @@ pub(super) fn check<'tcx>(
     {
         let msg = format!("called `{option_check_method}()` after searching an `Iterator` with `{search_method}`");
         let search_snippet = snippet(cx, search_arg.span, "..");
+        // `find()` provides a reference to the item, but `any` does not, so we
+        // should fix item usages for suggestion
         // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
         // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
         let mut applicability = Applicability::MachineApplicable;
-        let any_search_snippet = if search_method == sym::find
-            && let ExprKind::Closure(&hir::Closure { body, .. }) = search_arg.kind
-            && let closure_body = cx.tcx.hir_body(body)
-            && let Some(closure_arg) = closure_body.params.first()
-        {
-            if let PatKind::Ref(..) = closure_arg.pat.kind {
-                Some(search_snippet.replacen('&', "", 1))
-            } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
-                // `find()` provides a reference to the item, but `any` does not,
-                // so we should fix item usages for suggestion
-                if let Some(closure_sugg) = deref_closure_args(cx, search_arg) {
-                    applicability = closure_sugg.applicability;
-                    Some(closure_sugg.suggestion)
-                } else {
-                    Some(search_snippet.to_string())
-                }
+        let any_search_snippet = if search_method == sym::find {
+            if let Some(closure_sugg) = deref_closure_args(cx, search_arg) {
+                applicability = closure_sugg.applicability;
+                Some(closure_sugg.suggestion)
             } else {
                 None
             }

clippy_utils/src/sugg.rs

@@ -3,12 +3,12 @@
 
 use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_context};
 use crate::ty::expr_sig;
-use crate::{get_parent_expr_for_hir, higher};
+use crate::{get_parent_expr_for_hir, higher, strip_pat_refs};
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{UnOp, ast};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, Closure, ExprKind, HirId, MutTy, Node, TyKind};
+use rustc_hir::{self as hir, Closure, ExprKind, HirId, MutTy, Node, PatKind, TyKind};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_lint::{EarlyContext, LateContext, LintContext};
 use rustc_middle::hir::place::ProjectionKind;
@@ -770,8 +770,22 @@ pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Opti
     if let ExprKind::Closure(&Closure {
         fn_decl, def_id, body, ..
     }) = closure.kind
+        && let closure_body = cx.tcx.hir_body(body)
+        && let [closure_arg] = closure_body.params
     {
-        let closure_body = cx.tcx.hir_body(body);
+        // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
+        if matches!(closure_arg.pat.kind, PatKind::Ref(..)) {
+            let mut applicability = Applicability::MachineApplicable;
+            let suggestion =
+                snippet_with_applicability(cx, closure.span, "..", &mut applicability).replacen('&', "", 1);
+            return Some(DerefClosure {
+                applicability,
+                suggestion,
+            });
+        }
+        if !matches!(strip_pat_refs(closure_arg.pat).kind, PatKind::Binding(..)) {
+            return None;
+        }
         // is closure arg a type annotated double reference (i.e.: `|x: &&i32| ...`)
         // a type annotation is present if param `kind` is different from `TyKind::Infer`
         let closure_arg_is_type_annotated_double_ref = if let TyKind::Ref(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind
@@ -796,12 +810,10 @@ pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Opti
             .consume_body(closure_body)
             .into_ok();
 
-        if !visitor.suggestion_start.is_empty() {
-            return Some(DerefClosure {
-                applicability: visitor.applicability,
-                suggestion: visitor.finish(),
-            });
-        }
+        return Some(DerefClosure {
+            applicability: visitor.applicability,
+            suggestion: visitor.finish(),
+        });
     }
     None
 }

clippy_utils/src/sym.rs

@@ -198,6 +198,7 @@ generate! {
     is_none,
     is_none_or,
     is_ok,
+    is_ok_and,
     is_partitioned,
     is_some,
     is_some_and,