src/tools/clippy/tests/ui/manual_retain.rs

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