Function pointers are not VaArgSafe

[RalfJung]

The VaArgSafe trait is not implemented for fn types -- and fixing that seems non-trivial? There is no easy way to "implement a trait for all function pointers". This is something we may have to figure out before stabilizing #44930 because surely we want to support fn types eventually and so we should be confident that the design we stabilize can accommodate that.

We do have the FnPtr trait, but wouldn't we risk coherence issues if we add something like this?

impl<T: FnPtr> VaArgSafe for T {}

Cc @folkertdev

[eggyal]

@rustbot label +A-coherence -A-impl-trait +C-discussion +F-c_variadic +T-types -needs-triage

[folkertdev]

So far we've not seen it as an urgent problem because, with some caveats, a function pointer can be cast to a normal pointer, passed, then cast back on the other side. Because the VaArgSafe trait is sealed, there are no coherence concerns I believe.

If that FnPtr instance does what it seems to do that does seem useful.

[RalfJung]

My coherence concern is that if we add that blanket impl, then for any other VaArgSafe impl the trait system requires a proof that it is disjoint from the blanket impl. Basically you can only have one such blanket impl.

[folkertdev]

Another idea from #44930 (comment) is that repr(transparent) of a numeric primitive should also perhaps impl VaArgSafe, so now we're getting into auto trait territory.

I'd rather not actually implement all of that before stabilization, so my main priority is to be sure that the current design does not close any doors. As far as I can see we're good.

[RalfJung]

Auto traits do not know the repr of a type, so that's not auto trait territory, that's magic trait territory. If we are moving in a direction where we might later have to make this a magic trait with its impls hard-coded in the trait solver, we should be sure t-types is on-board with that plan.

[folkertdev]

Not much we can do if they are not. I don't see it as essential given that it can be worked around. Similarly something like

impl<T: VaArgSafe> VaArgSafe for MaybeUninit<T> {}

would be nice but runs into coherence problems too. We can just manually implement these though.