tests/ui/copies.rs

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