Failure to parse `{2} + {2}`

[blaztinn]

These examples should compile according to the rust reference:

fn compiles() -> i32 {
    ({2}) + ({2})
}

fn fails() -> i32 {
    {2} + {2}
}

fn compiles2() -> i32 {
    2 + {2}
}

fn fails2() -> i32 {
    {2} + 2
}

(Playground)

Errors:

   Compiling playground v0.0.1 (file:///playground)
error: expected expression, found `+`
 --> src/lib.rs:6:9
  |
6 |     {2} + {2}
  |         ^ expected expression

error: expected expression, found `+`
  --> src/lib.rs:14:9
   |
14 |     {2} + 2
   |         ^ expected expression

error: aborting due to 2 previous errors

error: Could not compile `playground`.

To learn more, run the command again with --verbose.

Rust reference snippet (thanks @Moongoodboy-K for the help here):

Expression : BlockExpression | OperatorExpression | ..
OperatorExpression : ArithmeticOrLogicalExpression | ..
ArithmeticOrLogicalExpression : Expression + Expression | ..
BlockExpression : { InnerAttribute* Statement* Expression? }

cc: @Moongoodboy-K

[nagisa]

Note: this is not a regression, these fail to parse all the way back to 1.0. I think this is a duplicate of #7909, but since we are now fairly accepting of look-ahead, this seems fairly valid.

[estebank]

but since we are now fairly accepting of look-ahead,

I believe that conversation is still ongoing, we'll probably have to go the RFCS route for that...

[scottmcm]

I'm not certain this is actually a bug; it might be worse for + and - to have difference parser behaviour here.

[Havvy]

This isn't a bug. It falls out of block expression statements terminating at the }.

[Havvy]

The relevant section of the reference:

An expression statement is one that evaluates an expression and ignores its result. As a rule, an expression statement's purpose is to trigger the effects of evaluating its expression.

An expression that consists of only a block expression or control flow expression, if used in a context where a statement is permitted, can omit the trailing semicolon. This can cause an ambiguity between it being parsed as a standalone statement and as a part of another expression; in this case, it is parsed as a statement.

v.pop();          // Ignore the element returned from pop
if v.is_empty() {
    v.push(5);
} else {
    v.remove(0);
}                 // Semicolon can be omitted.
[1];              // Separate expression statement, not an indexing expression.

While we could theoretically make { {2} + {2} } work since { + {2} } is not a valid expression, the same cannot be true of other binary ops. Specifically -. { - {2}; } is valid.

That said, the error for this is terrible. Most likely you want to change your expression statement to be ({2} + {2}); in these cases. Is there a diagnostic issue open for that?