tests/ui/matches.rs

   1
   2 #![feature(exclusive_range_pattern)]
   3
   4
   5 #![warn(clippy)]
   6 #![allow(unused, if_let_redundant_pattern_matching)]
   7 #![warn(single_match_else, match_same_arms)]
   8
   9 enum ExprNode {
  10     ExprAddrOf,
  11     Butterflies,
  12     Unicorns,
  13 }
  14
  15 static NODE: ExprNode = ExprNode::Unicorns;
  16
  17 fn dummy() {
  18 }
  19
  20 fn unwrap_addr() -> Option<&'static ExprNode> {
  21     match ExprNode::Butterflies {
  22         ExprNode::ExprAddrOf => Some(&NODE),
  23         _ => { let x = 5; None },
  24     }
  25 }
  26
  27 fn ref_pats() {
  28     {
  29         let v = &Some(0);
  30         match v {
  31             &Some(v) => println!("{:?}", v),
  32             &None => println!("none"),
  33         }
  34         match v {  // this doesn't trigger, we have a different pattern
  35             &Some(v) => println!("some"),
  36             other => println!("other"),
  37         }
  38     }
  39     let tup =& (1, 2);
  40     match tup {
  41         &(v, 1) => println!("{}", v),
  42         _ => println!("none"),
  43     }
  44     // special case: using & both in expr and pats
  45     let w = Some(0);
  46     match &w {
  47         &Some(v) => println!("{:?}", v),
  48         &None => println!("none"),
  49     }
  50     // false positive: only wildcard pattern
  51     let w = Some(0);
  52     match w {
  53         _ => println!("none"),
  54     }
  55
  56     let a = &Some(0);
  57     if let &None = a {
  58         println!("none");
  59     }
  60
  61     let b = Some(0);
  62     if let &None = &b {
  63         println!("none");
  64     }
  65 }
  66
  67 fn overlapping() {
  68     const FOO : u64 = 2;
  69
  70     match 42 {
  71         0 ... 10 => println!("0 ... 10"),
  72         0 ... 11 => println!("0 ... 11"),
  73         _ => (),
  74     }
  75
  76     match 42 {
  77         0 ... 5 => println!("0 ... 5"),
  78         6 ... 7 => println!("6 ... 7"),
  79         FOO ... 11 => println!("0 ... 11"),
  80         _ => (),
  81     }
  82
  83     match 42 {
  84         2 => println!("2"),
  85         0 ... 5 => println!("0 ... 5"),
  86         _ => (),
  87     }
  88
  89     match 42 {
  90         2 => println!("2"),
  91         0 ... 2 => println!("0 ... 2"),
  92         _ => (),
  93     }
  94
  95     match 42 {
  96         0 ... 10 => println!("0 ... 10"),
  97         11 ... 50 => println!("11 ... 50"),
  98         _ => (),
  99     }
 100
 101     match 42 {
 102         2 => println!("2"),
 103         0 .. 2 => println!("0 .. 2"),
 104         _ => (),
 105     }
 106
 107     match 42 {
 108         0 .. 10 => println!("0 .. 10"),
 109         10 .. 50 => println!("10 .. 50"),
 110         _ => (),
 111     }
 112
 113     match 42 {
 114         0 .. 11 => println!("0 .. 11"),
 115         0 ... 11 => println!("0 ... 11"),
 116         _ => (),
 117     }
 118
 119     if let None = Some(42) {
 120         // nothing
 121     } else if let None = Some(42) {
 122         // another nothing :-)
 123     }
 124 }
 125
 126 fn match_wild_err_arm() {
 127     let x: Result<i32, &str> = Ok(3);
 128
 129     match x {
 130         Ok(3) => println!("ok"),
 131         Ok(_) => println!("ok"),
 132         Err(_) => panic!("err")
 133     }
 134
 135     match x {
 136         Ok(3) => println!("ok"),
 137         Ok(_) => println!("ok"),
 138         Err(_) => {panic!()}
 139     }
 140
 141     match x {
 142         Ok(3) => println!("ok"),
 143         Ok(_) => println!("ok"),
 144         Err(_) => {panic!();}
 145     }
 146
 147     // allowed when not with `panic!` block
 148     match x {
 149         Ok(3) => println!("ok"),
 150         Ok(_) => println!("ok"),
 151         Err(_) => println!("err")
 152     }
 153
 154     // allowed when used with `unreachable!`
 155     match x {
 156         Ok(3) => println!("ok"),
 157         Ok(_) => println!("ok"),
 158         Err(_) => {unreachable!()}
 159     }
 160
 161     match x {
 162         Ok(3) => println!("ok"),
 163         Ok(_) => println!("ok"),
 164         Err(_) => unreachable!()
 165     }
 166
 167     match x {
 168         Ok(3) => println!("ok"),
 169         Ok(_) => println!("ok"),
 170         Err(_) => {unreachable!();}
 171     }
 172
 173     // no warning because of the guard
 174     match x {
 175         Ok(x) if x*x == 64 => println!("ok"),
 176         Ok(_) => println!("ok"),
 177         Err(_) => println!("err")
 178     }
 179
 180     // this used to be a false positive, see #1996
 181     match x {
 182         Ok(3) => println!("ok"),
 183         Ok(x) if x*x == 64 => println!("ok 64"),
 184         Ok(_) => println!("ok"),
 185         Err(_) => println!("err")
 186     }
 187
 188     match (x, Some(1i32)) {
 189         (Ok(x), Some(_)) => println!("ok {}", x),
 190         (Ok(_), Some(x)) => println!("ok {}", x),
 191         _ => println!("err")
 192     }
 193
 194     // no warning because of the different types for x
 195     match (x, Some(1.0f64)) {
 196         (Ok(x), Some(_)) => println!("ok {}", x),
 197         (Ok(_), Some(x)) => println!("ok {}", x),
 198         _ => println!("err")
 199     }
 200
 201     // because of a bug, no warning was generated for this case before #2251
 202     match x {
 203         Ok(_tmp) => println!("ok"),
 204         Ok(3) => println!("ok"),
 205         Ok(_) => println!("ok"),
 206         Err(_) => {unreachable!();}
 207     }
 208 }
 209
 210 fn match_as_ref() {
 211     let owned: Option<()> = None;
 212     let borrowed: Option<&()> = match owned {
 213         None => None,
 214         Some(ref v) => Some(v),
 215     };
 216
 217     let mut mut_owned: Option<()> = None;
 218     let borrow_mut: Option<&mut ()> = match mut_owned {
 219         None => None,
 220         Some(ref mut v) => Some(v),
 221     };
 222
 223 }
 224
 225 fn main() {
 226 }