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