Simplify predicate handling code

Author: smoelius

clippy_lints/src/dereference.rs

@@ -947,7 +947,6 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 // If the conditions are met, returns `Some(Position::ImplArg(..))`; otherwise, returns `None`.
 //   The "is copyable" condition is to avoid the case where removing the `&` means `e` would have to
 // be moved, but it cannot be.
-#[expect(clippy::too_many_lines)]
 fn needless_borrow_impl_arg_position<'tcx>(
     cx: &LateContext<'tcx>,
     parent: &Expr<'tcx>,
@@ -959,7 +958,6 @@ fn needless_borrow_impl_arg_position<'tcx>(
     let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
 
     let Some(callee_def_id) = fn_def_id(cx, parent) else { return Position::Other(precedence) };
-    let callee_generics = cx.tcx.generics_of(callee_def_id);
     let substs_with_expr_ty = cx
         .typeck_results()
         .node_substs(if let ExprKind::Call(callee, _) = parent.kind {
@@ -1032,54 +1030,29 @@ fn needless_borrow_impl_arg_position<'tcx>(
             return false;
         }
 
-        let substs_with_expr_ty = substs_with_expr_ty.split_at(callee_generics.parent_count);
-        let substs_with_referent_ty = substs_with_expr_ty
-            .0
-            .iter()
-            .copied()
-            .chain(
-                callee_generics
-                    .params
-                    .iter()
-                    .zip(substs_with_expr_ty.1.iter())
-                    .map(|(param, arg)| {
-                        if param.index == param_ty.index {
-                            ty::GenericArg::from(referent_ty)
-                        } else {
-                            projection_predicates
-                                .iter()
-                                .find_map(|projection_predicate| {
-                                    if let ty::Term::Ty(term_ty) = projection_predicate.term
-                                        && term_ty.is_param(param.index)
-                                    {
-                                        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(referent_ty, &[]));
-                                        let projected_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection);
-                                        Some(ty::GenericArg::from(projected_ty))
-                                    } else {
-                                        None
-                                    }
-                                })
-                                .unwrap_or(*arg)
-                        }
-                    }),
-            )
-            .collect::<Vec<_>>();
+        let mut substs_with_referent_ty = substs_with_expr_ty.to_vec();
+        substs_with_referent_ty[param_ty.index as usize] = ty::GenericArg::from(referent_ty);
+        for projection_predicate in &projection_predicates {
+            if 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(referent_ty, &[]));
+                let projected_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection);
+                substs_with_referent_ty[term_param_ty.index as usize] = ty::GenericArg::from(projected_ty);
+            }
+        }
 
-        let predicates = EarlyBinder(predicates).subst(cx.tcx, &substs_with_referent_ty);
-        if !predicates.iter().all(|predicate| {
+        predicates.iter().all(|predicate| {
+            let predicate = EarlyBinder(predicate).subst(cx.tcx, &substs_with_referent_ty);
             let obligation = Obligation::new(ObligationCause::dummy(), cx.param_env, predicate);
             cx.tcx
                 .infer_ctxt()
                 .enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
-        }) {
-            return false;
-        }
-
-        true
+        })
     };
 
     let mut needless_borrow = false;