Irrefutable pattern warning is confusing when pattern is on RHS

[Wilfred]

Code

pub fn say_hello(name: Option<String>) {
    let name_str = Some(name) else {
        println!("Hello person!");
        return;
    };

    // TODO: greet the user by name.
}

Current output

warning: irrefutable `let...else` pattern
 --> src/lib.rs:2:5
  |
2 |     let name_str = Some(name) else {
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: this pattern will always match, so the `else` clause is useless
  = help: consider removing the `else` clause
  = note: `#[warn(irrefutable_let_patterns)]` on by default

Desired output

warning: unreachable `else` clause
 --> src/lib.rs:2:5
  |
2 |     let name_str = Some(name) else {
  |                               ^^^^
  |
  = note: this pattern will match anything
  = help: consider using `let Some(name_str)` to match on a specific variant
  = note: `#[warn(irrefutable_let_patterns)]` on by default

Rationale and extra context

This took me a minute to realise what I was doing wrong: the code doesn't look obviously wrong at first glance.

The irrefutable message is also a little opaque to me. I know 'irrefutable' is in the warning name irrefutable_let_patterns, but does it need to be in the prose? E.g. would something like this better (inspired by unreachable_code)?

warning: `let...else` has unreachable `else` block

Other cases

Rust Version

rustc 1.95.0-nightly (7f99507f5 2026-02-19)
binary: rustc
commit-hash: 7f99507f57e6c4aa0dce3daf6a13cca8cd4dd312
commit-date: 2026-02-19
host: x86_64-unknown-linux-gnu
release: 1.95.0-nightly
LLVM version: 22.1.0

Anything else?

No response

[eggyal]

Perhaps

warning: unreachable `else` clause
 --> src/lib.rs:2:5
  |
2 |     let name_str = Some(name) else {
  |                               ^^^^
  |
  = note: assigning `Some(name)` to binding pattern `name_str` will always succeed
  = help: consider using `let Some(name_str) = name` to match on a specific variant
  = note: `#[warn(irrefutable_let_patterns)]` on by default

?

[ozankenangungor]

@rustbot claim

[Wilfred]

@eggyal that's definitely an improvement, but I think "assigning Some(name)" is confusing since the RHS doesn't matter and we want to highlight the LHS to the user. How about this?

warning: unreachable `else` clause
 --> src/lib.rs:2:5
  |
2 |     let name_str = Some(name) else {
  |                               ^^^^
  |
  = note: assigning to binding pattern `name_str` will always succeed
  = help: consider using `let Some(name_str) = name` to match on a specific variant
  = note: `#[warn(irrefutable_let_patterns)]` on by default

[eggyal]

Gosh. I think if I'd intended Some(name) to be a pattern then I'd find it a lot less confusing to see that the compiler instead interpreted it as a value to be assigned? But you were in this position more recently than me, so I'm happy to accept your view!

[Wilfred]

I guess the point is that the RHS is irrelevant to the match, and the code can't be fixed by editing that part. My 2c at least.

[estebank]

Two nitpicks: let's try to provide a structured suggestion (not very convinced that that is the right suggestion unless we have a lot of certainty about the types involved) and instead of a note about the irrefutable pattern, make it a span label:

warning: unreachable `else` clause
 --> src/lib.rs:2:5
  |
2 |     let name_str = Some(name) else {
  |         --------              ^^^^
  |         |
  |         assigning to binding pattern `name_str` will always succeed
  = note: `#[warn(irrefutable_let_patterns)]` on by default
help: consider using `let Some(name_str) = name` to match on a specific variant
  |
2 -     let name_str = Some(name) else {
2 +     let Some(name_str) = Some(name) else {
  |