2 #![feature(custom_inner_attributes)]
3 #![warn(clippy::manual_retain)]
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;
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();
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>>();
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();
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();
49 fn btree_map_retain() {
50 let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
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();
56 .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
62 .filter(|(x, _)| x % 2 == 0)
63 .collect::<BTreeMap<i8, i8>>();
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();
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();
72 fn btree_set_retain() {
73 let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
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();
80 // Do not lint, because type conversion is performed
83 .filter(|&x| x % 2 == 0)
85 .collect::<BTreeSet<i8>>();
89 .filter(|&x| x % 2 == 0)
91 .collect::<BTreeSet<i8>>();
93 btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
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();
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();
105 fn hash_map_retain() {
106 let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
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();
112 .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
118 .filter(|(x, _)| x % 2 == 0)
119 .collect::<HashMap<i8, i8>>();
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();
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();
128 fn hash_set_retain() {
129 let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
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();
135 // Do not lint, because type conversion is performed
136 hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
139 .filter(|&x| x % 2 == 0)
141 .collect::<HashSet<i8>>();
145 .filter(|&x| x % 2 == 0)
147 .collect::<HashSet<i8>>();
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();
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();
160 let mut s = String::from("foobar");
162 s = s.chars().filter(|&c| c != 'o').to_owned().collect();
164 // Do not lint, because this expression is not assign.
165 let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
167 // Do not lint, because it is an assignment to a different variable.
168 s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
172 let mut vec = vec![0, 1, 2];
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();
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>>();
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();
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();
193 fn vec_deque_retain() {
194 let mut vec_deque = VecDeque::new();
195 vec_deque.extend(1..5);
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();
202 // Do not lint, because type conversion is performed
203 vec_deque = vec_deque
205 .filter(|&x| x % 2 == 0)
207 .collect::<VecDeque<i8>>();
208 vec_deque = vec_deque
210 .filter(|&x| x % 2 == 0)
212 .collect::<VecDeque<i8>>();
213 vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
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();
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();
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();
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();
235 #![clippy::msrv = "1.25"]
236 let mut s = String::from("foobar");
237 s = s.chars().filter(|&c| c != 'o').to_owned().collect();
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();