Closed
Description
Proposal: desugar the Some
branch a for
loop to Some(value) => { let <pattern> = value; ...
, rather than Some(<pattern>) => { ...
as we do now.
#[cfg(normal)]
fn main() {
for &1 in [1].iter() {}
}
// expanded forms:
#[cfg(now)]
fn main() {
match &mut [1].iter() {
it => {
loop {
match it.next() {
None => break,
Some(&1) => {}
}
}
}
}
}
#[cfg(future)]
fn main() {
match &mut [1].iter() {
it => {
loop {
match it.next() {
None => break,
Some(value) => {
let &1 = value;
}
}
}
}
}
}
$ rustc patterns.rs --cfg normal
patterns.rs:3:5: 4:2 error: non-exhaustive patterns
patterns.rs:3 for &1 in [1].iter() {}
patterns.rs:4 }
error: aborting due to previous error
$ rustc patterns.rs --cfg now
patterns.rs:11:17: 14:18 error: non-exhaustive patterns
patterns.rs:11 match it.next() {
patterns.rs:12 None => break,
patterns.rs:13 Some(&1) => {}
patterns.rs:14 }
error: aborting due to previous error
$ rustc patterns.rs --cfg future
patterns.rs:28:29: 28:31 error: refutable pattern in local binding
patterns.rs:28 let &1 = value;
^~
error: aborting due to previous error
Using the let
version would give two advantages:
- mentions that the pattern is refutable
- allows the span of the error to point exactly at the pattern, rather than the whole
for
loop (annoying for beginners if thefor
has a large body).