1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#![feature(plugin)]
#![plugin(clippy)]
#![deny(while_let_loop, empty_loop, while_let_on_iterator)]
#![allow(dead_code, unused, cyclomatic_complexity)]
fn main() {
let y = Some(true);
loop {
//~^ERROR this loop could be written as a `while let` loop
//~|HELP try
//~|SUGGESTION while let Some(_x) = y {
if let Some(_x) = y {
let _v = 1;
} else {
break
}
}
loop { // no error, break is not in else clause
if let Some(_x) = y {
let _v = 1;
}
break;
}
loop {
//~^ERROR this loop could be written as a `while let` loop
//~|HELP try
//~|SUGGESTION while let Some(_x) = y {
match y {
Some(_x) => true,
None => break
};
}
loop {
//~^ERROR this loop could be written as a `while let` loop
//~|HELP try
//~|SUGGESTION while let Some(x) = y {
let x = match y {
Some(x) => x,
None => break
};
let _x = x;
let _str = "foo";
}
loop {
//~^ERROR this loop could be written as a `while let` loop
//~|HELP try
//~|SUGGESTION while let Some(x) = y {
let x = match y {
Some(x) => x,
None => break,
};
{ let _a = "bar"; };
{ let _b = "foobar"; }
}
loop { // no error, else branch does something other than break
match y {
Some(_x) => true,
_ => {
let _z = 1;
break;
}
};
}
while let Some(x) = y { // no error, obviously
println!("{}", x);
}
// #675, this used to have a wrong suggestion
loop {
//~^ERROR this loop could be written as a `while let` loop
//~|HELP try
//~|SUGGESTION while let Some(word) = "".split_whitespace().next() { .. }
let (e, l) = match "".split_whitespace().next() {
Some(word) => (word.is_empty(), word.len()),
None => break
};
let _ = (e, l);
}
let mut iter = 1..20;
while let Option::Some(x) = iter.next() { //~ERROR this loop could be written as a `for` loop
println!("{}", x);
}
let mut iter = 1..20;
while let Some(x) = iter.next() { //~ERROR this loop could be written as a `for` loop
println!("{}", x);
}
let mut iter = 1..20;
while let Some(_) = iter.next() {} //~ERROR this loop could be written as a `for` loop
let mut iter = 1..20;
while let None = iter.next() {} // this is fine (if nonsensical)
let mut iter = 1..20;
if let Some(x) = iter.next() { // also fine
println!("{}", x)
}
// the following shouldn't warn because it can't be written with a for loop
let mut iter = 1u32..20;
while let Some(x) = iter.next() {
println!("next: {:?}", iter.next())
}
// neither can this
let mut iter = 1u32..20;
while let Some(x) = iter.next() {
println!("next: {:?}", iter.next());
}
// or this
let mut iter = 1u32..20;
while let Some(x) = iter.next() {break;}
println!("Remaining iter {:?}", iter);
// or this
let mut iter = 1u32..20;
while let Some(x) = iter.next() {
iter = 1..20;
}
}
// regression test (#360)
// this should not panic
// it's okay if further iterations of the lint
// cause this function to trigger it
fn no_panic<T>(slice: &[T]) {
let mut iter = slice.iter();
loop { //~ERROR
let _ = match iter.next() {
Some(ele) => ele,
None => break
};
loop {} //~ERROR empty `loop {}` detected.
}
}