src/tools/clippy/tests/ui/copies.rs

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