Support if- and while-let chains

[ChayimFriedman2]

RFC 2497 https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md.

I'm not sure if this should be a major or minor version bump: it breaks users of rust.ungram but not general users of the crate.

[Veykril]

r? @matklad

Basically let chains require use to parse let expressions as the faeture will allow if (let pat = expr) to be a thing(at least as it stands right now):

Quoting rust-lang/rust-analyzer#11320 (comment):

Parsing turns out to be quite complex. The problem is that the let syntax can appear inside parentheses (if (let pat = expr)). This is to facilitate for macros, as stated in the RFC.

The problem is especially tricky since we cannot know if let is allowed in this position until we finish parsing it, becauses parentheses can be also tuples: if (let true = true, false) {} is invalid, but if (let true = true) {} is valid.

rustc chose to implement this as an expression kind and later verify that let is indeed valid there.

We don't have a validation pass to the AST. But it may be necessary to introduce it.

What do you think? Do you have an other way?

I believe this should work for us as well but I'd rather have your input on this grammar change.

[ChayimFriedman2]

@Veykril Turns out we do have a validation pass: rust-lang/rust-analyzer@1eb9d36.

[matklad]

Ok, so, contrary to the RFC, it seems like let's are now treated as expressions syntactically:

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=11396e0b7b3bd40cfb6ca2c20f4ad786

#![feature(let_chains)]

macro_rules! assert_item {
    ($i:item) => ()
}

assert_item!(fn f() { let _ = (let 1 = 1); });

Than, yeah, I agree we should just make Condition an Expr (and rewrite a bunch of stuff in ra TT), and add a LetExpr as a kind of Expr.

As a follow up, I think it'll than make sense to get rid of LetStmt, and just use ExprStmt in its place.

[matklad]

bors r+

[bors]

Build succeeded:

• Rust

[ChayimFriedman2]

As a follow up, I think it'll than make sense to get rid of LetStmt, and just use ExprStmt in its place.

rustc does not do that: let expressions, AST vs. let statements, AST; let expressions, HIR vs. let statements, HIR. But maybe this is related to the fact that in the MIR they're represented very differently, so we don't have to worry. However, there also other incompatibilities (e.g. the type of let expressions is treated as bool while let statements have no type). I'm not sure we can't do that, but it is worth remembering.

[ChayimFriedman2]

Also:

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=73ac9fb223d5785f932cd3760036c29d

#![feature(let_chains)]

macro_rules! expr {
    ($e:expr) => ()
}
macro_rules! stmt {
    ($e:stmt) => ()
}


// expr!(let 1 = 1);
expr!((let 1 = 1));
stmt!(let 1 = 1);
stmt!((let 1 = 1));

The stmt!((let 1 = 1)) probably works because this is an ExpressionStatement but the stmt!(let 1 = 1) is probably a LetStatement, confirmed by the fact that expr!(let 1 = 1) does not compile.