tests/ui/for_loop_fixable.rs

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