clean-up match_same_arms a bit

clippy_lints/src/matches/match_same_arms.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::{SpanlessEq, SpanlessHash, fulfill_or_allowed, is_lint_allowed, path_to_local, search_same};
+use clippy_utils::{SpanlessEq, fulfill_or_allowed, hash_expr, is_lint_allowed, path_to_local, search_same};
 use core::cmp::Ordering;
 use core::{iter, slice};
 use itertools::Itertools;
@@ -18,11 +18,7 @@ use super::MATCH_SAME_ARMS;
 
 #[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
-    let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-        let mut h = SpanlessHash::new(cx);
-        h.hash_expr(arm.body);
-        h.finish()
-    };
+    let hash = |&(_, arm): &(_, &Arm<'_>)| hash_expr(cx, arm.body);
 
     let arena = DroplessArena::default();
     let normalized_pats: Vec<_> = arms
@@ -35,9 +31,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            normalized_pats[i + 1..]
-                .iter()
-                .enumerate()
+            (normalized_pats[i + 1..].iter().enumerate())
                 .find_map(|(j, other)| pat.has_overlapping_values(other).then_some(i + 1 + j))
                 .unwrap_or(normalized_pats.len())
         })
@@ -48,16 +42,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            normalized_pats[..i]
-                .iter()
-                .enumerate()
-                .rev()
-                .zip(forwards_blocking_idxs[..i].iter().copied().rev())
-                .skip_while(|&(_, forward_block)| forward_block > i)
-                .find_map(|((j, other), forward_block)| {
-                    (forward_block == i || pat.has_overlapping_values(other)).then_some(j)
-                })
-                .unwrap_or(0)
+            iter::zip(
+                normalized_pats[..i].iter().enumerate().rev(),
+                forwards_blocking_idxs[..i].iter().copied().rev(),
+            )
+            .skip_while(|&(_, forward_block)| forward_block > i)
+            .find_map(|((j, other), forward_block)| {
+                (forward_block == i || pat.has_overlapping_values(other)).then_some(j)
+            })
+            .unwrap_or(0)
         })
         .collect();
 
@@ -158,12 +151,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                             .map(|(_, arm)| arm.pat.span.get_source_text(cx))
                             .collect::<Option<Vec<_>>>()
                     {
-                        let mut suggs = src
+                        let suggs = src
                             .iter()
                             .map(|(_, arm)| (adjusted_arm_span(cx, arm.span), String::new()))
+                            .chain([(dest.pat.span, pat_snippets.iter().join(" | "))])
                             .collect_vec();
 
-                        suggs.push((dest.pat.span, pat_snippets.iter().join(" | ")));
                         diag.multipart_suggestion_verbose(
                             "otherwise merge the patterns into a single arm",
                             suggs,
@@ -396,10 +389,7 @@ impl<'a> NormalizedPat<'a> {
                 if lpath != rpath {
                     return false;
                 }
-                lpats
-                    .iter()
-                    .zip(rpats.iter())
-                    .all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
+                iter::zip(lpats, rpats).all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
             },
             (Self::Path(x), Self::Path(y)) => x == y,
             (Self::LitStr(x), Self::LitStr(y)) => x == y,
@@ -409,7 +399,7 @@ impl<'a> NormalizedPat<'a> {
             (Self::Range(ref x), Self::Range(ref y)) => x.overlaps(y),
             (Self::Range(ref range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(ref range)) => range.contains(x),
             (Self::Slice(lpats, None), Self::Slice(rpats, None)) => {
-                lpats.len() == rpats.len() && lpats.iter().zip(rpats.iter()).all(|(x, y)| x.has_overlapping_values(y))
+                lpats.len() == rpats.len() && iter::zip(lpats, rpats).all(|(x, y)| x.has_overlapping_values(y))
             },
             (Self::Slice(pats, None), Self::Slice(front, Some(back)))
             | (Self::Slice(front, Some(back)), Self::Slice(pats, None)) => {
@@ -418,16 +408,12 @@ impl<'a> NormalizedPat<'a> {
                 if pats.len() < front.len() + back.len() {
                     return false;
                 }
-                pats[..front.len()]
-                    .iter()
-                    .zip(front.iter())
-                    .chain(pats[pats.len() - back.len()..].iter().zip(back.iter()))
+                iter::zip(&pats[..front.len()], front)
+                    .chain(iter::zip(&pats[pats.len() - back.len()..], back))
                     .all(|(x, y)| x.has_overlapping_values(y))
             },
-            (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => lfront
-                .iter()
-                .zip(rfront.iter())
-                .chain(lback.iter().rev().zip(rback.iter().rev()))
+            (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => iter::zip(lfront, rfront)
+                .chain(iter::zip(lback.iter().rev(), rback.iter().rev()))
                 .all(|(x, y)| x.has_overlapping_values(y)),
 
             // Enums can mix unit variants with tuple/struct variants. These can never overlap.