tests/ui/manual_retain.fixed

   1 // run-rustfix
   2 #![warn(clippy::manual_retain)]
   3 #![allow(unused, clippy::redundant_clone)]
   4 use std::collections::BTreeMap;
   5 use std::collections::BTreeSet;
   6 use std::collections::BinaryHeap;
   7 use std::collections::HashMap;
   8 use std::collections::HashSet;
   9 use std::collections::VecDeque;
  10
  11 fn main() {
  12     binary_heap_retain();
  13     btree_set_retain();
  14     btree_map_retain();
  15     hash_set_retain();
  16     hash_map_retain();
  17     string_retain();
  18     vec_deque_retain();
  19     vec_retain();
  20     _msrv_153();
  21     _msrv_126();
  22     _msrv_118();
  23 }
  24
  25 fn binary_heap_retain() {
  26     // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
  27     // And we need to add a test case for msrv if we update this implmention.
  28     // https://github.com/rust-lang/rust/issues/71503
  29     let mut heap = BinaryHeap::from([1, 2, 3]);
  30     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
  31     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
  32     heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
  33
  34     // Do not lint, because type conversion is performed
  35     heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
  36     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
  37     heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
  38
  39     // Do not lint, because this expression is not assign.
  40     let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
  41     let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
  42
  43     // Do not lint, because it is an assignment to a different variable.
  44     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
  45     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
  46 }
  47
  48 fn btree_map_retain() {
  49     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
  50     // Do lint.
  51     btree_map.retain(|k, _| k % 2 == 0);
  52     btree_map.retain(|_, &mut v| v % 2 == 0);
  53     btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
  54
  55     // Do not lint.
  56     btree_map = btree_map
  57         .into_iter()
  58         .filter(|(x, _)| x % 2 == 0)
  59         .collect::<BTreeMap<i8, i8>>();
  60
  61     // Do not lint, because this expression is not assign.
  62     let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
  63
  64     // Do not lint, because it is an assignment to a different variable.
  65     btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
  66 }
  67
  68 fn btree_set_retain() {
  69     let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
  70
  71     // Do lint.
  72     btree_set.retain(|x| x % 2 == 0);
  73     btree_set.retain(|x| x % 2 == 0);
  74     btree_set.retain(|x| x % 2 == 0);
  75
  76     // Do not lint, because type conversion is performed
  77     btree_set = btree_set
  78         .iter()
  79         .filter(|&x| x % 2 == 0)
  80         .copied()
  81         .collect::<BTreeSet<i8>>();
  82
  83     btree_set = btree_set
  84         .iter()
  85         .filter(|&x| x % 2 == 0)
  86         .cloned()
  87         .collect::<BTreeSet<i8>>();
  88
  89     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
  90
  91     // Do not lint, because this expression is not assign.
  92     let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
  93     let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
  94
  95     // Do not lint, because it is an assignment to a different variable.
  96     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
  97     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
  98     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
  99 }
 100
 101 fn hash_map_retain() {
 102     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
 103     // Do lint.
 104     hash_map.retain(|k, _| k % 2 == 0);
 105     hash_map.retain(|_, &mut v| v % 2 == 0);
 106     hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
 107
 108     // Do not lint.
 109     hash_map = hash_map
 110         .into_iter()
 111         .filter(|(x, _)| x % 2 == 0)
 112         .collect::<HashMap<i8, i8>>();
 113
 114     // Do not lint, because this expression is not assign.
 115     let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 116
 117     // Do not lint, because it is an assignment to a different variable.
 118     hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 119 }
 120
 121 fn hash_set_retain() {
 122     let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
 123     // Do lint.
 124     hash_set.retain(|x| x % 2 == 0);
 125     hash_set.retain(|x| x % 2 == 0);
 126     hash_set.retain(|x| x % 2 == 0);
 127
 128     // Do not lint, because type conversion is performed
 129     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
 130     hash_set = hash_set
 131         .iter()
 132         .filter(|&x| x % 2 == 0)
 133         .copied()
 134         .collect::<HashSet<i8>>();
 135
 136     hash_set = hash_set
 137         .iter()
 138         .filter(|&x| x % 2 == 0)
 139         .cloned()
 140         .collect::<HashSet<i8>>();
 141
 142     // Do not lint, because this expression is not assign.
 143     let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
 144     let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
 145
 146     // Do not lint, because it is an assignment to a different variable.
 147     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
 148     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
 149     bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
 150 }
 151
 152 fn string_retain() {
 153     let mut s = String::from("foobar");
 154     // Do lint.
 155     s.retain(|c| c != 'o');
 156
 157     // Do not lint, because this expression is not assign.
 158     let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
 159
 160     // Do not lint, because it is an assignment to a different variable.
 161     s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
 162 }
 163
 164 fn vec_retain() {
 165     let mut vec = vec![0, 1, 2];
 166     // Do lint.
 167     vec.retain(|x| x % 2 == 0);
 168     vec.retain(|x| x % 2 == 0);
 169     vec.retain(|x| x % 2 == 0);
 170
 171     // Do not lint, because type conversion is performed
 172     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
 173     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
 174     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
 175
 176     // Do not lint, because this expression is not assign.
 177     let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
 178     let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
 179
 180     // Do not lint, because it is an assignment to a different variable.
 181     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
 182     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
 183     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 184 }
 185
 186 fn vec_deque_retain() {
 187     let mut vec_deque = VecDeque::new();
 188     vec_deque.extend(1..5);
 189
 190     // Do lint.
 191     vec_deque.retain(|x| x % 2 == 0);
 192     vec_deque.retain(|x| x % 2 == 0);
 193     vec_deque.retain(|x| x % 2 == 0);
 194
 195     // Do not lint, because type conversion is performed
 196     vec_deque = vec_deque
 197         .iter()
 198         .filter(|&x| x % 2 == 0)
 199         .copied()
 200         .collect::<VecDeque<i8>>();
 201     vec_deque = vec_deque
 202         .iter()
 203         .filter(|&x| x % 2 == 0)
 204         .cloned()
 205         .collect::<VecDeque<i8>>();
 206     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
 207
 208     // Do not lint, because this expression is not assign.
 209     let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
 210     let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
 211
 212     // Do not lint, because it is an assignment to a different variable.
 213     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
 214     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
 215     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 216 }
 217
 218 #[clippy::msrv = "1.52"]
 219 fn _msrv_153() {
 220     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
 221     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 222
 223     let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
 224     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
 225 }
 226
 227 #[clippy::msrv = "1.25"]
 228 fn _msrv_126() {
 229     let mut s = String::from("foobar");
 230     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
 231 }
 232
 233 #[clippy::msrv = "1.17"]
 234 fn _msrv_118() {
 235     let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
 236     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
 237     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
 238     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 239 }