tests/ui/needless_for_each_fixable.rs

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