Add Convert match to let-else assist

[unexge]

Closes #13254

[unexge]

I've tried to get diverging arms by looking types of arm expressions via hir::semantics::Semantics::type_of_expr but we coerce all match arm expressions and the whole match expression to the Never type when we encounter any diverging arm, so I couldn't find a way to distinguish diverging and non-diverging arms without recording this information.

[jonas-schievink]

Does it help if you look at the unadjusted type? In an expression like

    match Some(0) {
        Some(_) => {}
        None => return
    }

return has type ! but is adjusted to (), so the unadjusted type should provide the information you need

[jonas-schievink]

Ah, I found the issue – your tests use Option but don't declare it. I'll push a fix.

[unexge]

ohh 😅 great! Thanks for the fix.

[jonas-schievink]

@bors r+

[bors]

📌 Commit 72d5b45 has been approved by jonas-schievink

It is now in the queue for this repository.

[bors]

⌛ Testing commit 72d5b45 with merge d90cb1e...

[bors]

☀️ Test successful - checks-actions
Approved by: jonas-schievink
Pushing d90cb1e to master...

[fmease]

Does this also fix #11908?

[liamhession]

@unexge - I was hoping you could explain to me what you mean by the terms "diverging arm" and "extracting arm" in match statements? I'm not seeing that term used elsewhere so i'm not sure what exactly they're supposed to describe. The reason i'm interested is that i'm trying to expand the functionality of this convert-match-to-let-else assist that you created!

My current guess is that a diverging arm is one which simply returns? Extracting arm is everything else?

Would really appreciate any more context you may be able to give about how you approached creating this assist, thanks!

[Veykril]

diverging arm = a match arm that has type ! (never type), so an arm that never yields a value (due to it returning for example).

extracting I imagine is the arm that "extracts" the value of interest from the value being match on

[unexge]

@liamhession I believe @Veykril answered your question but to give a bit more context:
There is a common theme that you are only interested some subpattern from a pattern, like you have Option<T> but you are only interested with Some(T) or you have ast::Expr but you are only interested with ast::AwaitExpr and the usual way to encode this pattern is you match on the given value (and now you can also use let-else statement :)) and you usually have 2 match arms:
one that diverges, meaning stops the execution of the function by return, continue, panic! or any other never ! type
one that extracts the value you are interested.

You can see that pattern a lot in Rust Analyzer especially in ide-assists for example:

// This only applies for tuple patterns, types, and initializers.
let tuple_pat = match pat { // <- extracts `ast::Pat::TuplePat` from `ast::Pat`
    ast::Pat::TuplePat(pat) => pat, // <- extracting arm
    _ => return None, // <- diverging arm
};
// ...
let tuple_init = match init { // <- extracts `ast::Expr::TupleExpr` from `ast::Expr`
    ast::Expr::TupleExpr(expr) => expr, // <- extracting arm
    _ => return None, // <- diverging arm
};

from

rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs

Lines 33 to 45 in 2656297

	// This only applies for tuple patterns, types, and initializers.
	let tuple_pat = match pat {
	ast::Pat::TuplePat(pat) => pat,
	_ => return None,
	};
	let tuple_ty = ty.and_then(|it| match it {
	ast::Type::TupleType(ty) => Some(ty),
	_ => None,
	});
	let tuple_init = match init {
	ast::Expr::TupleExpr(expr) => expr,
	_ => return None,
	};

Happy to help if you have any questions and I can also try to give you some pointers if you have some specific improvements in your mind!

[liamhession]

Very nice context to have, thanks @unexge and @Veykril

My confusion came about in part because i couldn't find really any other use of those terms "extracting arm" and "diverging arm" through Googling. But their names make sense in the context you laid out.

The improvements i'm aiming for are to expand the variety of "scrutinee expressions" (just learned that vocab from https://doc.rust-lang.org/reference/expressions/match-expr.html) this assist can be used for. The relevant issue within rust-analyzer is #13540

I've first been working on tweaking it so that it will recognize a statement with tuple after the let keyword, as outlined in the issue. But i hope to leave it even more general-purpose than just something that additionally recognizes that case.

I think first i'll need to update the find_binding function to add arms to the match statement it uses, and then update rename_variable to be able to use alternate sub-types of ast::Pat. Do you think that sounds about right @unexge ?

[unexge]

@liamhession yes I believe, you need to update following functions to be more generic:
find_binding: in addition to ast::IdentPat it should also find ast::TuplePat and other patterns that makes sense
find_extracted_variable: should probably return Vec<ast::Name> for every binding? instead of a single name
rename_variable: should be updated according to return types of previous functions and should handle new cases