tests/ui/needless_for_each_fixable.rs

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