tests/ui/copies.rs

   1 #![allow(blacklisted_name, collapsible_if, cyclomatic_complexity, eq_op, needless_continue,
   2          needless_return, never_loop, no_effect, zero_divided_by_zero)]
   3
   4 fn bar<T>(_: T) {}
   5 fn foo() -> bool { unimplemented!() }
   6
   7 struct Foo {
   8     bar: u8,
   9 }
  10
  11 pub enum Abc {
  12     A,
  13     B,
  14     C,
  15 }
  16
  17 #[warn(if_same_then_else)]
  18 #[warn(match_same_arms)]
  19 fn if_same_then_else() -> Result<&'static str, ()> {
  20     if true {
  21         Foo { bar: 42 };
  22         0..10;
  23         ..;
  24         0..;
  25         ..10;
  26         0..=10;
  27         foo();
  28     }
  29     else { //~ ERROR same body as `if` block
  30         Foo { bar: 42 };
  31         0..10;
  32         ..;
  33         0..;
  34         ..10;
  35         0..=10;
  36         foo();
  37     }
  38
  39     if true {
  40         Foo { bar: 42 };
  41     }
  42     else {
  43         Foo { bar: 43 };
  44     }
  45
  46     if true {
  47         ();
  48     }
  49     else {
  50         ()
  51     }
  52
  53     if true {
  54         0..10;
  55     }
  56     else {
  57         0..=10;
  58     }
  59
  60     if true {
  61         foo();
  62         foo();
  63     }
  64     else {
  65         foo();
  66     }
  67
  68     let _ = match 42 {
  69         42 => {
  70             foo();
  71             let mut a = 42 + [23].len() as i32;
  72             if true {
  73                 a += 7;
  74             }
  75             a = -31-a;
  76             a
  77         }
  78         _ => { //~ ERROR match arms have same body
  79             foo();
  80             let mut a = 42 + [23].len() as i32;
  81             if true {
  82                 a += 7;
  83             }
  84             a = -31-a;
  85             a
  86         }
  87     };
  88
  89     let _ = match Abc::A {
  90         Abc::A => 0,
  91         Abc::B => 1,
  92         _ => 0, //~ ERROR match arms have same body
  93     };
  94
  95     if true {
  96         foo();
  97     }
  98
  99     let _ = if true {
 100         42
 101     }
 102     else { //~ ERROR same body as `if` block
 103         42
 104     };
 105
 106     if true {
 107         for _ in &[42] {
 108             let foo: &Option<_> = &Some::<u8>(42);
 109             if true {
 110                 break;
 111             } else {
 112                 continue;
 113             }
 114         }
 115     }
 116     else { //~ ERROR same body as `if` block
 117         for _ in &[42] {
 118             let foo: &Option<_> = &Some::<u8>(42);
 119             if true {
 120                 break;
 121             } else {
 122                 continue;
 123             }
 124         }
 125     }
 126
 127     if true {
 128         let bar = if true {
 129             42
 130         }
 131         else {
 132             43
 133         };
 134
 135         while foo() { break; }
 136         bar + 1;
 137     }
 138     else { //~ ERROR same body as `if` block
 139         let bar = if true {
 140             42
 141         }
 142         else {
 143             43
 144         };
 145
 146         while foo() { break; }
 147         bar + 1;
 148     }
 149
 150     if true {
 151         let _ = match 42 {
 152             42 => 1,
 153             a if a > 0 => 2,
 154             10..=15 => 3,
 155             _ => 4,
 156         };
 157     }
 158     else if false {
 159         foo();
 160     }
 161     else if foo() {
 162         let _ = match 42 {
 163             42 => 1,
 164             a if a > 0 => 2,
 165             10..=15 => 3,
 166             _ => 4,
 167         };
 168     }
 169
 170     if true {
 171         if let Some(a) = Some(42) {}
 172     }
 173     else { //~ ERROR same body as `if` block
 174         if let Some(a) = Some(42) {}
 175     }
 176
 177     if true {
 178         if let (1, .., 3) = (1, 2, 3) {}
 179     }
 180     else { //~ ERROR same body as `if` block
 181         if let (1, .., 3) = (1, 2, 3) {}
 182     }
 183
 184     if true {
 185         if let (1, .., 3) = (1, 2, 3) {}
 186     }
 187     else {
 188         if let (.., 3) = (1, 2, 3) {}
 189     }
 190
 191     if true {
 192         if let (1, .., 3) = (1, 2, 3) {}
 193     }
 194     else {
 195         if let (.., 4) = (1, 2, 3) {}
 196     }
 197
 198     if true {
 199         if let (1, .., 3) = (1, 2, 3) {}
 200     }
 201     else {
 202         if let (.., 1, 3) = (1, 2, 3) {}
 203     }
 204
 205     if true {
 206         if let Some(42) = None {}
 207     }
 208     else {
 209         if let Option::Some(42) = None {}
 210     }
 211
 212     if true {
 213         if let Some(42) = None::<u8> {}
 214     }
 215     else {
 216         if let Some(42) = None {}
 217     }
 218
 219     if true {
 220         if let Some(42) = None::<u8> {}
 221     }
 222     else {
 223         if let Some(42) = None::<u32> {}
 224     }
 225
 226     if true {
 227         if let Some(a) = Some(42) {}
 228     }
 229     else {
 230         if let Some(a) = Some(43) {}
 231     }
 232
 233     let _ = match 42 {
 234         42 => foo(),
 235         51 => foo(), //~ ERROR match arms have same body
 236         _ => true,
 237     };
 238
 239     let _ = match Some(42) {
 240         Some(_) => 24,
 241         None => 24, //~ ERROR match arms have same body
 242     };
 243
 244     let _ = match Some(42) {
 245         Some(foo) => 24,
 246         None => 24,
 247     };
 248
 249     let _ = match Some(42) {
 250         Some(42) => 24,
 251         Some(a) => 24, // bindings are different
 252         None => 0,
 253     };
 254
 255     let _ = match Some(42) {
 256         Some(a) if a > 0 => 24,
 257         Some(a) => 24, // one arm has a guard
 258         None => 0,
 259     };
 260
 261     match (Some(42), Some(42)) {
 262         (Some(a), None) => bar(a),
 263         (None, Some(a)) => bar(a), //~ ERROR match arms have same body
 264         _ => (),
 265     }
 266
 267     match (Some(42), Some(42)) {
 268         (Some(a), ..) => bar(a),
 269         (.., Some(a)) => bar(a), //~ ERROR match arms have same body
 270         _ => (),
 271     }
 272
 273     match (1, 2, 3) {
 274         (1, .., 3) => 42,
 275         (.., 3) => 42, //~ ERROR match arms have same body
 276         _ => 0,
 277     };
 278
 279     let _ = if true {
 280         0.0
 281     } else { //~ ERROR same body as `if` block
 282         0.0
 283     };
 284
 285     let _ = if true {
 286         -0.0
 287     } else { //~ ERROR same body as `if` block
 288         -0.0
 289     };
 290
 291     let _ = if true {
 292         0.0
 293     } else {
 294         -0.0
 295     };
 296
 297     // Different NaNs
 298     let _ = if true {
 299         0.0 / 0.0
 300     } else {
 301         std::f32::NAN
 302     };
 303
 304     // Same NaNs
 305     let _ = if true {
 306         std::f32::NAN
 307     } else { //~ ERROR same body as `if` block
 308         std::f32::NAN
 309     };
 310
 311     let _ = match Some(()) {
 312         Some(()) => 0.0,
 313         None => -0.0
 314     };
 315
 316     match (Some(42), Some("")) {
 317         (Some(a), None) => bar(a),
 318         (None, Some(a)) => bar(a), // bindings have different types
 319         _ => (),
 320     }
 321
 322     if true {
 323         try!(Ok("foo"));
 324     }
 325     else { //~ ERROR same body as `if` block
 326         try!(Ok("foo"));
 327     }
 328
 329     if true {
 330         let foo = "";
 331         return Ok(&foo[0..]);
 332     }
 333     else if false {
 334         let foo = "bar";
 335         return Ok(&foo[0..]);
 336     }
 337     else {
 338         let foo = "";
 339         return Ok(&foo[0..]);
 340     }
 341 }
 342
 343 #[warn(ifs_same_cond)]
 344 #[allow(if_same_then_else)] // all empty blocks
 345 fn ifs_same_cond() {
 346     let a = 0;
 347     let b = false;
 348
 349     if b {
 350     }
 351     else if b { //~ ERROR ifs same condition
 352     }
 353
 354     if a == 1 {
 355     }
 356     else if a == 1 { //~ ERROR ifs same condition
 357     }
 358
 359     if 2*a == 1 {
 360     }
 361     else if 2*a == 2 {
 362     }
 363     else if 2*a == 1 { //~ ERROR ifs same condition
 364     }
 365     else if a == 1 {
 366     }
 367
 368     // See #659
 369     if cfg!(feature = "feature1-659") {
 370         1
 371     } else if cfg!(feature = "feature2-659") {
 372         2
 373     } else {
 374         3
 375     };
 376
 377     let mut v = vec![1];
 378     if v.pop() == None { // ok, functions
 379     }
 380     else if v.pop() == None {
 381     }
 382
 383     if v.len() == 42 { // ok, functions
 384     }
 385     else if v.len() == 42 {
 386     }
 387 }
 388
 389 fn main() {}
 390
 391 // Issue #2423. This was causing an ICE
 392 fn func() {
 393     if true {
 394         f(&[0; 62]);
 395         f(&[0; 4]);
 396         f(&[0; 3]);
 397     } else {
 398         f(&[0; 62]);
 399         f(&[0; 6]);
 400         f(&[0; 6]);
 401     }
 402 }
 403
 404 fn f(val: &[u8]) {}