Revert unrolling and use inspect

Author: smoelius

clippy_lints/src/dereference.rs

@@ -17,8 +17,8 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
-    self, subst::Subst, EarlyBinder, FnSig, ParamTy, PredicateKind, ProjectionPredicate, TraitPredicate, TraitRef, Ty,
-    TyCtxt, TypeVisitable, TypeckResults,
+    self, subst::Subst, EarlyBinder, FnSig, ParamTy, PredicateKind, ProjectionPredicate, Ty, TyCtxt, TypeVisitable,
+    TypeckResults,
 };
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol};
@@ -985,20 +985,24 @@ fn needless_borrow_impl_arg_position<'tcx>(
     let mut trait_with_ref_mut_self_method = false;
 
     // If no traits were found, or only the `Sized` or `Any` traits were found, return.
-    if predicates.iter().all(|predicate| {
-        if let PredicateKind::Trait(TraitPredicate {
-            trait_ref: TraitRef {
-                def_id: trait_def_id, ..
-            },
-            ..
-        }) = predicate.kind().skip_binder()
-        {
-            trait_with_ref_mut_self_method |= has_ref_mut_self_method(cx, trait_def_id);
+    if predicates
+        .iter()
+        .filter_map(|predicate| {
+            if let PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && trait_predicate.trait_ref.self_ty() == param_ty.to_ty(cx.tcx)
+            {
+                Some(trait_predicate.trait_ref.def_id)
+            } else {
+                None
+            }
+        })
+        .inspect(|trait_def_id| {
+            trait_with_ref_mut_self_method |= has_ref_mut_self_method(cx, *trait_def_id);
+        })
+        .all(|trait_def_id| {
             Some(trait_def_id) == sized_trait_def_id || cx.tcx.is_diagnostic_item(sym::Any, trait_def_id)
-        } else {
-            true
-        }
-    }) {
+        })
+    {
         return Position::Other(precedence);
     }
 
@@ -1083,55 +1087,41 @@ fn replace_types<'tcx>(
     substs: &mut [ty::GenericArg<'tcx>],
 ) -> bool {
     let mut replaced = BitSet::new_empty(substs.len());
-    let mut deque = VecDeque::with_capacity(substs.len());
-
-    if fn_sig
-        .inputs_and_output
-        .iter()
-        .enumerate()
-        .any(|(i, ty)| i != arg_index && contains_ty(ty, param_ty.to_ty(cx.tcx)))
-    {
-        return false;
-    }
-
-    substs[param_ty.index as usize] = ty::GenericArg::from(new_ty);
 
+    let mut deque = VecDeque::with_capacity(substs.len());
     deque.push_back((param_ty, new_ty));
 
     while let Some((param_ty, new_ty)) = deque.pop_front() {
-        for projection_predicate in projection_predicates {
-            if projection_predicate.projection_ty.self_ty() == param_ty.to_ty(cx.tcx)
-                && let ty::Term::Ty(term_ty) = projection_predicate.term
-                && let ty::Param(term_param_ty) = term_ty.kind()
-            {
-                let item_def_id = projection_predicate.projection_ty.item_def_id;
-                let assoc_item = cx.tcx.associated_item(item_def_id);
-                let projection = cx.tcx
-                    .mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, &[]));
-                let projected_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection);
-
-                let inserted = replaced.insert(term_param_ty.index);
-
-                let new_generic_arg = ty::GenericArg::from(projected_ty);
-
-                if substs[term_param_ty.index as usize] == new_generic_arg {
-                    continue;
-                }
+        let new_generic_arg = ty::GenericArg::from(new_ty);
+
+        // If `replaced.is_empty()`, then `param_ty` and `new_ty` are those initially passed in.
+        if substs[param_ty.index as usize] != new_generic_arg
+            && !fn_sig
+                .inputs_and_output
+                .iter()
+                .enumerate()
+                .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !contains_ty(ty, param_ty.to_ty(cx.tcx)))
+        {
+            return false;
+        }
 
-                // The next line provides some protection against infinite loops.
-                assert!(inserted);
+        substs[param_ty.index as usize] = new_generic_arg;
 
-                if fn_sig
-                    .inputs_and_output
-                    .iter()
-                    .any(|ty| contains_ty(ty, term_param_ty.to_ty(cx.tcx)))
+        // The `replaced.insert(...)` check provides some protection against infinite loops.
+        if replaced.insert(param_ty.index) {
+            for projection_predicate in projection_predicates {
+                if projection_predicate.projection_ty.self_ty() == param_ty.to_ty(cx.tcx)
+                    && let ty::Term::Ty(term_ty) = projection_predicate.term
+                    && let ty::Param(term_param_ty) = term_ty.kind()
                 {
-                    return false;
-                }
+                    let item_def_id = projection_predicate.projection_ty.item_def_id;
+                    let assoc_item = cx.tcx.associated_item(item_def_id);
+                    let projection = cx.tcx
+                        .mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, &[]));
+                    let projected_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection);
 
-                substs[term_param_ty.index as usize] = new_generic_arg;
-
-                deque.push_back((*term_param_ty, projected_ty));
+                    deque.push_back((*term_param_ty, projected_ty));
+                }
             }
         }
     }