]>
Commit | Line | Data |
---|---|---|
f20569fa XL |
1 | // run-rustfix |
2 | ||
3 | #![allow(dead_code, unused)] | |
4 | ||
5 | use std::collections::*; | |
6 | ||
7 | #[warn(clippy::all)] | |
8 | struct Unrelated(Vec<u8>); | |
9 | impl Unrelated { | |
10 | fn next(&self) -> std::slice::Iter<u8> { | |
11 | self.0.iter() | |
12 | } | |
13 | ||
14 | fn iter(&self) -> std::slice::Iter<u8> { | |
15 | self.0.iter() | |
16 | } | |
17 | } | |
18 | ||
19 | #[warn( | |
20 | clippy::needless_range_loop, | |
21 | clippy::explicit_iter_loop, | |
22 | clippy::explicit_into_iter_loop, | |
23 | clippy::iter_next_loop, | |
24 | clippy::for_kv_map | |
25 | )] | |
26 | #[allow( | |
27 | clippy::linkedlist, | |
28 | clippy::shadow_unrelated, | |
29 | clippy::unnecessary_mut_passed, | |
30 | clippy::similar_names | |
31 | )] | |
32 | #[allow(clippy::many_single_char_names, unused_variables)] | |
33 | fn main() { | |
34 | let mut vec = vec![1, 2, 3, 4]; | |
35 | ||
36 | // See #601 | |
37 | for i in 0..10 { | |
38 | // no error, id_col does not exist outside the loop | |
39 | let mut id_col = vec![0f64; 10]; | |
40 | id_col[i] = 1f64; | |
41 | } | |
42 | ||
43 | for _v in vec.iter() {} | |
44 | ||
45 | for _v in vec.iter_mut() {} | |
46 | ||
47 | let out_vec = vec![1, 2, 3]; | |
48 | for _v in out_vec.into_iter() {} | |
49 | ||
50 | for _v in &vec {} // these are fine | |
51 | for _v in &mut vec {} // these are fine | |
52 | ||
53 | for _v in [1, 2, 3].iter() {} | |
54 | ||
55 | for _v in (&mut [1, 2, 3]).iter() {} // no error | |
56 | ||
57 | for _v in [0; 32].iter() {} | |
58 | ||
59 | for _v in [0; 33].iter() {} // no error | |
60 | ||
61 | let ll: LinkedList<()> = LinkedList::new(); | |
62 | for _v in ll.iter() {} | |
63 | ||
64 | let vd: VecDeque<()> = VecDeque::new(); | |
65 | for _v in vd.iter() {} | |
66 | ||
67 | let bh: BinaryHeap<()> = BinaryHeap::new(); | |
68 | for _v in bh.iter() {} | |
69 | ||
70 | let hm: HashMap<(), ()> = HashMap::new(); | |
71 | for _v in hm.iter() {} | |
72 | ||
73 | let bt: BTreeMap<(), ()> = BTreeMap::new(); | |
74 | for _v in bt.iter() {} | |
75 | ||
76 | let hs: HashSet<()> = HashSet::new(); | |
77 | for _v in hs.iter() {} | |
78 | ||
79 | let bs: BTreeSet<()> = BTreeSet::new(); | |
80 | for _v in bs.iter() {} | |
81 | ||
82 | let u = Unrelated(vec![]); | |
83 | for _v in u.next() {} // no error | |
84 | for _v in u.iter() {} // no error | |
85 | ||
86 | let mut out = vec![]; | |
87 | vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>(); | |
88 | let _y = vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>(); // this is fine | |
89 | ||
90 | // Loop with explicit counter variable | |
91 | ||
92 | // Potential false positives | |
93 | let mut _index = 0; | |
94 | _index = 1; | |
95 | for _v in &vec { | |
96 | _index += 1 | |
97 | } | |
98 | ||
99 | let mut _index = 0; | |
100 | _index += 1; | |
101 | for _v in &vec { | |
102 | _index += 1 | |
103 | } | |
104 | ||
105 | let mut _index = 0; | |
106 | if true { | |
107 | _index = 1 | |
108 | } | |
109 | for _v in &vec { | |
110 | _index += 1 | |
111 | } | |
112 | ||
113 | let mut _index = 0; | |
114 | let mut _index = 1; | |
115 | for _v in &vec { | |
116 | _index += 1 | |
117 | } | |
118 | ||
119 | let mut _index = 0; | |
120 | for _v in &vec { | |
121 | _index += 1; | |
122 | _index += 1 | |
123 | } | |
124 | ||
125 | let mut _index = 0; | |
126 | for _v in &vec { | |
127 | _index *= 2; | |
128 | _index += 1 | |
129 | } | |
130 | ||
131 | let mut _index = 0; | |
132 | for _v in &vec { | |
133 | _index = 1; | |
134 | _index += 1 | |
135 | } | |
136 | ||
137 | let mut _index = 0; | |
138 | ||
139 | for _v in &vec { | |
140 | let mut _index = 0; | |
141 | _index += 1 | |
142 | } | |
143 | ||
144 | let mut _index = 0; | |
145 | for _v in &vec { | |
146 | _index += 1; | |
147 | _index = 0; | |
148 | } | |
149 | ||
150 | let mut _index = 0; | |
151 | for _v in &vec { | |
152 | for _x in 0..1 { | |
153 | _index += 1; | |
154 | } | |
155 | _index += 1 | |
156 | } | |
157 | ||
158 | let mut _index = 0; | |
159 | for x in &vec { | |
160 | if *x == 1 { | |
161 | _index += 1 | |
162 | } | |
163 | } | |
164 | ||
165 | let mut _index = 0; | |
166 | if true { | |
167 | _index = 1 | |
168 | }; | |
169 | for _v in &vec { | |
170 | _index += 1 | |
171 | } | |
172 | ||
173 | let mut _index = 1; | |
174 | if false { | |
175 | _index = 0 | |
176 | }; | |
177 | for _v in &vec { | |
178 | _index += 1 | |
179 | } | |
180 | ||
181 | let mut index = 0; | |
182 | { | |
183 | let mut _x = &mut index; | |
184 | } | |
185 | for _v in &vec { | |
186 | _index += 1 | |
187 | } | |
188 | ||
189 | let mut index = 0; | |
190 | for _v in &vec { | |
191 | index += 1 | |
192 | } | |
193 | println!("index: {}", index); | |
194 | ||
195 | fn f<T>(_: &T, _: &T) -> bool { | |
196 | unimplemented!() | |
197 | } | |
198 | fn g<T>(_: &mut [T], _: usize, _: usize) { | |
199 | unimplemented!() | |
200 | } | |
201 | for i in 1..vec.len() { | |
202 | if f(&vec[i - 1], &vec[i]) { | |
203 | g(&mut vec, i - 1, i); | |
204 | } | |
205 | } | |
206 | ||
207 | for mid in 1..vec.len() { | |
208 | let (_, _) = vec.split_at(mid); | |
209 | } | |
210 | } | |
211 | ||
212 | fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize { | |
213 | let pivot = v.len() - 1; | |
214 | let mut i = 0; | |
215 | for j in 0..pivot { | |
216 | if v[j] <= v[pivot] { | |
217 | v.swap(i, j); | |
218 | i += 1; | |
219 | } | |
220 | } | |
221 | v.swap(i, pivot); | |
222 | i | |
223 | } | |
224 | ||
225 | #[warn(clippy::needless_range_loop)] | |
226 | pub fn manual_copy_same_destination(dst: &mut [i32], d: usize, s: usize) { | |
227 | // Same source and destination - don't trigger lint | |
228 | for i in 0..dst.len() { | |
229 | dst[d + i] = dst[s + i]; | |
230 | } | |
231 | } | |
232 | ||
233 | mod issue_2496 { | |
234 | pub trait Handle { | |
235 | fn new_for_index(index: usize) -> Self; | |
236 | fn index(&self) -> usize; | |
237 | } | |
238 | ||
239 | pub fn test<H: Handle>() -> H { | |
240 | for x in 0..5 { | |
241 | let next_handle = H::new_for_index(x); | |
242 | println!("{}", next_handle.index()); | |
243 | } | |
244 | unimplemented!() | |
245 | } | |
246 | } | |
247 | ||
248 | // explicit_into_iter_loop bad suggestions | |
249 | #[warn(clippy::explicit_into_iter_loop, clippy::explicit_iter_loop)] | |
250 | mod issue_4958 { | |
251 | fn takes_iterator<T>(iterator: &T) | |
252 | where | |
253 | for<'a> &'a T: IntoIterator<Item = &'a String>, | |
254 | { | |
255 | for i in iterator.into_iter() { | |
256 | println!("{}", i); | |
257 | } | |
258 | } | |
259 | ||
260 | struct T; | |
261 | impl IntoIterator for &T { | |
262 | type Item = (); | |
263 | type IntoIter = std::vec::IntoIter<Self::Item>; | |
264 | fn into_iter(self) -> Self::IntoIter { | |
265 | vec![].into_iter() | |
266 | } | |
267 | } | |
268 | ||
269 | fn more_tests() { | |
270 | let t = T; | |
271 | let r = &t; | |
272 | let rr = &&t; | |
273 | ||
274 | // This case is handled by `explicit_iter_loop`. No idea why. | |
275 | for _ in t.into_iter() {} | |
276 | ||
277 | for _ in r.into_iter() {} | |
278 | ||
279 | // No suggestion for this. | |
280 | // We'd have to suggest `for _ in *rr {}` which is less clear. | |
281 | for _ in rr.into_iter() {} | |
282 | } | |
283 | } |