`unreachable_patterns` fires on match arm that can't be removed.

[Dirbaio]

playground

use core::future::Future;

async fn select<A: Future, B: Future>(_: A, _: B) -> Result<A::Output, B::Output> {
    todo!()
}

pub async fn wtf() -> ! {
    let a = async { loop {} };
    let b = async { loop {} };
    match select(a, b).await {
        Ok(x) => x,
        Err(x) => x,
    }
}

warns with unreachable_patterns on both arms

warning: unreachable pattern
  --> src/lib.rs:11:9
   |
11 |         Ok(x) => x,
   |         ^^^^^
   |
   = note: this pattern matches no values because `Result<!, !>` is uninhabited
   = note: `#[warn(unreachable_patterns)]` on by default

but removing either doesn't actually compile

error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> src/lib.rs:10:11
    |
10  |     match select(a, b).await {
    |           ^^^^^^^^^^^^^^^^^^ pattern `Ok(_)` not covered
    |
note: `Result<(), !>` defined here
   --> /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/result.rs:527:1
    |
527 | pub enum Result<T, E> {
    | ^^^^^^^^^^^^^^^^^^^^^
...
531 |     Ok(#[stable(feature = "rust1", since = "1.0.0")] T),
    |     -- not covered
    = note: the matched value is of type `Result<(), !>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
11  ~         Err(x) => x,
12  ~         Ok(_) => todo!(),

So this code seems "unfixable" with the new lint.

What's happening is the match arm is unreachable, but it still has the "side effect" of making the async block be inferred to Future<Output=!> instead of Future<Output=()>. So, if you remove it the future now gets inferred to return (), and the arm is not unreachable anymore.

In edition 2024 it Just Works if you write match select(a, b).await {}, because the fallback is ! instead of ().

This seems a bit hard to mitigate in Edition 2021, it seems more like an unfortunate combination of the lint and the inference fallback more than a bug. I'm opening the issue anyway to share it, just in case anyone has an idea.

[Noratrieb]

cc @Nadrieril

[WaffleLapkin]

The way to fix this would be to specify an uninhabited type which isn't never type (and thus doesn't experience never type fallback). i.e. doing an identity::<Result<Infallible, Infallible>> or loop {} as Infallible. The problem is that both of these run into unreachable code lint.

I think the only way to fix the warning is to specify the type of the futures, either directly:

fn ascribe_future<R>(f: impl Future<Output = R>) -> impl Future<Output = R> { f }

let a = ascribe_future::<Infallible>(async { loop {} });
let b = ascribe_future::<Infallible>(async { loop {} });

or in the select:

async fn select<A: Future<Output = RA>, B: Future<Output = RB>, RA, RB>(_: A, _: B) -> Result<A::Output, B::Output> {
    todo!()
}

match select::<_, _, Infallible, Infallible>(a, b).await {}

Neither is particularly nice and the interaction with the old never type fallback is very unfortunate, but yeah :(

[Nadrieril]

Well that's fun :D Yeah, to mitigate we'd have to make pattern exhaustiveness influence type inference I think, which... yeah.

[traviscross]

The code above can be fixed to not warn with:

//@ edition: 2021
use core::future::Future;

async fn select<A: Future, B: Future>(_: A, _: B) -> Result<A::Output, B::Output> {
    loop {}
}

pub async fn f() -> ! {
    let a = async { loop {} };
    let b = async { loop {} };
    match select(a, b).await {
        _ => unreachable!(), //[2021]~ <--- No warning.
    }
}

Playground link

This does warn in Rust 2024 as one might expect and as is desirable.

[traviscross]

Here's a minimization of the original issue:

pub fn g<T>(_: fn() -> T) -> Option<T> { loop {} }
pub fn f() -> ! {
    match g(|| loop {}) {
        Some(x) => x,
        //[2021]~^ WARN unreachable pattern
        None => unreachable!(),
    }
}

Playground link

(There's some similarity to the never type hack here, both in the minimization and in the original.)

As in the original, removing the arm works in Rust 2024 but not in Rust 2021. However, in Rust 2021 we can write, warning-free, either:

pub fn g<T>(_: fn() -> T) -> Option<T> { loop {} }
pub fn f() -> ! {
    match g(|| loop {}) {
        Some(()) => unreachable!(),
        None => unreachable!(),
    }
}

Playground link

...or:

pub fn g<T>(_: fn() -> T) -> Option<T> { loop {} }
pub fn f() -> ! {
    match g(|| loop {}) {
        _ => unreachable!(),
    }
}

Playground link

[Dirbaio]

it's undesirable to have to write unreachable! though. i'd rather have the compiler prove unreachability for me, than trust my word and get a panic if i'm wrong.