rust/tests/ui/parser/bad-let-else-statement.stderr

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:10:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = ({
LL |
LL |         1
LL ~     }) else {
   |

error: `for...else` loops are not supported
  --> $DIR/bad-let-else-statement.rs:19:7
   |
LL |       let foo = for i in 1..2 {
   |                 --- `else` is attached to this loop
LL |           break;
LL |       } else {
   |  _______^
LL | |
LL | |         return;
LL | |     };
   | |_____^
   |
   = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:31:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = (if true {
LL |
 ...
LL |         0
LL ~     }) else {
   |

error: `loop...else` loops are not supported
  --> $DIR/bad-let-else-statement.rs:40:7
   |
LL |       let foo = loop {
   |                 ---- `else` is attached to this loop
LL |           break;
LL |       } else {
   |  _______^
LL | |
LL | |         return;
LL | |     };
   | |_____^
   |
   = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:51:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = (match true {
LL |
LL |         true => 1,
LL |         false => 0
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:62:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = (X {
LL |
LL |         a: 1
LL ~     }) else {
   |

error: `while...else` loops are not supported
  --> $DIR/bad-let-else-statement.rs:71:7
   |
LL |       let foo = while false {
   |                 ----- `else` is attached to this loop
LL |           break;
LL |       } else {
   |  _______^
LL | |
LL | |         return;
LL | |     };
   | |_____^
   |
   = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:81:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = (const {
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:91:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = &({
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:102:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = bar = ({
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:112:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = 1 + ({
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:122:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = 1..({
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:132:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = return ({
LL |
LL |         ()
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:142:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = -({
LL |
LL |         1
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:152:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = do yeet ({
LL |
LL |         ()
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:162:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = become ({
LL |
LL |         ()
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:172:5
   |
LL |     } else {
   |     ^
   |
help: wrap the expression in parentheses
   |
LL ~     let foo = |x: i32| ({
LL |
LL |         x
LL ~     }) else {
   |

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:182:31
   |
LL |     let bad = format_args! {""} else { return; };
   |                               ^
   |
help: use parentheses instead of braces for this macro
   |
LL |     let bad = format_args! ("") else { return; };
   |                            ~  ~

error: right curly brace `}` before `else` in a `let...else` statement not allowed
  --> $DIR/bad-let-else-statement.rs:199:25
   |
LL |             let x = a! {} else { return; };
   |                         ^
...
LL |     b!(1); b!(2);
   |            ----- in this macro invocation
   |
   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
help: use parentheses instead of braces for this macro
   |
LL |             let x = a! () else { return; };
   |                        ~~

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:7:5
   |
LL | /     let foo = {
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause
   = note: `#[warn(irrefutable_let_patterns)]` on by default

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:26:5
   |
LL | /     let foo = if true {
LL | |
LL | |         1
LL | |     } else {
LL | |         0
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:47:5
   |
LL | /     let foo = match true {
LL | |
LL | |         true => 1,
LL | |         false => 0
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:59:5
   |
LL | /     let foo = X {
LL | |
LL | |         a: 1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:78:5
   |
LL | /     let foo = const {
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:88:5
   |
LL | /     let foo = &{
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:99:5
   |
LL | /     let foo = bar = {
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

error[E0384]: cannot assign twice to immutable variable `bar`
  --> $DIR/bad-let-else-statement.rs:99:15
   |
LL |       let bar = 0;
   |           ---
   |           |
   |           first assignment to `bar`
   |           help: consider making this binding mutable: `mut bar`
LL |       let foo = bar = {
   |  _______________^
LL | |
LL | |         1
LL | |     } else {
   | |_____^ cannot assign twice to immutable variable

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:109:5
   |
LL | /     let foo = 1 + {
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:119:5
   |
LL | /     let foo = 1..{
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:129:5
   |
LL | /     let foo = return {
LL | |
LL | |         ()
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:139:5
   |
LL | /     let foo = -{
LL | |
LL | |         1
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:149:5
   |
LL | /     let foo = do yeet {
LL | |
LL | |         ()
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:159:5
   |
LL | /     let foo = become {
LL | |
LL | |         ()
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:169:5
   |
LL | /     let foo = |x: i32| {
LL | |
LL | |         x
LL | |     } else {
   | |_____^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:179:5
   |
LL |     let ok = format_args!("") else { return; };
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:182:5
   |
LL |     let bad = format_args! {""} else { return; };
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:189:19
   |
LL |           () => { {} }
   |  ___________________^
LL | |
LL | |
LL | |     }
...  |
LL | |         (1) => {
LL | |             let x = a!() else { return; };
   | |____________^
...
LL |       b!(1); b!(2);
   |       ----- in this macro invocation
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause
   = note: this warning originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: irrefutable `let...else` pattern
  --> $DIR/bad-let-else-statement.rs:189:19
   |
LL |           () => { {} }
   |  ___________________^
LL | |
LL | |
LL | |     }
...  |
LL | |         (2) => {
LL | |             let x = a! {} else { return; };
   | |____________^
...
LL |       b!(1); b!(2);
   |              ----- in this macro invocation
   |
   = note: this pattern will always match, so the `else` clause is useless
   = help: consider removing the `else` clause
   = note: this warning originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)

error: aborting due to 20 previous errors; 18 warnings emitted

For more information about this error, try `rustc --explain E0384`.