fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
9.1 KiB357 linesraw
1#![allow(unused)]
2#![warn(clippy::clear_with_drain)]
3
4use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
5
6fn vec_range() {
7    // Do not lint because iterator is assigned
8    let mut v = vec![1, 2, 3];
9    let iter = v.drain(0..v.len());
10
11    // Do not lint because iterator is used
12    let mut v = vec![1, 2, 3];
13    let n = v.drain(0..v.len()).count();
14
15    // Do not lint because iterator is assigned and used
16    let mut v = vec![1, 2, 3];
17    let iter = v.drain(usize::MIN..v.len());
18    let n = iter.count();
19
20    // Do lint
21    let mut v = vec![1, 2, 3];
22    v.clear();
23
24    // Do lint
25    let mut v = vec![1, 2, 3];
26    v.clear();
27}
28
29fn vec_range_from() {
30    // Do not lint because iterator is assigned
31    let mut v = vec![1, 2, 3];
32    let iter = v.drain(0..);
33
34    // Do not lint because iterator is assigned and used
35    let mut v = vec![1, 2, 3];
36    let mut iter = v.drain(0..);
37    let next = iter.next();
38
39    // Do not lint because iterator is used
40    let mut v = vec![1, 2, 3];
41    let next = v.drain(usize::MIN..).next();
42
43    // Do lint
44    let mut v = vec![1, 2, 3];
45    v.clear();
46
47    // Do lint
48    let mut v = vec![1, 2, 3];
49    v.clear();
50}
51
52fn vec_range_full() {
53    // Do not lint because iterator is assigned
54    let mut v = vec![1, 2, 3];
55    let iter = v.drain(..);
56
57    // Do not lint because iterator is used
58    let mut v = vec![1, 2, 3];
59    for x in v.drain(..) {
60        let y = format!("x = {x}");
61    }
62
63    // Do lint
64    let mut v = vec![1, 2, 3];
65    v.clear();
66}
67
68fn vec_range_to() {
69    // Do not lint because iterator is assigned
70    let mut v = vec![1, 2, 3];
71    let iter = v.drain(..v.len());
72
73    // Do not lint because iterator is assigned and used
74    let mut v = vec![1, 2, 3];
75    let iter = v.drain(..v.len());
76    for x in iter {
77        let y = format!("x = {x}");
78    }
79
80    // Do lint
81    let mut v = vec![1, 2, 3];
82    v.clear();
83}
84
85fn vec_partial_drains() {
86    // Do not lint any of these because the ranges are not full
87
88    let mut v = vec![1, 2, 3];
89    v.drain(1..);
90    let mut v = vec![1, 2, 3];
91    v.drain(1..).max();
92
93    let mut v = vec![1, 2, 3];
94    v.drain(..v.len() - 1);
95    let mut v = vec![1, 2, 3];
96    v.drain(..v.len() - 1).min();
97
98    let mut v = vec![1, 2, 3];
99    v.drain(1..v.len() - 1);
100    let mut v = vec![1, 2, 3];
101    let w: Vec<i8> = v.drain(1..v.len() - 1).collect();
102}
103
104fn vec_deque_range() {
105    // Do not lint because iterator is assigned
106    let mut deque = VecDeque::from([1, 2, 3]);
107    let iter = deque.drain(0..deque.len());
108
109    // Do not lint because iterator is used
110    let mut deque = VecDeque::from([1, 2, 3]);
111    let n = deque.drain(0..deque.len()).count();
112
113    // Do not lint because iterator is assigned and used
114    let mut deque = VecDeque::from([1, 2, 3]);
115    let iter = deque.drain(usize::MIN..deque.len());
116    let n = iter.count();
117
118    // Do lint
119    let mut deque = VecDeque::from([1, 2, 3]);
120    deque.clear();
121
122    // Do lint
123    let mut deque = VecDeque::from([1, 2, 3]);
124    deque.clear();
125}
126
127fn vec_deque_range_from() {
128    // Do not lint because iterator is assigned
129    let mut deque = VecDeque::from([1, 2, 3]);
130    let iter = deque.drain(0..);
131
132    // Do not lint because iterator is assigned and used
133    let mut deque = VecDeque::from([1, 2, 3]);
134    let mut iter = deque.drain(0..);
135    let next = iter.next();
136
137    // Do not lint because iterator is used
138    let mut deque = VecDeque::from([1, 2, 3]);
139    let next = deque.drain(usize::MIN..).next();
140
141    // Do lint
142    let mut deque = VecDeque::from([1, 2, 3]);
143    deque.clear();
144
145    // Do lint
146    let mut deque = VecDeque::from([1, 2, 3]);
147    deque.clear();
148}
149
150fn vec_deque_range_full() {
151    // Do not lint because iterator is assigned
152    let mut deque = VecDeque::from([1, 2, 3]);
153    let iter = deque.drain(..);
154
155    // Do not lint because iterator is used
156    let mut deque = VecDeque::from([1, 2, 3]);
157    for x in deque.drain(..) {
158        let y = format!("x = {x}");
159    }
160
161    // Do lint
162    let mut deque = VecDeque::from([1, 2, 3]);
163    deque.clear();
164}
165
166fn vec_deque_range_to() {
167    // Do not lint because iterator is assigned
168    let mut deque = VecDeque::from([1, 2, 3]);
169    let iter = deque.drain(..deque.len());
170
171    // Do not lint because iterator is assigned and used
172    let mut deque = VecDeque::from([1, 2, 3]);
173    let iter = deque.drain(..deque.len());
174    for x in iter {
175        let y = format!("x = {x}");
176    }
177
178    // Do lint
179    let mut deque = VecDeque::from([1, 2, 3]);
180    deque.clear();
181}
182
183fn vec_deque_partial_drains() {
184    // Do not lint any of these because the ranges are not full
185
186    let mut deque = VecDeque::from([1, 2, 3]);
187    deque.drain(1..);
188    let mut deque = VecDeque::from([1, 2, 3]);
189    deque.drain(1..).max();
190
191    let mut deque = VecDeque::from([1, 2, 3]);
192    deque.drain(..deque.len() - 1);
193    let mut deque = VecDeque::from([1, 2, 3]);
194    deque.drain(..deque.len() - 1).min();
195
196    let mut deque = VecDeque::from([1, 2, 3]);
197    deque.drain(1..deque.len() - 1);
198    let mut deque = VecDeque::from([1, 2, 3]);
199    let w: Vec<i8> = deque.drain(1..deque.len() - 1).collect();
200}
201
202fn string_range() {
203    // Do not lint because iterator is assigned
204    let mut s = String::from("Hello, world!");
205    let iter = s.drain(0..s.len());
206
207    // Do not lint because iterator is used
208    let mut s = String::from("Hello, world!");
209    let n = s.drain(0..s.len()).count();
210
211    // Do not lint because iterator is assigned and used
212    let mut s = String::from("Hello, world!");
213    let iter = s.drain(usize::MIN..s.len());
214    let n = iter.count();
215
216    // Do lint
217    let mut s = String::from("Hello, world!");
218    s.clear();
219
220    // Do lint
221    let mut s = String::from("Hello, world!");
222    s.clear();
223}
224
225fn string_range_from() {
226    // Do not lint because iterator is assigned
227    let mut s = String::from("Hello, world!");
228    let iter = s.drain(0..);
229
230    // Do not lint because iterator is assigned and used
231    let mut s = String::from("Hello, world!");
232    let mut iter = s.drain(0..);
233    let next = iter.next();
234
235    // Do not lint because iterator is used
236    let mut s = String::from("Hello, world!");
237    let next = s.drain(usize::MIN..).next();
238
239    // Do lint
240    let mut s = String::from("Hello, world!");
241    s.clear();
242
243    // Do lint
244    let mut s = String::from("Hello, world!");
245    s.clear();
246}
247
248fn string_range_full() {
249    // Do not lint because iterator is assigned
250    let mut s = String::from("Hello, world!");
251    let iter = s.drain(..);
252
253    // Do not lint because iterator is used
254    let mut s = String::from("Hello, world!");
255    for x in s.drain(..) {
256        let y = format!("x = {x}");
257    }
258
259    // Do lint
260    let mut s = String::from("Hello, world!");
261    s.clear();
262}
263
264fn string_range_to() {
265    // Do not lint because iterator is assigned
266    let mut s = String::from("Hello, world!");
267    let iter = s.drain(..s.len());
268
269    // Do not lint because iterator is assigned and used
270    let mut s = String::from("Hello, world!");
271    let iter = s.drain(..s.len());
272    for x in iter {
273        let y = format!("x = {x}");
274    }
275
276    // Do lint
277    let mut s = String::from("Hello, world!");
278    s.clear();
279}
280
281fn string_partial_drains() {
282    // Do not lint any of these because the ranges are not full
283
284    let mut s = String::from("Hello, world!");
285    s.drain(1..);
286    let mut s = String::from("Hello, world!");
287    s.drain(1..).max();
288
289    let mut s = String::from("Hello, world!");
290    s.drain(..s.len() - 1);
291    let mut s = String::from("Hello, world!");
292    s.drain(..s.len() - 1).min();
293
294    let mut s = String::from("Hello, world!");
295    s.drain(1..s.len() - 1);
296    let mut s = String::from("Hello, world!");
297    let w: String = s.drain(1..s.len() - 1).collect();
298}
299
300fn hash_set() {
301    // Do not lint because iterator is assigned
302    let mut set = HashSet::from([1, 2, 3]);
303    let iter = set.drain();
304
305    // Do not lint because iterator is assigned and used
306    let mut set = HashSet::from([1, 2, 3]);
307    let mut iter = set.drain();
308    let next = iter.next();
309
310    // Do not lint because iterator is used
311    let mut set = HashSet::from([1, 2, 3]);
312    let next = set.drain().next();
313
314    // Do lint
315    let mut set = HashSet::from([1, 2, 3]);
316    set.clear();
317}
318
319fn hash_map() {
320    // Do not lint because iterator is assigned
321    let mut map = HashMap::from([(1, "a"), (2, "b")]);
322    let iter = map.drain();
323
324    // Do not lint because iterator is assigned and used
325    let mut map = HashMap::from([(1, "a"), (2, "b")]);
326    let mut iter = map.drain();
327    let next = iter.next();
328
329    // Do not lint because iterator is used
330    let mut map = HashMap::from([(1, "a"), (2, "b")]);
331    let next = map.drain().next();
332
333    // Do lint
334    let mut map = HashMap::from([(1, "a"), (2, "b")]);
335    map.clear();
336}
337
338fn binary_heap() {
339    // Do not lint because iterator is assigned
340    let mut heap = BinaryHeap::from([1, 2]);
341    let iter = heap.drain();
342
343    // Do not lint because iterator is assigned and used
344    let mut heap = BinaryHeap::from([1, 2]);
345    let mut iter = heap.drain();
346    let next = iter.next();
347
348    // Do not lint because iterator is used
349    let mut heap = BinaryHeap::from([1, 2]);
350    let next = heap.drain().next();
351
352    // Do lint
353    let mut heap = BinaryHeap::from([1, 2]);
354    heap.clear();
355}
356
357fn main() {}