rust-clippy/tests/ui/for_loop.stderr

error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
  --> $DIR/for_loop.rs:18:14
   |
18 |     for x in option {
   |              ^^^^^^
   |
   = note: #[deny(for_loop_over_option)] implied by #[deny(clippy)]
note: lint level defined here
  --> $DIR/for_loop.rs:10:8
   |
10 | #[deny(clippy)]
   |        ^^^^^^
   = 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:26:14
   |
26 |     for x in result {
   |              ^^^^^^
   |
   = note: #[deny(for_loop_over_result)] implied by #[deny(clippy)]
note: lint level defined here
  --> $DIR/for_loop.rs:10:8
   |
10 | #[deny(clippy)]
   |        ^^^^^^
   = 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:32:14
   |
32 |     for x in option.ok_or("x not found") {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: #[deny(for_loop_over_result)] implied by #[deny(clippy)]
   = 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:40:5
   |
40 | /     for x in v.iter().next() {
41 | |
42 | |         println!("{}", x);
43 | |     }
   | |_____^
   |
   = note: #[deny(iter_next_loop)] implied by #[deny(clippy)]
note: lint level defined here
  --> $DIR/for_loop.rs:10:8
   |
10 | #[deny(clippy)]
   |        ^^^^^^

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:47:14
   |
47 |     for x in v.iter().next().and(Some(0)) {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: #[deny(for_loop_over_option)] implied by #[deny(clippy)]
   = 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:53:14
   |
53 |     for x in v.iter().next().ok_or("x not found") {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: #[deny(for_loop_over_result)] implied by #[deny(clippy)]
   = 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: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:99:5
    |
99  | /     for i in 0..vec.len() {
100 | |
101 | |
102 | |
103 | |
104 | |         println!("{}", vec[i]);
105 | |     }
    | |_____^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:8
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |        ^^^^^^^^^^^^^^^^^^^
help: consider using an iterator
    |     for <item> in &vec {

warning: unused variable: `i`
   --> $DIR/for_loop.rs:107:9
    |
107 |     for i in 0..vec.len() {
    |         ^
    |
    = note: #[warn(unused_variables)] on by default

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:113:5
    |
113 |     for i in 0..vec.len() { let _ = vec[i]; }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider using an iterator
    |     for <item> in &vec { let _ = vec[i]; }

error: the loop variable `j` is only used to index `STATIC`.
   --> $DIR/for_loop.rs:120:5
    |
120 | /     for j in 0..4 {
121 | |
122 | |
123 | |
124 | |
125 | |         println!("{:?}", STATIC[j]);
126 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in STATIC.iter().take(4) {

error: the loop variable `j` is only used to index `CONST`.
   --> $DIR/for_loop.rs:128:5
    |
128 | /     for j in 0..4 {
129 | |
130 | |
131 | |
132 | |
133 | |         println!("{:?}", CONST[j]);
134 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in CONST.iter().take(4) {

error: the loop variable `i` is used to index `vec`
   --> $DIR/for_loop.rs:136:5
    |
136 | /     for i in 0..vec.len() {
137 | |
138 | |
139 | |
140 | |
141 | |         println!("{} {}", vec[i], i);
142 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for (i, <item>) in vec.iter().enumerate() {

error: the loop variable `i` is only used to index `vec2`.
   --> $DIR/for_loop.rs:147:5
    |
147 | /     for i in 0..vec.len() {
148 | |
149 | |
150 | |
151 | |
152 | |         println!("{}", vec2[i]);
153 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec2.iter().take(vec.len()) {

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:155:5
    |
155 | /     for i in 5..vec.len() {
156 | |
157 | |
158 | |
159 | |
160 | |         println!("{}", vec[i]);
161 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec.iter().skip(5) {

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:163:5
    |
163 | /     for i in 0..MAX_LEN {
164 | |
165 | |
166 | |
167 | |
168 | |         println!("{}", vec[i]);
169 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec.iter().take(MAX_LEN) {

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:171:5
    |
171 | /     for i in 0...MAX_LEN {
172 | |
173 | |
174 | |
175 | |
176 | |         println!("{}", vec[i]);
177 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec.iter().take(MAX_LEN + 1) {

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:179:5
    |
179 | /     for i in 5..10 {
180 | |
181 | |
182 | |
183 | |
184 | |         println!("{}", vec[i]);
185 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec.iter().take(10).skip(5) {

error: the loop variable `i` is only used to index `vec`.
   --> $DIR/for_loop.rs:187:5
    |
187 | /     for i in 5...10 {
188 | |
189 | |
190 | |
191 | |
192 | |         println!("{}", vec[i]);
193 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for <item> in vec.iter().take(10 + 1).skip(5) {

error: the loop variable `i` is used to index `vec`
   --> $DIR/for_loop.rs:195:5
    |
195 | /     for i in 5..vec.len() {
196 | |
197 | |
198 | |
199 | |
200 | |         println!("{} {}", vec[i], i);
201 | |     }
    | |_____^
    |
help: consider using an iterator
    |     for (i, <item>) in vec.iter().enumerate().skip(5) {

error: the loop variable `i` is used to index `vec`
   --> $DIR/for_loop.rs:203:5
    |
203 | /     for i in 5..10 {
204 | |
205 | |
206 | |
207 | |
208 | |         println!("{} {}", vec[i], i);
209 | |     }
    | |_____^
    |
help: consider using an iterator
    |     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:211:5
    |
211 | /     for i in 10..0 {
212 | |
213 | |
214 | |
215 | |         println!("{}", i);
216 | |     }
    | |_____^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:90
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                                                                                          ^^^^^^^^^^^^^^^^^^
help: consider using the following if you are attempting to iterate over this range in reverse
    |     for i in (0..10).rev() {

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:218:5
    |
218 | /     for i in 10...0 {
219 | |
220 | |
221 | |
222 | |         println!("{}", i);
223 | |     }
    | |_____^
    |
help: consider using the following if you are attempting to iterate over this range in reverse
    |     for i in (0...10).rev() {

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:225:5
    |
225 | /     for i in MAX_LEN..0 {
226 | |
227 | |
228 | |         println!("{}", i);
229 | |     }
    | |_____^
    |
help: consider using the following if you are attempting to iterate over this range in reverse
    |     for i in (0..MAX_LEN).rev() {

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:231:5
    |
231 | /     for i in 5..5 {
232 | |         println!("{}", i);
233 | |     }
    | |_____^

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:252:5
    |
252 | /     for i in 10..5+4 {
253 | |
254 | |
255 | |
256 | |         println!("{}", i);
257 | |     }
    | |_____^
    |
help: consider using the following if you are attempting to iterate over this range in reverse
    |     for i in (5+4..10).rev() {

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:259:5
    |
259 | /     for i in (5+2)..(3-1) {
260 | |
261 | |
262 | |
263 | |         println!("{}", i);
264 | |     }
    | |_____^
    |
help: consider using the following if you are attempting to iterate over this range in reverse
    |     for i in ((3-1)..(5+2)).rev() {

error: this range is empty so this for loop will never run
   --> $DIR/for_loop.rs:266:5
    |
266 | /     for i in (5+2)..(8-1) {
267 | |         println!("{}", i);
268 | |     }
    | |_____^

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:289:15
    |
289 |     for _v in vec.iter() { }
    |               ^^^^^^^^^^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:29
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                             ^^^^^^^^^^^^^^^^^^
help: to write this more concisely, try
    |     for _v in &vec { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:294:15
    |
294 |     for _v in vec.iter_mut() { }
    |               ^^^^^^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &mut vec { }

error: it is more idiomatic to loop over containers instead of using explicit iteration methods`
   --> $DIR/for_loop.rs:300:15
    |
300 |     for _v in out_vec.into_iter() { }
    |               ^^^^^^^^^^^^^^^^^^^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:49
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
help: to write this more concisely, try
    |     for _v in out_vec { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:306:15
    |
306 |     for _v in array.into_iter() {}
    |               ^^^^^^^^^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &array {}

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:311:15
    |
311 |     for _v in [1, 2, 3].iter() { }
    |               ^^^^^^^^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &[1, 2, 3] { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:318:15
    |
318 |     for _v in [0; 32].iter() {}
    |               ^^^^^^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &[0; 32] {}

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:326:15
    |
326 |     for _v in ll.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &ll { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:332:15
    |
332 |     for _v in vd.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &vd { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:338:15
    |
338 |     for _v in bh.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &bh { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:344:15
    |
344 |     for _v in hm.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &hm { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:350:15
    |
350 |     for _v in bt.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &bt { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:356:15
    |
356 |     for _v in hs.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &hs { }

error: it is more idiomatic to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop.rs:362:15
    |
362 |     for _v in bs.iter() { }
    |               ^^^^^^^^^
    |
help: to write this more concisely, try
    |     for _v in &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:368:5
    |
368 |     for _v in vec.iter().next() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:74
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                                                                          ^^^^^^^^^^^^^^

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:375:5
    |
375 |     vec.iter().map(|x| out.push(x)).collect::<Vec<_>>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:91:8
    |
91  | #[deny(unused_collect)]
    |        ^^^^^^^^^^^^^^

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:380:5
    |
380 |     for _v in &vec { _index += 1 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:110
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                                                                                                              ^^^^^^^^^^^^^^^^^^^^^

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:384:5
    |
384 |     for _v in &vec { _index += 1 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: you seem to want to iterate on a map's values
   --> $DIR/for_loop.rs:444:5
    |
444 | /     for (_, v) in &m {
445 | |
446 | |
447 | |
448 | |
449 | |         let _v = v;
450 | |     }
    | |_____^
    |
note: lint level defined here
   --> $DIR/for_loop.rs:90:133
    |
90  | #[deny(needless_range_loop, explicit_iter_loop, explicit_into_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop, for_kv_map)]
    |                                                                                                                                     ^^^^^^^^^^
help: use the corresponding method
    |     for v in m.values() {

error: you seem to want to iterate on a map's values
   --> $DIR/for_loop.rs:453:5
    |
453 | /     for (_, v) in &*m {
454 | |
455 | |
456 | |
...   |
460 | |         // `in *m.values()` as we used to
461 | |     }
    | |_____^
    |
help: use the corresponding method
    |     for v in (*m).values() {

error: you seem to want to iterate on a map's values
   --> $DIR/for_loop.rs:464:5
    |
464 | /     for (_, v) in &mut m {
465 | |
466 | |
467 | |
468 | |
469 | |         let _v = v;
470 | |     }
    | |_____^
    |
help: use the corresponding method
    |     for v in m.values_mut() {

error: you seem to want to iterate on a map's values
   --> $DIR/for_loop.rs:473:5
    |
473 | /     for (_, v) in &mut *m {
474 | |
475 | |
476 | |
477 | |
478 | |         let _v = v;
479 | |     }
    | |_____^
    |
help: use the corresponding method
    |     for v in (*m).values_mut() {

error: you seem to want to iterate on a map's keys
   --> $DIR/for_loop.rs:483:5
    |
483 | /     for (k, _value) in rm {
484 | |
485 | |
486 | |
487 | |
488 | |         let _k = k;
489 | |     }
    | |_____^
    |
help: use the corresponding method
    |     for k in rm.keys() {

error: aborting due to 48 previous errors