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::cognitive_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     let mut vec = vec![1, 2, 3, 4];
  39
  40     for i in 10..0 {
  41         println!("{}", i);
  42     }
  43
  44     for i in 10..=0 {
  45         println!("{}", i);
  46     }
  47
  48     for i in MAX_LEN..0 {
  49         println!("{}", i);
  50     }
  51
  52     for i in 5..5 {
  53         println!("{}", i);
  54     }
  55
  56     for i in 5..=5 {
  57         // not an error, this is the range with only one element “5”
  58         println!("{}", i);
  59     }
  60
  61     for i in 0..10 {
  62         // not an error, the start index is less than the end index
  63         println!("{}", i);
  64     }
  65
  66     for i in -10..0 {
  67         // not an error
  68         println!("{}", i);
  69     }
  70
  71     for i in (10..0).map(|x| x * 2) {
  72         // not an error, it can't be known what arbitrary methods do to a range
  73         println!("{}", i);
  74     }
  75
  76     // testing that the empty range lint folds constants
  77     for i in 10..5 + 4 {
  78         println!("{}", i);
  79     }
  80
  81     for i in (5 + 2)..(3 - 1) {
  82         println!("{}", i);
  83     }
  84
  85     for i in (5 + 2)..(8 - 1) {
  86         println!("{}", i);
  87     }
  88
  89     for i in (2 * 2)..(2 * 3) {
  90         // no error, 4..6 is fine
  91         println!("{}", i);
  92     }
  93
  94     let x = 42;
  95     for i in x..10 {
  96         // no error, not constant-foldable
  97         println!("{}", i);
  98     }
  99
 100     // See #601
 101     for i in 0..10 {
 102         // no error, id_col does not exist outside the loop
 103         let mut id_col = vec![0f64; 10];
 104         id_col[i] = 1f64;
 105     }
 106
 107     for _v in vec.iter() {}
 108
 109     for _v in vec.iter_mut() {}
 110
 111     let out_vec = vec![1, 2, 3];
 112     for _v in out_vec.into_iter() {}
 113
 114     let array = [1, 2, 3];
 115     for _v in array.into_iter() {}
 116
 117     for _v in &vec {} // these are fine
 118     for _v in &mut vec {} // these are fine
 119
 120     for _v in [1, 2, 3].iter() {}
 121
 122     for _v in (&mut [1, 2, 3]).iter() {} // no error
 123
 124     for _v in [0; 32].iter() {}
 125
 126     for _v in [0; 33].iter() {} // no error
 127
 128     let ll: LinkedList<()> = LinkedList::new();
 129     for _v in ll.iter() {}
 130
 131     let vd: VecDeque<()> = VecDeque::new();
 132     for _v in vd.iter() {}
 133
 134     let bh: BinaryHeap<()> = BinaryHeap::new();
 135     for _v in bh.iter() {}
 136
 137     let hm: HashMap<(), ()> = HashMap::new();
 138     for _v in hm.iter() {}
 139
 140     let bt: BTreeMap<(), ()> = BTreeMap::new();
 141     for _v in bt.iter() {}
 142
 143     let hs: HashSet<()> = HashSet::new();
 144     for _v in hs.iter() {}
 145
 146     let bs: BTreeSet<()> = BTreeSet::new();
 147     for _v in bs.iter() {}
 148
 149     for _v in vec.iter().next() {}
 150
 151     let u = Unrelated(vec![]);
 152     for _v in u.next() {} // no error
 153     for _v in u.iter() {} // no error
 154
 155     let mut out = vec![];
 156     vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>();
 157     let _y = vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>(); // this is fine
 158
 159     // Loop with explicit counter variable
 160
 161     // Potential false positives
 162     let mut _index = 0;
 163     _index = 1;
 164     for _v in &vec {
 165         _index += 1
 166     }
 167
 168     let mut _index = 0;
 169     _index += 1;
 170     for _v in &vec {
 171         _index += 1
 172     }
 173
 174     let mut _index = 0;
 175     if true {
 176         _index = 1
 177     }
 178     for _v in &vec {
 179         _index += 1
 180     }
 181
 182     let mut _index = 0;
 183     let mut _index = 1;
 184     for _v in &vec {
 185         _index += 1
 186     }
 187
 188     let mut _index = 0;
 189     for _v in &vec {
 190         _index += 1;
 191         _index += 1
 192     }
 193
 194     let mut _index = 0;
 195     for _v in &vec {
 196         _index *= 2;
 197         _index += 1
 198     }
 199
 200     let mut _index = 0;
 201     for _v in &vec {
 202         _index = 1;
 203         _index += 1
 204     }
 205
 206     let mut _index = 0;
 207
 208     for _v in &vec {
 209         let mut _index = 0;
 210         _index += 1
 211     }
 212
 213     let mut _index = 0;
 214     for _v in &vec {
 215         _index += 1;
 216         _index = 0;
 217     }
 218
 219     let mut _index = 0;
 220     for _v in &vec {
 221         for _x in 0..1 {
 222             _index += 1;
 223         }
 224         _index += 1
 225     }
 226
 227     let mut _index = 0;
 228     for x in &vec {
 229         if *x == 1 {
 230             _index += 1
 231         }
 232     }
 233
 234     let mut _index = 0;
 235     if true {
 236         _index = 1
 237     };
 238     for _v in &vec {
 239         _index += 1
 240     }
 241
 242     let mut _index = 1;
 243     if false {
 244         _index = 0
 245     };
 246     for _v in &vec {
 247         _index += 1
 248     }
 249
 250     let mut index = 0;
 251     {
 252         let mut _x = &mut index;
 253     }
 254     for _v in &vec {
 255         _index += 1
 256     }
 257
 258     let mut index = 0;
 259     for _v in &vec {
 260         index += 1
 261     }
 262     println!("index: {}", index);
 263
 264     fn f<T>(_: &T, _: &T) -> bool {
 265         unimplemented!()
 266     }
 267     fn g<T>(_: &mut [T], _: usize, _: usize) {
 268         unimplemented!()
 269     }
 270     for i in 1..vec.len() {
 271         if f(&vec[i - 1], &vec[i]) {
 272             g(&mut vec, i - 1, i);
 273         }
 274     }
 275
 276     for mid in 1..vec.len() {
 277         let (_, _) = vec.split_at(mid);
 278     }
 279 }
 280
 281 #[allow(dead_code)]
 282 fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize {
 283     let pivot = v.len() - 1;
 284     let mut i = 0;
 285     for j in 0..pivot {
 286         if v[j] <= v[pivot] {
 287             v.swap(i, j);
 288             i += 1;
 289         }
 290     }
 291     v.swap(i, pivot);
 292     i
 293 }
 294
 295 #[warn(clippy::needless_range_loop)]
 296 pub fn manual_copy_same_destination(dst: &mut [i32], d: usize, s: usize) {
 297     // Same source and destination - don't trigger lint
 298     for i in 0..dst.len() {
 299         dst[d + i] = dst[s + i];
 300     }
 301 }
 302
 303 mod issue_2496 {
 304     pub trait Handle {
 305         fn new_for_index(index: usize) -> Self;
 306         fn index(&self) -> usize;
 307     }
 308
 309     pub fn test<H: Handle>() -> H {
 310         for x in 0..5 {
 311             let next_handle = H::new_for_index(x);
 312             println!("{}", next_handle.index());
 313         }
 314         unimplemented!()
 315     }
 316 }