Coercion from non-capturing closure to fn ptr fails when return type is `!`

[RalfJung]

Usually, non-capturing closures can be coerced to fn ptrs. But somehow that seems to fail when the return type is !:

fn magic<R, F: FnOnce() -> R>(f: F) -> F { f }

fn main() {
    let f1 = magic(|| {}) as fn() -> (); // works fine
    let f2 = magic(|| loop {}) as fn() -> !; // errors
}

The error is

error[E0605]: non-primitive cast: `[closure@src/main.rs:5:21: 5:31]` as `fn() -> !`
 --> src/main.rs:5:14
  |
5 |     let f2 = magic(|| loop {}) as fn() -> !;
  |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait

This fails even on nightly, where ! should be stable as a type.

Curiously, this works:

let f2: fn() -> ! = || loop {};

Cc @Centril

[eddyb]

This also works: magic(|| -> ! { loop {} }) as fn() -> !.

I'm not surprised inference of ! is finicky even with ! stabilized.

[SimonSapin]

Could this have a common root cause with #66757? They both compile if #![feature(never_type_fallback)] is enabled.

[RalfJung]

Actually the error happens even on stable, entirely independent of the never_type feature.

[Mark-Simulacrum]

I suspect this is not actually a bug, in some sense. Currently, the closure being passed into the function here doesn't get a return type of !. Expressions like loop {} are typed as !, but the return type of the closure is inferred for this code -- and the loop {} expression sets no requirements on the return type due to ! being coerceable to any type -- including the inference variable of the return type.

That means we basically end up with a situation where the return type of the closure is "unknown", and so falls back to (). fn() is not castable to fn() -> !, of course, so this leads to an error. In general ! is a somewhat "weak" type due to this easy coercion behavior, which leads to quite a bit of unintuitive behavior.

[RalfJung]

Ah, I see, that makes sense... and indeed this variant works:

#![feature(never_type)]
fn magic<F: FnOnce() -> !>(f: F) -> F { f }

fn main() {
    let f2 = magic(|| loop {}) as fn() -> !;
}