try_block cannot be used everywhere an expression can

[rodrigorc]

The following code fails to compile (rustc --edition=2018):

#![feature(try_blocks)]
fn main() {
    match try { 0 } {
        None => (),
        Some(_) => ()
    };
}

The compiler error is:

error: expected expression, found reserved keyword `try`
 --> test.rs:3:11
  |
3 |     match try { 0 } {
  |     ----- ^^^ expected expression
  |     |
  |     while parsing this match expression

Adding parentheses or braces, it will compile fine:

    match ( try { 0 } ) { ... } //warning: unnecessary parentheses around `match` head expression
    match { try { 0 } } { ... }

The same issue happens with other constructs such as:

    if let Some(_) = try { 0 } { }
    for _ in try { 0 } { } //should fail because of "cannot infer type", not "expected expression"

[Centril]

cc @scottmcm

[scottmcm]

I believe the error is expected here, the same as with the following struct literal match in 2015:

struct try { x: i32 }
fn main() {
    let x = 1;
    match try { x } {
        try { .. } => {}
    }
}

Which also needs to be match (try { x }) { to compile.

That said, the warning to remove the necessary parens is definitely wrong.

EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me:

for _ in if true { [1].iter() } else { [0].iter() } { }

as does this:

match loop { break } {

So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.

[Centril]

Yeah I think match loop { ... } { is the better comparison here so it's probably a bug.

[rodrigorc]

match loop { break } {

This is exactly what a thought. I didn't know that this:

struct try { x: i32 }
fn main() {
    let x = 1;
    match try { x } {
        try { .. } => {}
    }
}

was not allowed, so in my head the parentheses were always redundant. Is there any reason for why we need parentheses around a struct literal? A parser ambiguity, maybe? Because I would expect that to work, too.

[ExpHP]

Is there any reason for why we need parentheses around a struct literal? A parser ambiguity, maybe? Because I would expect that to work, too.

for x in (Thing { x })
{
    println!("This is the loop body.");
}

for x in Thing { x }
{
    println!("This is a block expression.");
}

For match, hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.

match (Thing {})
{} // Parsed as the match block.  ERROR: Missing `_` branch


let thing: ! = panic!();

match thing {}
{} // Parsed as a block expression statement