style: use zip-the-function all over the place

makes the code a bit more concise by removing the need for explicit
`.iter()`

Author: ada4a

clippy_utils/src/lib.rs

@@ -84,7 +84,7 @@ pub use self::hir_utils::{
 use core::mem;
 use core::ops::ControlFlow;
 use std::collections::hash_map::Entry;
-use std::iter::{once, repeat_n};
+use std::iter::{once, repeat_n, zip};
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use itertools::Itertools;
@@ -581,7 +581,7 @@ pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -
         return false;
     }
 
-    for (x1, x2) in s1.iter().zip(s2.iter()) {
+    for (x1, x2) in zip(&s1, &s2) {
         if expr_custom_deref_adjustment(cx, x1).is_some() || expr_custom_deref_adjustment(cx, x2).is_some() {
             return false;
         }
@@ -1923,24 +1923,20 @@ fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
             (PatKind::Tuple(pats, dotdot), ExprKind::Tup(tup))
                 if dotdot.as_opt_usize().is_none() && pats.len() == tup.len() =>
             {
-                pats.iter().zip(tup).all(|(pat, expr)| check_pat(cx, pat, expr))
+                zip(pats, tup).all(|(pat, expr)| check_pat(cx, pat, expr))
             },
             (PatKind::Slice(before, slice, after), ExprKind::Array(arr))
                 if slice.is_none() && before.len() + after.len() == arr.len() =>
             {
-                (before.iter().chain(after))
-                    .zip(arr)
-                    .all(|(pat, expr)| check_pat(cx, pat, expr))
+                zip(before.iter().chain(after), arr).all(|(pat, expr)| check_pat(cx, pat, expr))
             },
             (PatKind::TupleStruct(pat_ident, field_pats, dotdot), ExprKind::Call(ident, fields))
                 if dotdot.as_opt_usize().is_none()
                     && let ExprKind::Path(ident) = ident.kind =>
             {
                 field_pats.len() == fields.len()
                     && qpath_res(&pat_ident, pat.hir_id) == qpath_res(&ident, expr.hir_id)
-                    && (field_pats.iter())
-                        .zip(fields)
-                        .all(|(pat, expr)| check_pat(cx, pat, expr))
+                    && zip(field_pats, fields).all(|(pat, expr)| check_pat(cx, pat, expr))
             },
             (
                 PatKind::Struct(pat_ident, field_pats, false),