Mismatch reported for fn impl with HRTB lifetime without cast

[mqudsi]

type IntCallback = fn(&i32);

enum Callback {
    Int(IntCallback)
}

impl Into<Callback> for for<'a> fn(&'a i32) {
    fn into(self) -> Callback {
        Callback::Int(self)
    }
}

fn callback(_: &i32) {
}

fn main() {
    let callback: Callback = callback.into();
}

I expected to see this happen: the impl for the fn pointer should be picked up and used.

Instead, this happened:

Compiling playground v0.0.1 (/playground)
error[[E0277]](https://doc.rust-lang.org/nightly/error_codes/E0277.html): the trait bound `Callback: From<for<'a> fn(&'a i32) {callback}>` is not satisfied
  --> src/main.rs:17:39
   |
17 |     let callback: Callback = callback.into();
   |                                       ^^^^ the trait `From<for<'a> fn(&'a i32) {callback}>` is not implemented for `Callback`
   |
   = help: the trait `Into<Callback>` is implemented for fn pointer `for<'a> fn(&'a i32)`, cast using `as`
   = note: required for `for<'a> fn(&'a i32) {callback}` to implement `Into<Callback>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` (bin "playground") due to previous error

Since callback can be passed directly to a function taking IntCallback as a parameter, it should be possible for the existing From<> impl to be used directly.

This makes it extremely verbose to use generic bounds to accept a callback:

fn callback(_: &i32) {
}

fn foo<C: Into<Callback>>(c: C) {
    todo!();
}

fn main() {
    foo(callback);
}

which returns

error[[E0277]](https://doc.rust-lang.org/nightly/error_codes/E0277.html): the trait bound `Callback: From<for<'a> fn(&'a i32) {callback}>` is not satisfied
  --> src/main.rs:17:9
   |
17 |     foo(callback);
   |     --- ^^^^^^^^ the trait `From<for<'a> fn(&'a i32) {callback}>` is not implemented for `Callback`
   |     |
   |     required by a bound introduced by this call
   |
   = help: the trait `Into<Callback>` is implemented for fn pointer `for<'a> fn(&'a i32)`, cast using `as`
   = note: required for `for<'a> fn(&'a i32) {callback}` to implement `Into<Callback>`
note: required by a bound in `foo`
  --> src/main.rs:20:11
   |
20 | fn foo<C: Into<Callback>>(c: C) {
   |           ^^^^^^^^^^^^^^ required by this bound in `foo`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` (bin "playground") due to previous error

Playground link: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=c367afd81fc7219e802099735acc2507

Side note: the diagnostics for this have drastically improved in the latest nightlies. The nightly build I have installed didn't give me the "cast using as" hint and instead said "type xxxx doesn't implement Foo, implemented for <same type xxxx>"

Meta

rustc --version --verbose:

 1.71.0-nightly (2023-05-27 cca7ee58110726983951)

[compiler-errors]

I'm not exactly sure that this is a bug. The type of the function callback is not a fn ptr, but an fn item. It may be coerced to a fn ptr, but only in certain positions (argument position, RHS of an assignment operator, field in a struct constructor). So the compiler is right when it says that the trait Callback is not implemented for the fn item type of "for<'a> fn(&'a i32) {callback}".

This is misleading and confusing of course, though, so I'm not gonna close the issue. But the diagnostic is right that you need to use the as operator to coerce it like (callback as fn(&i32)).into(). And I'm pretty certain that this cannot be fixed to just compile (at least in general).

[mqudsi]

TBH I probably wouldn't have filed a bug if that was the error message I saw. I filed this issue with a minimal repro but the actual error I ran into was different and didn't even mention the cast - I thought it was a compiler difference but it turns out to be more about the specific usage so I should come up with another repro:

error[E0277]: the trait bound `EnvCallback: From<for<'a> fn(&'a environment::EnvStack) {handle_fish_trace}>` is not satisfied                                                                               
   --> src/env_dispatch.rs:80:37                                                                                                                                                                            
    |                                                                                                                                                                                                       
80  |         table.add(L!("fish_trace"), handle_fish_trace);                                                                                                                                               
    |               ---                   ^^^^^^^^^^^^^^^^^ the trait `From<for<'a> fn(&'a environment::EnvStack) {handle_fish_trace}>` is not implemented for `EnvCallback`                                
    |               |                                                                                                                                                                                       
    |               required by a bound introduced by this call                                                                                                                                             
    |                                                                                                                                                                                                       
    = help: the following other types implement trait `Into<T>`:                                                                                                                                            
              for<'a> fn(&'a Utf32Str, &'a environment::EnvStack)                                                                                                                                           
              for<'a> fn(&'a environment::EnvStack)                                                                                                                                                         
    = note: required for `for<'a> fn(&'a environment::EnvStack) {handle_fish_trace}` to implement `Into<EnvCallback>`                                                                                       
note: required by a bound in `VarDispatchTable::add` 

As you can see, the message doesn't even mention casting with as, it just presents two identical type signatures (one with the trailing {func_name} and one without) and says they don't match (when it would seem they do).

I'm not convinced this can't be coerced automatically in the compiler specifically for fn which already has a ton of magic compared to the Fn family which needs to be treated like any other trait.

To clarify further, since it's not possible to impl a trait for an fn item, I don't think there could be any issues coercing the fn item to an fn pointer.

i.e. this isn't possible:

impl Into<Callback> for callback { ... }

so the impl necessary has to be

impl Into<Callback> for fn(...) { ... }

and I don't think the function item can deref into any other ast implicitly besides an fn (I'd expect it an explicit cast to be required for any other coercion, of course), so I can't see the harm in coercing to an fn ptr in this context.

[mqudsi]

(As a related aside, I don't think the docs on HRTB lifetimes actually make it clear it can be used the way I did, i.e. not in a generic trait constraint. As the trait can't be implemented for a generic using fn as a constraint since it's not a trait, the syntax used in the original post is the only way to explicitly specify the HRTB lifetime for an impl so it should probably be documented -- though cases where an explicit HRTB lifetime for fn ptrs is required are rather rare/advanced, of course.)

[zirconium-n]

so the impl necessary has to be

impl Into<Callback> for fn(...) { ... }

Just in case of you are not aware of it, you can write this impl

impl<F: Fn(...)> SomeTrait for F {...}