src/tools/clippy/tests/ui/needless_for_each_fixable.fixed

   1 // run-rustfix
   2 #![warn(clippy::needless_for_each)]
   3 #![allow(
   4     unused,
   5     clippy::needless_return,
   6     clippy::match_single_binding,
   7     clippy::let_unit_value
   8 )]
   9
  10 use std::collections::HashMap;
  11
  12 fn should_lint() {
  13     let v: Vec<i32> = Vec::new();
  14     let mut acc = 0;
  15     for elem in v.iter() {
  16         acc += elem;
  17     }
  18     for elem in v.into_iter() {
  19         acc += elem;
  20     }
  21
  22     for elem in [1, 2, 3].iter() {
  23         acc += elem;
  24     }
  25
  26     let mut hash_map: HashMap<i32, i32> = HashMap::new();
  27     for (k, v) in hash_map.iter() {
  28         acc += k + v;
  29     }
  30     for (k, v) in hash_map.iter_mut() {
  31         acc += *k + *v;
  32     }
  33     for k in hash_map.keys() {
  34         acc += k;
  35     }
  36     for v in hash_map.values() {
  37         acc += v;
  38     }
  39
  40     fn my_vec() -> Vec<i32> {
  41         Vec::new()
  42     }
  43     for elem in my_vec().iter() {
  44         acc += elem;
  45     }
  46 }
  47
  48 fn should_not_lint() {
  49     let v: Vec<i32> = Vec::new();
  50     let mut acc = 0;
  51
  52     // `for_each` argument is not closure.
  53     fn print(x: &i32) {
  54         println!("{}", x);
  55     }
  56     v.iter().for_each(print);
  57
  58     // User defined type.
  59     struct MyStruct {
  60         v: Vec<i32>,
  61     }
  62     impl MyStruct {
  63         fn iter(&self) -> impl Iterator<Item = &i32> {
  64             self.v.iter()
  65         }
  66     }
  67     let s = MyStruct { v: Vec::new() };
  68     s.iter().for_each(|elem| {
  69         acc += elem;
  70     });
  71
  72     // `for_each` follows long iterator chain.
  73     v.iter().chain(v.iter()).for_each(|v| {
  74         acc += v;
  75     });
  76     v.as_slice().iter().for_each(|v| {
  77         acc += v;
  78     });
  79     s.v.iter().for_each(|v| {
  80         acc += v;
  81     });
  82
  83     // `return` is used in `Loop` of the closure.
  84     v.iter().for_each(|v| {
  85         for i in 0..*v {
  86             if i == 10 {
  87                 return;
  88             } else {
  89                 println!("{}", v);
  90             }
  91         }
  92         if *v == 20 {
  93             return;
  94         } else {
  95             println!("{}", v);
  96         }
  97     });
  98
  99     // Previously transformed iterator variable.
 100     let it = v.iter();
 101     it.chain(v.iter()).for_each(|elem| {
 102         acc += elem;
 103     });
 104
 105     // `for_each` is not directly in a statement.
 106     match 1 {
 107         _ => v.iter().for_each(|elem| {
 108             acc += elem;
 109         }),
 110     }
 111
 112     // `for_each` is in a let bingind.
 113     let _ = v.iter().for_each(|elem| {
 114         acc += elem;
 115     });
 116 }
 117
 118 fn main() {}