mirror of
https://github.com/rust-lang/rust-clippy
synced 2024-11-24 05:33:27 +00:00
590 lines
18 KiB
Text
590 lines
18 KiB
Text
error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
|
|
--> $DIR/for_loop.rs:17:14
|
|
|
|
|
17 | for x in option {
|
|
| ^^^^^^
|
|
|
|
|
= note: `-D for-loop-over-option` implied by `-D warnings`
|
|
= help: consider replacing `for x in option` with `if let Some(x) = option`
|
|
|
|
error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
|
|
--> $DIR/for_loop.rs:22:14
|
|
|
|
|
22 | for x in result {
|
|
| ^^^^^^
|
|
|
|
|
= note: `-D for-loop-over-result` implied by `-D warnings`
|
|
= help: consider replacing `for x in result` with `if let Ok(x) = result`
|
|
|
|
error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
|
|
--> $DIR/for_loop.rs:26:14
|
|
|
|
|
26 | for x in option.ok_or("x not found") {
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
|
= help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
|
|
|
|
error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
|
|
--> $DIR/for_loop.rs:32:5
|
|
|
|
|
32 | / for x in v.iter().next() {
|
|
33 | | println!("{}", x);
|
|
34 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D iter-next-loop` implied by `-D warnings`
|
|
|
|
error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
|
|
--> $DIR/for_loop.rs:37:14
|
|
|
|
|
37 | for x in v.iter().next().and(Some(0)) {
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
|
= help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
|
|
|
|
error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
|
|
--> $DIR/for_loop.rs:41:14
|
|
|
|
|
41 | for x in v.iter().next().ok_or("x not found") {
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
|
= help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
|
|
|
|
error: this loop never actually loops
|
|
--> $DIR/for_loop.rs:53:5
|
|
|
|
|
53 | / while let Some(x) = option {
|
|
54 | | println!("{}", x);
|
|
55 | | break;
|
|
56 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D never-loop` implied by `-D warnings`
|
|
|
|
error: this loop never actually loops
|
|
--> $DIR/for_loop.rs:59:5
|
|
|
|
|
59 | / while let Ok(x) = result {
|
|
60 | | println!("{}", x);
|
|
61 | | break;
|
|
62 | | }
|
|
| |_____^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:86:5
|
|
|
|
|
86 | / for i in 0..vec.len() {
|
|
87 | | println!("{}", vec[i]);
|
|
88 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D needless-range-loop` implied by `-D warnings`
|
|
help: consider using an iterator
|
|
|
|
|
86 | for <item> in &vec {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:95:5
|
|
|
|
|
95 | / for i in 0..vec.len() {
|
|
96 | | let _ = vec[i];
|
|
97 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
95 | for <item> in &vec {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `j` is only used to index `STATIC`.
|
|
--> $DIR/for_loop.rs:100:5
|
|
|
|
|
100 | / for j in 0..4 {
|
|
101 | | println!("{:?}", STATIC[j]);
|
|
102 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
100 | for <item> in STATIC.iter().take(4) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `j` is only used to index `CONST`.
|
|
--> $DIR/for_loop.rs:104:5
|
|
|
|
|
104 | / for j in 0..4 {
|
|
105 | | println!("{:?}", CONST[j]);
|
|
106 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
104 | for <item> in CONST.iter().take(4) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is used to index `vec`
|
|
--> $DIR/for_loop.rs:108:5
|
|
|
|
|
108 | / for i in 0..vec.len() {
|
|
109 | | println!("{} {}", vec[i], i);
|
|
110 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
108 | for (i, <item>) in vec.iter().enumerate() {
|
|
| ^^^^^^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec2`.
|
|
--> $DIR/for_loop.rs:116:5
|
|
|
|
|
116 | / for i in 0..vec.len() {
|
|
117 | | println!("{}", vec2[i]);
|
|
118 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
116 | for <item> in vec2.iter().take(vec.len()) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:120:5
|
|
|
|
|
120 | / for i in 5..vec.len() {
|
|
121 | | println!("{}", vec[i]);
|
|
122 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
120 | for <item> in vec.iter().skip(5) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:124:5
|
|
|
|
|
124 | / for i in 0..MAX_LEN {
|
|
125 | | println!("{}", vec[i]);
|
|
126 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
124 | for <item> in vec.iter().take(MAX_LEN) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:128:5
|
|
|
|
|
128 | / for i in 0...MAX_LEN {
|
|
129 | | println!("{}", vec[i]);
|
|
130 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
128 | for <item> in vec.iter().take(MAX_LEN + 1) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:132:5
|
|
|
|
|
132 | / for i in 5..10 {
|
|
133 | | println!("{}", vec[i]);
|
|
134 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
132 | for <item> in vec.iter().take(10).skip(5) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is only used to index `vec`.
|
|
--> $DIR/for_loop.rs:136:5
|
|
|
|
|
136 | / for i in 5...10 {
|
|
137 | | println!("{}", vec[i]);
|
|
138 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
136 | for <item> in vec.iter().take(10 + 1).skip(5) {
|
|
| ^^^^^^
|
|
|
|
error: the loop variable `i` is used to index `vec`
|
|
--> $DIR/for_loop.rs:140:5
|
|
|
|
|
140 | / for i in 5..vec.len() {
|
|
141 | | println!("{} {}", vec[i], i);
|
|
142 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
140 | for (i, <item>) in vec.iter().enumerate().skip(5) {
|
|
| ^^^^^^^^^^^
|
|
|
|
error: the loop variable `i` is used to index `vec`
|
|
--> $DIR/for_loop.rs:144:5
|
|
|
|
|
144 | / for i in 5..10 {
|
|
145 | | println!("{} {}", vec[i], i);
|
|
146 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using an iterator
|
|
|
|
|
144 | for (i, <item>) in vec.iter().enumerate().take(10).skip(5) {
|
|
| ^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:148:5
|
|
|
|
|
148 | / for i in 10..0 {
|
|
149 | | println!("{}", i);
|
|
150 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D reverse-range-loop` implied by `-D warnings`
|
|
help: consider using the following if you are attempting to iterate over this range in reverse
|
|
|
|
|
148 | for i in (0..10).rev() {
|
|
| ^^^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:152:5
|
|
|
|
|
152 | / for i in 10...0 {
|
|
153 | | println!("{}", i);
|
|
154 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using the following if you are attempting to iterate over this range in reverse
|
|
|
|
|
152 | for i in (0...10).rev() {
|
|
| ^^^^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:156:5
|
|
|
|
|
156 | / for i in MAX_LEN..0 {
|
|
157 | | println!("{}", i);
|
|
158 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using the following if you are attempting to iterate over this range in reverse
|
|
|
|
|
156 | for i in (0..MAX_LEN).rev() {
|
|
| ^^^^^^^^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:160:5
|
|
|
|
|
160 | / for i in 5..5 {
|
|
161 | | println!("{}", i);
|
|
162 | | }
|
|
| |_____^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:185:5
|
|
|
|
|
185 | / for i in 10..5 + 4 {
|
|
186 | | println!("{}", i);
|
|
187 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using the following if you are attempting to iterate over this range in reverse
|
|
|
|
|
185 | for i in (5 + 4..10).rev() {
|
|
| ^^^^^^^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:189:5
|
|
|
|
|
189 | / for i in (5 + 2)..(3 - 1) {
|
|
190 | | println!("{}", i);
|
|
191 | | }
|
|
| |_____^
|
|
|
|
|
help: consider using the following if you are attempting to iterate over this range in reverse
|
|
|
|
|
189 | for i in ((3 - 1)..(5 + 2)).rev() {
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: this range is empty so this for loop will never run
|
|
--> $DIR/for_loop.rs:193:5
|
|
|
|
|
193 | / for i in (5 + 2)..(8 - 1) {
|
|
194 | | println!("{}", i);
|
|
195 | | }
|
|
| |_____^
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:215:15
|
|
|
|
|
215 | for _v in vec.iter() {}
|
|
| ^^^^^^^^^^ help: to write this more concisely, try: `&vec`
|
|
|
|
|
= note: `-D explicit-iter-loop` implied by `-D warnings`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:217:15
|
|
|
|
|
217 | for _v in vec.iter_mut() {}
|
|
| ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
|
|
|
|
error: it is more idiomatic to loop over containers instead of using explicit iteration methods`
|
|
--> $DIR/for_loop.rs:220:15
|
|
|
|
|
220 | for _v in out_vec.into_iter() {}
|
|
| ^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `out_vec`
|
|
|
|
|
= note: `-D explicit-into-iter-loop` implied by `-D warnings`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:223:15
|
|
|
|
|
223 | for _v in array.into_iter() {}
|
|
| ^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&array`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:228:15
|
|
|
|
|
228 | for _v in [1, 2, 3].iter() {}
|
|
| ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:232:15
|
|
|
|
|
232 | for _v in [0; 32].iter() {}
|
|
| ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:237:15
|
|
|
|
|
237 | for _v in ll.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&ll`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:240:15
|
|
|
|
|
240 | for _v in vd.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&vd`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:243:15
|
|
|
|
|
243 | for _v in bh.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&bh`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:246:15
|
|
|
|
|
246 | for _v in hm.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&hm`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:249:15
|
|
|
|
|
249 | for _v in bt.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&bt`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:252:15
|
|
|
|
|
252 | for _v in hs.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&hs`
|
|
|
|
error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
|
|
--> $DIR/for_loop.rs:255:15
|
|
|
|
|
255 | for _v in bs.iter() {}
|
|
| ^^^^^^^^^ help: to write this more concisely, try: `&bs`
|
|
|
|
error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
|
|
--> $DIR/for_loop.rs:257:5
|
|
|
|
|
257 | for _v in vec.iter().next() {}
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: you are collect()ing an iterator and throwing away the result. Consider using an explicit for loop to exhaust the iterator
|
|
--> $DIR/for_loop.rs:264:5
|
|
|
|
|
264 | vec.iter().cloned().map(|x| out.push(x)).collect::<Vec<_>>();
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
|
= note: `-D unused-collect` implied by `-D warnings`
|
|
|
|
error: the variable `_index` is used as a loop counter. Consider using `for (_index, item) in &vec.enumerate()` or similar iterators
|
|
--> $DIR/for_loop.rs:269:5
|
|
|
|
|
269 | / for _v in &vec {
|
|
270 | | _index += 1
|
|
271 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D explicit-counter-loop` implied by `-D warnings`
|
|
|
|
error: the variable `_index` is used as a loop counter. Consider using `for (_index, item) in &vec.enumerate()` or similar iterators
|
|
--> $DIR/for_loop.rs:275:5
|
|
|
|
|
275 | / for _v in &vec {
|
|
276 | | _index += 1
|
|
277 | | }
|
|
| |_____^
|
|
|
|
error: you seem to want to iterate on a map's values
|
|
--> $DIR/for_loop.rs:385:5
|
|
|
|
|
385 | / for (_, v) in &m {
|
|
386 | | let _v = v;
|
|
387 | | }
|
|
| |_____^
|
|
|
|
|
= note: `-D for-kv-map` implied by `-D warnings`
|
|
help: use the corresponding method
|
|
|
|
|
385 | for v in m.values() {
|
|
| ^
|
|
|
|
error: you seem to want to iterate on a map's values
|
|
--> $DIR/for_loop.rs:390:5
|
|
|
|
|
390 | / for (_, v) in &*m {
|
|
391 | | let _v = v;
|
|
392 | | // Here the `*` is not actually necesarry, but the test tests that we don't
|
|
393 | | // suggest
|
|
394 | | // `in *m.values()` as we used to
|
|
395 | | }
|
|
| |_____^
|
|
|
|
|
help: use the corresponding method
|
|
|
|
|
390 | for v in (*m).values() {
|
|
| ^
|
|
|
|
error: you seem to want to iterate on a map's values
|
|
--> $DIR/for_loop.rs:398:5
|
|
|
|
|
398 | / for (_, v) in &mut m {
|
|
399 | | let _v = v;
|
|
400 | | }
|
|
| |_____^
|
|
|
|
|
help: use the corresponding method
|
|
|
|
|
398 | for v in m.values_mut() {
|
|
| ^
|
|
|
|
error: you seem to want to iterate on a map's values
|
|
--> $DIR/for_loop.rs:403:5
|
|
|
|
|
403 | / for (_, v) in &mut *m {
|
|
404 | | let _v = v;
|
|
405 | | }
|
|
| |_____^
|
|
|
|
|
help: use the corresponding method
|
|
|
|
|
403 | for v in (*m).values_mut() {
|
|
| ^
|
|
|
|
error: you seem to want to iterate on a map's keys
|
|
--> $DIR/for_loop.rs:409:5
|
|
|
|
|
409 | / for (k, _value) in rm {
|
|
410 | | let _k = k;
|
|
411 | | }
|
|
| |_____^
|
|
|
|
|
help: use the corresponding method
|
|
|
|
|
409 | for k in rm.keys() {
|
|
| ^
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:462:5
|
|
|
|
|
462 | / for i in 0..src.len() {
|
|
463 | | dst[i] = src[i];
|
|
464 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
|
|
|
|
|
= note: `-D manual-memcpy` implied by `-D warnings`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:467:5
|
|
|
|
|
467 | / for i in 0..src.len() {
|
|
468 | | dst[i + 10] = src[i];
|
|
469 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[10..(src.len() + 10)].clone_from_slice(&src[..])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:472:5
|
|
|
|
|
472 | / for i in 0..src.len() {
|
|
473 | | dst[i] = src[i + 10];
|
|
474 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[10..])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:477:5
|
|
|
|
|
477 | / for i in 11..src.len() {
|
|
478 | | dst[i] = src[i - 10];
|
|
479 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[11..src.len()].clone_from_slice(&src[(11 - 10)..(src.len() - 10)])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:482:5
|
|
|
|
|
482 | / for i in 0..dst.len() {
|
|
483 | | dst[i] = src[i];
|
|
484 | | }
|
|
| |_____^ help: try replacing the loop by: `dst.clone_from_slice(&src[..dst.len()])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:495:5
|
|
|
|
|
495 | / for i in 10..256 {
|
|
496 | | dst[i] = src[i - 5];
|
|
497 | | dst2[i + 500] = src[i]
|
|
498 | | }
|
|
| |_____^
|
|
|
|
|
help: try replacing the loop by
|
|
|
|
|
495 | dst[10..256].clone_from_slice(&src[(10 - 5)..(256 - 5)])
|
|
496 | dst2[(10 + 500)..(256 + 500)].clone_from_slice(&src[10..256])
|
|
|
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:507:5
|
|
|
|
|
507 | / for i in 10..LOOP_OFFSET {
|
|
508 | | dst[i + LOOP_OFFSET] = src[i - some_var];
|
|
509 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].clone_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:520:5
|
|
|
|
|
520 | / for i in 0..src_vec.len() {
|
|
521 | | dst_vec[i] = src_vec[i];
|
|
522 | | }
|
|
| |_____^ help: try replacing the loop by: `dst_vec[..src_vec.len()].clone_from_slice(&src_vec[..])`
|
|
|
|
error: it looks like you're manually copying between slices
|
|
--> $DIR/for_loop.rs:547:5
|
|
|
|
|
547 | / for i in 0..src.len() {
|
|
548 | | dst[i] = src[i].clone();
|
|
549 | | }
|
|
| |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
|
|
|
|
error: aborting due to 59 previous errors
|
|
|