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!

[Antikyth]

Hi @Antikyth, thanks for the help! Here is, to my knowledge, the status of the work on if-let guards:

• There aren't any known bugs with the feature but testing is insufficient. More unit tests (found in tests/ui/rfc-2294-if-let-guard) should be added to cover e.g. the interaction between if-let guards and let-chains? We might also want to encourage people on nightly to use the feature to collect feedback? If you noticed surprising behaviour or bad diagnostics, please open an issue!
• Document if-let guards reference#1082 is adding if-let guards to the Reference and should be good to go
• I opened Documenting if-let guards ? rust-by-example#1667 to ask if if-let guards should be included in Rust by Example
• Formatting if-let guards is blocked on a decision from the Style team (Support let guards and let chains rustfmt#5203), though that is not blocking stabilization

If you are interested in writing some tests or the Rust by Example chapter, please go ahead! Thanks again for your help.

I can see that if let guards are not documented in the unstable book. I suppose this is something that needs to be done?

I don't think that's particularly useful in the perspective of stabilization, but I might be wrong.

Ah, thanks for the reply! I'll have a look at:

• where if let guards are used in my code, and where they could be used, so I can see if I can find any more issues or bad diagnostics
• adding unit tests, if I can think of areas to test
• contributing to a rust by example chapter

I may or may not get somewhere with those, will have to see if (a) I happen to have time to do so, (b) I can do something useful. But I'm happy to give it a try :)

[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 {} => {} }