tests/ui/for_loop.rs

   1 use std::collections::*;
   2 use std::rc::Rc;
   3
   4 static STATIC: [usize; 4] = [0, 1, 8, 16];
   5 const CONST: [usize; 4] = [0, 1, 8, 16];
   6
   7 #[warn(clippy::all)]
   8 struct Unrelated(Vec<u8>);
   9 impl Unrelated {
  10     fn next(&self) -> std::slice::Iter<u8> {
  11         self.0.iter()
  12     }
  13
  14     fn iter(&self) -> std::slice::Iter<u8> {
  15         self.0.iter()
  16     }
  17 }
  18
  19 #[warn(
  20     clippy::needless_range_loop,
  21     clippy::explicit_iter_loop,
  22     clippy::explicit_into_iter_loop,
  23     clippy::iter_next_loop,
  24     clippy::reverse_range_loop,
  25     clippy::for_kv_map
  26 )]
  27 #[warn(clippy::unused_collect)]
  28 #[allow(
  29     clippy::linkedlist,
  30     clippy::shadow_unrelated,
  31     clippy::unnecessary_mut_passed,
  32     clippy::cyclomatic_complexity,
  33     clippy::similar_names
  34 )]
  35 #[allow(clippy::many_single_char_names, unused_variables, clippy::into_iter_on_array)]
  36 fn main() {
  37     const MAX_LEN: usize = 42;
  38
  39     let mut vec = vec![1, 2, 3, 4];
  40     let vec2 = vec![1, 2, 3, 4];
  41     for i in 0..vec.len() {
  42         println!("{}", vec[i]);
  43     }
  44
  45     for i in 0..vec.len() {
  46         let i = 42; // make a different `i`
  47         println!("{}", vec[i]); // ok, not the `i` of the for-loop
  48     }
  49
  50     for i in 0..vec.len() {
  51         let _ = vec[i];
  52     }
  53
  54     // ICE #746
  55     for j in 0..4 {
  56         println!("{:?}", STATIC[j]);
  57     }
  58
  59     for j in 0..4 {
  60         println!("{:?}", CONST[j]);
  61     }
  62
  63     for i in 0..vec.len() {
  64         println!("{} {}", vec[i], i);
  65     }
  66     for i in 0..vec.len() {
  67         // not an error, indexing more than one variable
  68         println!("{} {}", vec[i], vec2[i]);
  69     }
  70
  71     for i in 0..vec.len() {
  72         println!("{}", vec2[i]);
  73     }
  74
  75     for i in 5..vec.len() {
  76         println!("{}", vec[i]);
  77     }
  78
  79     for i in 0..MAX_LEN {
  80         println!("{}", vec[i]);
  81     }
  82
  83     for i in 0..=MAX_LEN {
  84         println!("{}", vec[i]);
  85     }
  86
  87     for i in 5..10 {
  88         println!("{}", vec[i]);
  89     }
  90
  91     for i in 5..=10 {
  92         println!("{}", vec[i]);
  93     }
  94
  95     for i in 5..vec.len() {
  96         println!("{} {}", vec[i], i);
  97     }
  98
  99     for i in 5..10 {
 100         println!("{} {}", vec[i], i);
 101     }
 102
 103     for i in 10..0 {
 104         println!("{}", i);
 105     }
 106
 107     for i in 10..=0 {
 108         println!("{}", i);
 109     }
 110
 111     for i in MAX_LEN..0 {
 112         println!("{}", i);
 113     }
 114
 115     for i in 5..5 {
 116         println!("{}", i);
 117     }
 118
 119     for i in 5..=5 {
 120         // not an error, this is the range with only one element “5”
 121         println!("{}", i);
 122     }
 123
 124     for i in 0..10 {
 125         // not an error, the start index is less than the end index
 126         println!("{}", i);
 127     }
 128
 129     for i in -10..0 {
 130         // not an error
 131         println!("{}", i);
 132     }
 133
 134     for i in (10..0).map(|x| x * 2) {
 135         // not an error, it can't be known what arbitrary methods do to a range
 136         println!("{}", i);
 137     }
 138
 139     // testing that the empty range lint folds constants
 140     for i in 10..5 + 4 {
 141         println!("{}", i);
 142     }
 143
 144     for i in (5 + 2)..(3 - 1) {
 145         println!("{}", i);
 146     }
 147
 148     for i in (5 + 2)..(8 - 1) {
 149         println!("{}", i);
 150     }
 151
 152     for i in (2 * 2)..(2 * 3) {
 153         // no error, 4..6 is fine
 154         println!("{}", i);
 155     }
 156
 157     let x = 42;
 158     for i in x..10 {
 159         // no error, not constant-foldable
 160         println!("{}", i);
 161     }
 162
 163     // See #601
 164     for i in 0..10 {
 165         // no error, id_col does not exist outside the loop
 166         let mut id_col = vec![0f64; 10];
 167         id_col[i] = 1f64;
 168     }
 169
 170     for _v in vec.iter() {}
 171
 172     for _v in vec.iter_mut() {}
 173
 174     let out_vec = vec![1, 2, 3];
 175     for _v in out_vec.into_iter() {}
 176
 177     let array = [1, 2, 3];
 178     for _v in array.into_iter() {}
 179
 180     for _v in &vec {} // these are fine
 181     for _v in &mut vec {} // these are fine
 182
 183     for _v in [1, 2, 3].iter() {}
 184
 185     for _v in (&mut [1, 2, 3]).iter() {} // no error
 186
 187     for _v in [0; 32].iter() {}
 188
 189     for _v in [0; 33].iter() {} // no error
 190
 191     let ll: LinkedList<()> = LinkedList::new();
 192     for _v in ll.iter() {}
 193
 194     let vd: VecDeque<()> = VecDeque::new();
 195     for _v in vd.iter() {}
 196
 197     let bh: BinaryHeap<()> = BinaryHeap::new();
 198     for _v in bh.iter() {}
 199
 200     let hm: HashMap<(), ()> = HashMap::new();
 201     for _v in hm.iter() {}
 202
 203     let bt: BTreeMap<(), ()> = BTreeMap::new();
 204     for _v in bt.iter() {}
 205
 206     let hs: HashSet<()> = HashSet::new();
 207     for _v in hs.iter() {}
 208
 209     let bs: BTreeSet<()> = BTreeSet::new();
 210     for _v in bs.iter() {}
 211
 212     for _v in vec.iter().next() {}
 213
 214     let u = Unrelated(vec![]);
 215     for _v in u.next() {} // no error
 216     for _v in u.iter() {} // no error
 217
 218     let mut out = vec![];
 219     vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>();
 220     let _y = vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>(); // this is fine
 221
 222     // Loop with explicit counter variable
 223
 224     // Potential false positives
 225     let mut _index = 0;
 226     _index = 1;
 227     for _v in &vec {
 228         _index += 1
 229     }
 230
 231     let mut _index = 0;
 232     _index += 1;
 233     for _v in &vec {
 234         _index += 1
 235     }
 236
 237     let mut _index = 0;
 238     if true {
 239         _index = 1
 240     }
 241     for _v in &vec {
 242         _index += 1
 243     }
 244
 245     let mut _index = 0;
 246     let mut _index = 1;
 247     for _v in &vec {
 248         _index += 1
 249     }
 250
 251     let mut _index = 0;
 252     for _v in &vec {
 253         _index += 1;
 254         _index += 1
 255     }
 256
 257     let mut _index = 0;
 258     for _v in &vec {
 259         _index *= 2;
 260         _index += 1
 261     }
 262
 263     let mut _index = 0;
 264     for _v in &vec {
 265         _index = 1;
 266         _index += 1
 267     }
 268
 269     let mut _index = 0;
 270
 271     for _v in &vec {
 272         let mut _index = 0;
 273         _index += 1
 274     }
 275
 276     let mut _index = 0;
 277     for _v in &vec {
 278         _index += 1;
 279         _index = 0;
 280     }
 281
 282     let mut _index = 0;
 283     for _v in &vec {
 284         for _x in 0..1 {
 285             _index += 1;
 286         }
 287         _index += 1
 288     }
 289
 290     let mut _index = 0;
 291     for x in &vec {
 292         if *x == 1 {
 293             _index += 1
 294         }
 295     }
 296
 297     let mut _index = 0;
 298     if true {
 299         _index = 1
 300     };
 301     for _v in &vec {
 302         _index += 1
 303     }
 304
 305     let mut _index = 1;
 306     if false {
 307         _index = 0
 308     };
 309     for _v in &vec {
 310         _index += 1
 311     }
 312
 313     let mut index = 0;
 314     {
 315         let mut _x = &mut index;
 316     }
 317     for _v in &vec {
 318         _index += 1
 319     }
 320
 321     let mut index = 0;
 322     for _v in &vec {
 323         index += 1
 324     }
 325     println!("index: {}", index);
 326
 327     fn f<T>(_: &T, _: &T) -> bool {
 328         unimplemented!()
 329     }
 330     fn g<T>(_: &mut [T], _: usize, _: usize) {
 331         unimplemented!()
 332     }
 333     for i in 1..vec.len() {
 334         if f(&vec[i - 1], &vec[i]) {
 335             g(&mut vec, i - 1, i);
 336         }
 337     }
 338
 339     for mid in 1..vec.len() {
 340         let (_, _) = vec.split_at(mid);
 341     }
 342 }
 343
 344 #[allow(dead_code)]
 345 fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize {
 346     let pivot = v.len() - 1;
 347     let mut i = 0;
 348     for j in 0..pivot {
 349         if v[j] <= v[pivot] {
 350             v.swap(i, j);
 351             i += 1;
 352         }
 353     }
 354     v.swap(i, pivot);
 355     i
 356 }
 357
 358 const LOOP_OFFSET: usize = 5000;
 359
 360 #[warn(clippy::needless_range_loop)]
 361 pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
 362     // plain manual memcpy
 363     for i in 0..src.len() {
 364         dst[i] = src[i];
 365     }
 366
 367     // dst offset memcpy
 368     for i in 0..src.len() {
 369         dst[i + 10] = src[i];
 370     }
 371
 372     // src offset memcpy
 373     for i in 0..src.len() {
 374         dst[i] = src[i + 10];
 375     }
 376
 377     // src offset memcpy
 378     for i in 11..src.len() {
 379         dst[i] = src[i - 10];
 380     }
 381
 382     // overwrite entire dst
 383     for i in 0..dst.len() {
 384         dst[i] = src[i];
 385     }
 386
 387     // manual copy with branch - can't easily convert to memcpy!
 388     for i in 0..src.len() {
 389         dst[i] = src[i];
 390         if dst[i] > 5 {
 391             break;
 392         }
 393     }
 394
 395     // multiple copies - suggest two memcpy statements
 396     for i in 10..256 {
 397         dst[i] = src[i - 5];
 398         dst2[i + 500] = src[i]
 399     }
 400
 401     // this is a reversal - the copy lint shouldn't be triggered
 402     for i in 10..LOOP_OFFSET {
 403         dst[i + LOOP_OFFSET] = src[LOOP_OFFSET - i];
 404     }
 405
 406     let some_var = 5;
 407     // Offset in variable
 408     for i in 10..LOOP_OFFSET {
 409         dst[i + LOOP_OFFSET] = src[i - some_var];
 410     }
 411
 412     // Non continuous copy - don't trigger lint
 413     for i in 0..10 {
 414         dst[i + i] = src[i];
 415     }
 416
 417     let src_vec = vec![1, 2, 3, 4, 5];
 418     let mut dst_vec = vec![0, 0, 0, 0, 0];
 419
 420     // make sure vectors are supported
 421     for i in 0..src_vec.len() {
 422         dst_vec[i] = src_vec[i];
 423     }
 424
 425     // lint should not trigger when either
 426     // source or destination type is not
 427     // slice-like, like DummyStruct
 428     struct DummyStruct(i32);
 429
 430     impl ::std::ops::Index<usize> for DummyStruct {
 431         type Output = i32;
 432
 433         fn index(&self, _: usize) -> &i32 {
 434             &self.0
 435         }
 436     }
 437
 438     let src = DummyStruct(5);
 439     let mut dst_vec = vec![0; 10];
 440
 441     for i in 0..10 {
 442         dst_vec[i] = src[i];
 443     }
 444
 445     // Simplify suggestion (issue #3004)
 446     let src = [0, 1, 2, 3, 4];
 447     let mut dst = [0, 0, 0, 0, 0, 0];
 448     let from = 1;
 449
 450     for i in from..from + src.len() {
 451         dst[i] = src[i - from];
 452     }
 453
 454     for i in from..from + 3 {
 455         dst[i] = src[i - from];
 456     }
 457 }
 458
 459 #[warn(clippy::needless_range_loop)]
 460 pub fn manual_clone(src: &[String], dst: &mut [String]) {
 461     for i in 0..src.len() {
 462         dst[i] = src[i].clone();
 463     }
 464 }
 465
 466 #[warn(clippy::needless_range_loop)]
 467 pub fn manual_copy_same_destination(dst: &mut [i32], d: usize, s: usize) {
 468     // Same source and destination - don't trigger lint
 469     for i in 0..dst.len() {
 470         dst[d + i] = dst[s + i];
 471     }
 472 }
 473
 474 mod issue_2496 {
 475     pub trait Handle {
 476         fn new_for_index(index: usize) -> Self;
 477         fn index(&self) -> usize;
 478     }
 479
 480     pub fn test<H: Handle>() -> H {
 481         for x in 0..5 {
 482             let next_handle = H::new_for_index(x);
 483             println!("{}", next_handle.index());
 484         }
 485         unimplemented!()
 486     }
 487 }