`continue` expressions in loop conditions

[raimondsrainskis]

Location

https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions

Summary

The reference unambiguously states that "A continue expression is only permitted in the body of a loop.", but this is demonstrably not true for continue 'label expressions.

The following compiles and runs an infinite loop. A warning mentions the body being unreachable, but otherwise the behavior is as one would expect:

'a: while continue 'a {}

Meanwhile, the following does not compile:

while { continue; true } {}

In the second example, an error is generated:

error[E0590]: break or continue with no label in the condition of a while loop

Furthermore, rustc --explain E0590 demonstrates label usage with a break expression:

'foo: while break 'foo {}

---

Unless I have misunderstood something, there seems to be conflicting information between the reference and the actual behavior of the compiler.

Edit: grammar.

[traviscross]

Personally, I wouldn't expect us to accept 'a: while continue 'a {} unless we were to also accept 'a: { continue 'a }.

[theemathas]

See also #121623, where rust doesn't properly handle 'a: { continue 'a }

[theemathas]

Edit: This has been filed as a separate issue: #141274

Another interesting case:

fn main() {
    let x: i32;
    'a: while {
        while break 'a {}
        println!("{}", x);  // uninitialized variable!
        true  // removing this gives a type error
    } {}
}

This code compiles, but removing the true expression makes the code not compile. This is strange, because:

• Since we can use uninitialized variables after the break, it seems that rustc realizes that the break causes the whole block to diverge.
• Usually, with most diverging blocks, rustc doesn't check if the last expression has the right type.

For comparison, this compiles:

fn main() {
    let x: i32;
    'a: while {
        if break 'a {}
        println!("{}", x);  // uninitialized variable!
        // No need to write `true` here
    } {}
}

[traviscross]

@rustbot labels -I-lang-nominated +I-lang-radar -P-lang-drag-3

We talked about this today in triage briefly.

Probably I would prefer to make this consistent by allowing backward jumps to labels, generally, within labeled blocks, just as we allow forward jumps to labels (i.e. 'a: { continue 'a }). Probably the next step is for someone to write that up and propose it.