Function item subtyping can change behavior

[theemathas]

I'm not sure if this is a bug or not.

In the following code, F2 is a subtype of F1. It seems that this causes the type of the F2::method function item to be a subtype of the F1::method function item. This implies that function items that are subtypes of each other can have different behavior. This is rather strange.

type F1 = fn(&'static ());
type F2 = for<'a> fn(&'a ());

trait Trait: Sized {
    fn method() -> Option<Self>;
}

impl Trait for F1 {
    fn method() -> Option<Self> {
        println!("F1");
        None
    }
}

#[expect(coherence_leak_check)]
impl Trait for F2 {
    fn method() -> Option<Self> {
        println!("F2");
        None
    }
}

fn main() {
    let mut x = F1::method;
    x();
    let y = F2::method;
    y();
    x = y;
    x();
}

The above code prints:

F1
F2
F1

cc @lcnr

Meta

Reproducible on the playground with version 1.97.0-nightly (2026-04-28 37d85e592f9ae5f20f7d)

[Morgane55440]

this looks like #118247 all over again.
it also works if you write

type F1 = for<'a> fn(&'a (), &'a ());
type F2 = for<'a, 'b> fn(&'a (), &'b ());

i'm not sure how the specific example on the old issue was fixed but yours was not.

nevermind i figured it out it's because of variance of course.
if you write impl Trait for Cell<F{$N}> instead, it does not compile

[theemathas]

See also lcnr/random-rust-snippets#11

[Morgane55440]

minimised ?

use std::any::TypeId;
type F1 = fn(&'static ());
type F2 = for<'a> fn(&'a ());

const fn type_id_of_val<T : 'static>(_ : &T) -> TypeId {
    TypeId::of::<T>()
}

fn main() {
    let mut x = Option::<F1>::None;
    let id1 = type_id_of_val(&x);
    let y = Option::<F2>::None;
    let id2 = type_id_of_val(&y);
    x = y;
    let id3 = type_id_of_val(&x);
    assert!(id1 == id3 && id2 != id3);
}

this is documented to be a thing on TypeId's doc btw

[QuineDot]

@Morgane55440 the issue is about subtyping function items based on subtyping of the implementing type in the qualified paths of the function items.

In contrast your latest example is just about subtyping of higher-ranked types themselves AFAICT; you compared no function item types.

(F1 and F2 must have distinct TypeIds, else you could transmute between them (in either direction) without unsafe (via dyn Any), which is unsound. That would be true even if they weren't related by subtyping.)

[Morgane55440]

@QuineDot mb i see what you mean. i tried to get my example to

use std::any::TypeId;
type F1 = fn(&'static ());
type F2 = for<'a> fn(&'a ());

fn main() {
    let mut x = TypeId::of::<F1>; // function item
    let id1 = x();
    let y = TypeId::of::<F2>; // function item
    let id2 = y();
    x = y; // should work
    let id3 = x();
    assert!(id1 == id3 && id2 != id3);
}

but it seems the subtyped type must not be on the function itself, but earlier in the path ? i may be wrong.

[theemathas]

@Morgane55440 For a function item to be covariant, the generic parameter must be mentioned in the return type.