matches: Peel subpatterns in bindings

Author: jubnzv

clippy_lints/src/matches.rs

@@ -862,8 +862,17 @@ fn contains_only_known_enums(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
     }
 }
 
+fn peel_subpatterns<'a>(pat: &'a Pat<'a>) -> &'a Pat<'a> {
+    if let PatKind::Binding(.., Some(sub)) = pat.kind {
+        return peel_subpatterns(sub);
+    }
+    pat
+}
+
 /// Returns true if the patterns exhaustively match an enum.
 fn check_exhaustive<'a>(cx: &LateContext<'a>, left: &Pat<'_>, right: &Pat<'_>, ty: Ty<'a>) -> bool {
+    let left = peel_subpatterns(left);
+    let right = peel_subpatterns(right);
     match (&left.kind, &right.kind) {
         (PatKind::Wild, _) | (_, PatKind::Wild) => true,
         (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
@@ -876,17 +885,13 @@ fn check_exhaustive<'a>(cx: &LateContext<'a>, left: &Pat<'_>, right: &Pat<'_>, t
             let are_structs_with_the_same_name =
                 || -> bool { cx.qpath_res(left_qpath, left.hir_id) == cx.qpath_res(right_qpath, right.hir_id) };
             let are_known_enums =
-                || -> bool { contains_only_known_enums(cx, left) && contains_only_known_enums(cx, right) };
+                || -> bool { contains_only_known_enums(cx, &left) && contains_only_known_enums(cx, &right) };
             if are_structs_with_the_same_name() || are_known_enums() {
                 return check_exhaustive_tuples(cx, left_in, left_pos, right_in, right_pos);
             }
             false
         },
-        (PatKind::Binding(.., None) | PatKind::Path(_), _)
-            if contains_only_wilds(right) =>
-        {
-            is_known_enum(cx, ty)
-        },
+        (PatKind::Binding(.., None) | PatKind::Path(_), _) if contains_only_wilds(&right) => is_known_enum(cx, ty),
         _ => false,
     }
 }
@@ -959,7 +964,7 @@ fn contains_only_wilds(pat: &Pat<'_>) -> bool {
 
 fn contains_single_binding(pat: &Pat<'_>) -> bool {
     match pat.kind {
-        PatKind::Binding(BindingAnnotation::Unannotated, .., None) => true,
+        PatKind::Binding(.., None) => true,
         PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_single_binding),
         _ => false,
     }

tests/ui/patterns.stderr

@@ -18,5 +18,16 @@ error: the `x @ _` pattern can be written as just `x`
 LL |         ref x @ _ => println!("vec: {:?}", x),
    |         ^^^^^^^^^ help: try: `ref x`
 
-error: aborting due to 3 previous errors
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/patterns.rs:8:5
+   |
+LL | /     match v {
+LL | |         Some(x) => (),
+LL | |         y @ _ => (),
+LL | |     }
+   | |_____^ help: try this: `if let Some(x) = v { () }`
+   |
+   = note: `-D clippy::single-match` implied by `-D warnings`
+
+error: aborting due to 4 previous errors
 

tests/ui/single_match.rs

@@ -222,6 +222,15 @@ fn annotated_bindings() {
     }
 }
 
+fn binding_subpatterns() {
+    struct S(i32);
+    let x = S(1);
+    match x {
+        S(aa @ 42) => {},
+        S(_) => {},
+    }
+}
+
 fn tuple_structs() {
     struct S(i32, i32);
     let s = S(1, 2);

tests/ui/single_match.stderr

@@ -183,7 +183,16 @@ LL | |     }
    | |_____^ help: try this: `if let Some(ref mut a) = Some(S(1i32)) {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:230:5
+  --> $DIR/single_match.rs:228:5
+   |
+LL | /     match x {
+LL | |         S(aa @ 42) => {},
+LL | |         S(_) => {},
+LL | |     }
+   | |_____^ help: try this: `if let S(aa @ 42) = x {}`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:239:5
    |
 LL | /     match s {
 LL | |         S(42, _a) => {},
@@ -192,13 +201,13 @@ LL | |     }
    | |_____^ help: try this: `if let S(42, _a) = s {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:236:5
+  --> $DIR/single_match.rs:245:5
    |
 LL | /     match s {
 LL | |         S(42, _a) => {},
 LL | |         S(..) => {},
 LL | |     }
    | |_____^ help: try this: `if let S(42, _a) = s {}`
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors