tests/ui/for_loop_fixable.fixed

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