Tracking issue for RFC 2294, "if let guard"

[Centril]

This is a tracking issue for the RFC "if let guard" (rust-lang/rfcs#2294).

Steps:

• Implement the RFC (implemented in Implement if-let match guards #79051)
• Adjust documentation (see instructions on forge)
• Stabilization PR (see instructions on forge)

Unresolved questions:

• Work out the exact semantics / borrowck (cc @nikomatsakis, @pnkfelix)
  • Add unit tests analogous to the existing if guard ones that test if let guard instead
  • Ensure that the documentation of these details, if any, give equal footing to if and if let guards.
  • (If there is no documentation of if guards behavior w.r.t. move semantics, I do not think that should hold up stabilizing this feature. We can just file an issue that those things need to be documented.)
• pnkfelix: The fact that both this feature and let else were implemented but had problems discovered relatively late with their handling of certain details w.r.t. locals and temporary r-values is a hint that we may need to revisit our approach to testing features like this more broadly, in terms of how we advise implementors of such features on how to probe for such cases (and maybe also in the form of some kind of language-oriented test-generation tooling?)

[imjacobclark]

👋 After a conversation about this change with @varkor I'm starting to take a look at this with a view to implementing it!

[alexreg]

@imjacobclark Hey. Any progress over the past few months? :-)

[ebkalderon]

Just ran into a case where this ability would be useful. I look forward to this feature landing someday!

[Vincent-liuwingsang]

+1 This would be a nice feature to have!

[Silhalnor]

Am currently learning Rust and thought it was unintuitive that I couldn't write this syntax. (Thought I must be mis-writing it somehow.) Lo, here it is in progress! Woo~

[Boscop]

Any update on this? :)

[LeSeulArtichaut]

I was willing to take a look at this, but I didn't have time to... I'll try to free some time for this ASAP!

[matthewjasper]

Is the code here supposed to work? I would expect only direct use of a let expression (or maybe a chain with && if if let chains is also enabled) to be accepted.

https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_build/src/build/expr/as_operand.rs#L121

edit: Looks like it's not intended to be allowed (and was fixed by #111841)

[dtolnay]

I opened #118726 with a pretty-printer fix that is relevant to "if let guard". The rules for when struct literals must be enclosed in parentheses are different between if-let-guard and ordinary if-let.

#![feature(if_let_guard)]

macro_rules! stringify_expr {
    ($expr:expr) => {
        stringify!($expr)
    };
}

macro_rules! stringify_if_let {
    ($expr:expr) => {
        stringify_expr!(if let _ = $expr {})
    };
}

macro_rules! stringify_if_let_guard {
    ($expr:expr) => {
        stringify_expr!(match () { _ if let _ = $expr => {} })
    };
}

fn main() {
    println!("{}", stringify_if_let!(Struct {}));
    println!("{}", stringify_if_let_guard!(Struct {}));
}

stringify! must add parentheses around Struct {} in the if-let case, but it is not necessary to do so in the if-let-guard case because parsing of the expression is not terminated by { in that position.

if let _ = (Struct {}) {}
match () { _ if let _ = Struct {} => {} }