tests/ui/matches.rs

   1 #![feature(exclusive_range_pattern)]
   2 #![warn(clippy::all)]
   3 #![allow(unused, clippy::redundant_pattern_matching, clippy::too_many_lines)]
   4 #![warn(clippy::match_same_arms)]
   5
   6 fn dummy() {}
   7
   8 fn ref_pats() {
   9     {
  10         let v = &Some(0);
  11         match v {
  12             &Some(v) => println!("{:?}", v),
  13             &None => println!("none"),
  14         }
  15         match v {
  16             // This doesn't trigger; we have a different pattern.
  17             &Some(v) => println!("some"),
  18             other => println!("other"),
  19         }
  20     }
  21     let tup = &(1, 2);
  22     match tup {
  23         &(v, 1) => println!("{}", v),
  24         _ => println!("none"),
  25     }
  26     // Special case: using `&` both in expr and pats.
  27     let w = Some(0);
  28     match &w {
  29         &Some(v) => println!("{:?}", v),
  30         &None => println!("none"),
  31     }
  32     // False positive: only wildcard pattern.
  33     let w = Some(0);
  34     match w {
  35         _ => println!("none"),
  36     }
  37
  38     let a = &Some(0);
  39     if let &None = a {
  40         println!("none");
  41     }
  42
  43     let b = Some(0);
  44     if let &None = &b {
  45         println!("none");
  46     }
  47 }
  48
  49 fn match_wild_err_arm() {
  50     let x: Result<i32, &str> = Ok(3);
  51
  52     match x {
  53         Ok(3) => println!("ok"),
  54         Ok(_) => println!("ok"),
  55         Err(_) => panic!("err"),
  56     }
  57
  58     match x {
  59         Ok(3) => println!("ok"),
  60         Ok(_) => println!("ok"),
  61         Err(_) => panic!(),
  62     }
  63
  64     match x {
  65         Ok(3) => println!("ok"),
  66         Ok(_) => println!("ok"),
  67         Err(_) => {
  68             panic!();
  69         },
  70     }
  71
  72     // Allowed when not with `panic!` block.
  73     match x {
  74         Ok(3) => println!("ok"),
  75         Ok(_) => println!("ok"),
  76         Err(_) => println!("err"),
  77     }
  78
  79     // Allowed when used with `unreachable!`.
  80     match x {
  81         Ok(3) => println!("ok"),
  82         Ok(_) => println!("ok"),
  83         Err(_) => unreachable!(),
  84     }
  85
  86     match x {
  87         Ok(3) => println!("ok"),
  88         Ok(_) => println!("ok"),
  89         Err(_) => unreachable!(),
  90     }
  91
  92     match x {
  93         Ok(3) => println!("ok"),
  94         Ok(_) => println!("ok"),
  95         Err(_) => {
  96             unreachable!();
  97         },
  98     }
  99
 100     // No warning because of the guard.
 101     match x {
 102         Ok(x) if x * x == 64 => println!("ok"),
 103         Ok(_) => println!("ok"),
 104         Err(_) => println!("err"),
 105     }
 106
 107     // This used to be a false positive; see issue #1996.
 108     match x {
 109         Ok(3) => println!("ok"),
 110         Ok(x) if x * x == 64 => println!("ok 64"),
 111         Ok(_) => println!("ok"),
 112         Err(_) => println!("err"),
 113     }
 114
 115     match (x, Some(1i32)) {
 116         (Ok(x), Some(_)) => println!("ok {}", x),
 117         (Ok(_), Some(x)) => println!("ok {}", x),
 118         _ => println!("err"),
 119     }
 120
 121     // No warning; different types for `x`.
 122     match (x, Some(1.0f64)) {
 123         (Ok(x), Some(_)) => println!("ok {}", x),
 124         (Ok(_), Some(x)) => println!("ok {}", x),
 125         _ => println!("err"),
 126     }
 127
 128     // Because of a bug, no warning was generated for this case before #2251.
 129     match x {
 130         Ok(_tmp) => println!("ok"),
 131         Ok(3) => println!("ok"),
 132         Ok(_) => println!("ok"),
 133         Err(_) => {
 134             unreachable!();
 135         },
 136     }
 137 }
 138
 139 macro_rules! foo_variant(
 140     ($idx:expr) => (Foo::get($idx).unwrap())
 141 );
 142
 143 enum Foo {
 144     A,
 145     B,
 146 }
 147
 148 impl Foo {
 149     fn get(idx: u8) -> Option<&'static Self> {
 150         match idx {
 151             0 => Some(&Foo::A),
 152             1 => Some(&Foo::B),
 153             _ => None,
 154         }
 155     }
 156 }
 157
 158 fn main() {
 159     // ICE #3719
 160     match foo_variant!(0) {
 161         &Foo::A => println!("A"),
 162         _ => println!("Wild"),
 163     }
 164 }