HRTB variants are missing a std::fmt::Pointer impl

[jimy-byerley]

It seems that there is a missing implementation of std::fmt::Pointer on some function pointers:

function pointers like fn test() -> f32 can be passed as argument to println!("{:p}", ...)
but function pointers like fn test(Vec<T> a) -> f32 can't because it's a HRTB variant.

see https://users.rust-lang.org/t/display-function-pointer/17073 for more details.

[ExpHP]

Your link is broken. Can you please post a code snippet?

Printing an HRTB fn pointer should be impossible, because the address depends on the type arguments. Printing test::<i8> might be possible; I'm not sure, because playing around with it in the playpen, it seems to me that even a simple fn foo() does not impl Pointer.

[ExpHP]

Found it by copying the link text.

Your arg type was fn (&Vec<i8>)->f32, which adds an important detail (the reference in the argument, which adds an invisible HRTB lifetime parameter that should not affect the function address. This makes the issue more legitimate

[jimy-byerley]

But the address's interpretation doesn't depends on the function type, isn't it ? HRTB type makes it difficult to reach the correct implementation of methods and traits but that doesn't affect the fact that it's a pointer ?

[vitalyd]

There's a macro in std that is used to generate the various std::fmt::Pointer impls for fn's of different arity. Probably what's missing are the HRTB variants, e.g. impl<Ret, A> Pointer for for<'a> fn(&'a A) -> Ret and so on for the other combinations.

[ExpHP]

@vitalyd that solution has exponentially scaling complexity just to support & and &mut arguments, and that's without even support for:

• other types besides & that have lifetime parameters
• 'b: 'a constraints

[vitalyd]

@ExpHP, I agree that it’s not exhaustive. The existing impls are handcoded as well with someone making the choice of which arities and types to support.

Perhaps the real solution would be compiler support (eg a lang item) or some auto trait or something else. It’s a bad look when these fn pointers should just work but don’t and it all depends for which impls Pointer was implemented.

But barring a more principled solution, adding more combinations could bandaid this for now.

[steveklabnik]

Triage: no change. This program: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=844d632aee1147f2dc9e7d05d3ef9462

fn show(a: fn () -> f32, b: fn (&Vec<i8>)->f32) {
    println!("the two pointers: {:p} {:p}", a, b);
}

gives this error:

error[E0277]: the trait bound `for<'r> fn(&'r std::vec::Vec<i8>) -> f32: std::fmt::Pointer` is not satisfied
 --> src/lib.rs:2:48
  |
2 |     println!("the two pointers: {:p} {:p}", a, b);
  |                                                ^ the trait `std::fmt::Pointer` is not implemented for `for<'r> fn(&'r std::vec::Vec<i8>) -> f32`
  |
  = help: the following implementations were found:
            <extern "C" fn(A) -> Ret as std::fmt::Pointer>
            <extern "C" fn(A, ...) -> Ret as std::fmt::Pointer>
            <fn(A) -> Ret as std::fmt::Pointer>
            <unsafe extern "C" fn(A) -> Ret as std::fmt::Pointer>
          and 2 others
  = note: required by `std::fmt::Pointer::fmt`
  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

[fmease]

Triage: The code provided in the comment above now compiles just fine.

Marking as E-needs-test, however we might already have a test for this.