Fix `match_same_arms` false negative

[rust.git] / clippy_lints / src / copies.rs

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index d85cf97a6bdde3380b8e746ab3f3cce852a15ae1..3894b56c0494b0775d89dff5214f316bab6a40d3 100644 (file)
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,4 +1,6 @@
-use crate::utils::{get_parent_expr, higher, in_macro_or_desugar, snippet, span_lint_and_then, span_note_and_lint};
+use crate::utils::{
+    get_parent_expr, higher, in_macro_or_desugar, same_tys, snippet, span_lint_and_then, span_note_and_lint,
+};
 use crate::utils::{SpanlessEq, SpanlessHash};
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -152,7 +154,7 @@ fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr]) {
     let eq: &dyn Fn(&&Expr, &&Expr) -> bool =
         &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, rhs) };
 
-    if let Some((i, j)) = search_same(conds, hash, eq) {
+    for (i, j) in search_same(conds, hash, eq) {
         span_note_and_lint(
             cx,
             IFS_SAME_COND,
@@ -165,7 +167,18 @@ fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr]) {
 }
 
 /// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
+fn lint_match_arms<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &Expr) {
+    fn same_bindings<'tcx>(
+        cx: &LateContext<'_, 'tcx>,
+        lhs: &FxHashMap<LocalInternedString, Ty<'tcx>>,
+        rhs: &FxHashMap<LocalInternedString, Ty<'tcx>>,
+    ) -> bool {
+        lhs.len() == rhs.len()
+            && lhs
+                .iter()
+                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| same_tys(cx, l_ty, r_ty)))
+    }
+
     if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.node {
         let hash = |&(_, arm): &(usize, &Arm)| -> u64 {
             let mut h = SpanlessHash::new(cx, cx.tables);
@@ -176,16 +189,17 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
         let eq = |&(lindex, lhs): &(usize, &Arm), &(rindex, rhs): &(usize, &Arm)| -> bool {
             let min_index = usize::min(lindex, rindex);
             let max_index = usize::max(lindex, rindex);
+
             // Arms with a guard are ignored, those can’t always be merged together
             // This is also the case for arms in-between each there is an arm with a guard
             (min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
                 SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
                 // all patterns should have the same bindings
-                bindings(cx, &lhs.pats[0]) == bindings(cx, &rhs.pats[0])
+                same_bindings(cx, &bindings(cx, &lhs.pats[0]), &bindings(cx, &rhs.pats[0]))
         };
 
         let indexed_arms: Vec<(usize, &Arm)> = arms.iter().enumerate().collect();
-        if let Some((&(_, i), &(_, j))) = search_same(&indexed_arms, hash, eq) {
+        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
             span_lint_and_then(
                 cx,
                 MATCH_SAME_ARMS,
@@ -217,7 +231,10 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
                                 ),
                             );
                         } else {
-                            db.span_note(i.body.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
+                            db.span_help(
+                                i.pats[0].span,
+                                &format!("consider refactoring into `{} | {}`", lhs, rhs),
+                            );
                         }
                     }
                 },
@@ -323,22 +340,34 @@ fn search_same_sequenced<T, Eq>(exprs: &[T], eq: Eq) -> Option<(&T, &T)>
     None
 }
 
-fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
+fn search_common_cases<'a, T, Eq>(exprs: &'a [T], eq: &Eq) -> Option<(&'a T, &'a T)>
 where
-    Hash: Fn(&T) -> u64,
     Eq: Fn(&T, &T) -> bool,
 {
-    // common cases
     if exprs.len() < 2 {
-        return None;
+        None
     } else if exprs.len() == 2 {
-        return if eq(&exprs[0], &exprs[1]) {
+        if eq(&exprs[0], &exprs[1]) {
             Some((&exprs[0], &exprs[1]))
         } else {
             None
-        };
+        }
+    } else {
+        None
+    }
+}
+
+fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
+where
+    Hash: Fn(&T) -> u64,
+    Eq: Fn(&T, &T) -> bool,
+{
+    if let Some(expr) = search_common_cases(&exprs, &eq) {
+        return vec![expr];
     }
 
+    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
+
     let mut map: FxHashMap<_, Vec<&_>> =
         FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
 
@@ -347,7 +376,7 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
             Entry::Occupied(mut o) => {
                 for o in o.get() {
                     if eq(o, expr) {
-                        return Some((o, expr));
+                        match_expr_list.push((o, expr));
                     }
                 }
                 o.get_mut().push(expr);
@@ -358,5 +387,5 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
         }
     }
 
-    None
+    match_expr_list
 }