Non-exhaustive pattern error when matching on `!`

[cjgillot]

I tried this code:

#![feature(never_type)]

fn main() {
    let x: !;
    match x {
        _ if { loop {} } => (),
    }
}

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

I expected to see this happen: complain about the uninitialized binding x.
Like it does in https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=99dc49582c1bce26b084e33bfd366026

Instead, this happened: error E0004: non-exhaustive patterns: () not covered
A match on a scrutinee of type ! should not expect a pattern of type ().

Meta

rustc --version --verbose:

rustc 1.71.1 (eb26296b5 2023-08-03)
binary: rustc
commit-hash: eb26296b556cef10fb713a38f3d16b9886080f26
commit-date: 2023-08-03
host: x86_64-unknown-linux-gnu
release: 1.71.1
LLVM version: 16.0.5

[asquared31415]

Adding the never_type_fallback feature causes the code to compile.

[WaffleLapkin]

Status update: The original example from the issue now compiles fine, although the unreachable pattern warning is still emitted:

#![feature(never_type)]

fn main() {
    let x: !;
    match x {
        _ if { loop {} } => (),
    }
}

compiler output

warning: unreachable pattern
 --> src/main.rs:6:9
  |
6 |         _ if { loop {} } => (),
  |         ^----------------------
  |         |
  |         matches no values because `!` is uninhabited
  |         help: remove the match arm
  |
  = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
  = note: `#[warn(unreachable_patterns)]` on by default

However, if you change _ to _x the example returns to the original behavior described in the issue:

#![feature(never_type)]

fn main() {
    let x: !;
    match x {
        _x if { loop {} } => (),
    }
}

compiler output

warning: unreachable arm
 --> src/main.rs:6:30
  |
5 |     match x {
  |           - any code following this expression is unreachable
6 |         _x if { loop {} } => (),
  |                              ^^ unreachable arm
  |
  = note: `#[warn(unreachable_code)]` on by default

error[E0004]: non-exhaustive patterns: `()` not covered
 --> src/main.rs:5:11
  |
5 |     match x {
  |           ^ pattern `()` not covered
  |
  = note: the matched value is of type `()`
  = note: match arms with guards don't count towards exhaustivity
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
6 ~         _x if { loop {} } => (),
7 ~         () => todo!(),
  |

However (2), if you switch the compiler to edition 2024, it actually produces a sane error:

compiler output

warning: unreachable arm
 --> src/main.rs:6:30
  |
5 |     match x {
  |           - any code following this expression is unreachable
6 |         _x if { loop {} } => (),
  |                              ^^ unreachable arm
  |
  = note: `#[warn(unreachable_code)]` on by default

warning: unreachable pattern
 --> src/main.rs:6:9
  |
6 |         _x if { loop {} } => (),
  |         ^^----------------------
  |         |
  |         matches no values because `!` is uninhabited
  |         help: remove the match arm
  |
  = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
  = note: `#[warn(unreachable_patterns)]` on by default

error[E0381]: used binding `x` isn't initialized
 --> src/main.rs:6:9
  |
4 |     let x: !;
  |         - binding declared here but left uninitialized
5 |     match x {
6 |         _x if { loop {} } => (),
  |         ^^ `x` used here but it isn't initialized

So, uhh. There is a lot going on.

The reason it compiles with _, is that _ doesn't result a move anymore, so the x variable is not actually accessed.

The reason for weird error with _x on edition < 2024 is that it does generate a move, which results in never type fallback being used, which coerces _x to () (this is subject to change).

On edition >= 2024, and in future on all editions, never type fallback will be !, rather than (), so the error is more sane.

To conclude:

1. Unreachable pattern lint seems to be bugged (it is emitted in cases where the pattern is clearly reachable) (I opened unreachable_patterns emitted on _ that matches a local of uninhabited type (that is uninitialized) #134733 for this)
2. Weird diagnostic for the never type will be fixed once we switch fallback to !