tests/ui/matches.rs

   1 #![feature(exclusive_range_pattern)]
   2 #![warn(clippy::all)]
   3 #![allow(unused, clippy::redundant_pattern_matching)]
   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 #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 because of the 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 fn match_as_ref() {
 140     let owned: Option<()> = None;
 141     let borrowed: Option<&()> = match owned {
 142         None => None,
 143         Some(ref v) => Some(v),
 144     };
 145
 146     let mut mut_owned: Option<()> = None;
 147     let borrow_mut: Option<&mut ()> = match mut_owned {
 148         None => None,
 149         Some(ref mut v) => Some(v),
 150     };
 151 }
 152
 153 fn main() {}