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

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