anonymous constants are overly restrictive wrt variance

[lcnr]

cc #89829 (comment)

this currently causes an error as 'a is considered invariant because it is used in an anonymous constant.

#![feature(generic_const_exprs)]
struct Foo<'a>([&'a u32; std::mem::size_of::<&'a u32>()]);
fn covariant<'a>(v: &'a Foo<'static>) -> &'a Foo<'a> {
    v //~ERROR mismatched types
}

This shouldn't actually be needed for std::mem::size_of as it doesn't care about variance.

Once stuff like the following causes an error (instead of a future imcompat lint, cc #56105), subtyping should not be able to influence const eval, so we could allow lifetimes used in constants to remain bivariant. It is not clear that we should do that, as this restriction on subtyping is definitely not obvious or even necessarily desirable.

trait SadBee {
    const ASSOC: usize;
}
// fn(&'static ())` is a supertype of `for<'a> fn(&'a ())` while
// we allow two different impls for these types, leading
// to different const eval results.
impl SadBee for for<'a> fn(&'a ()) {
    const ASSOC: usize = 0;
}
impl SadBee for fn(&'static ()) {
    const ASSOC: usize = 100;
}

[BGR360]

@rustbot label +A-variance

[QuineDot]

The current plan as I understand it is for these to continue to be allowed:

impl SadBee for for<'a> fn(&'a ()) {
    const ASSOC: usize = 0;
}
// This `impl` is more generic than your but still covers fn(`&'static ()`)
// (and any other `fn(&'concrete_lifetime U)`)
impl<T> SadBee for fn(T) {
    const ASSOC: usize = 100;
}

But I'm unsure if that's a problem for you or not.

[lcnr]

yeah, subtyping also impacts TypeId, so we won't be able to just use bivariance once TypeId::of is const. We can still allow variance by looking into the constant, e.g. for

struct UsesRef<'a> {
    actual_ref: &'a (),
    in_anon_const: [u8; std::mem::size_of::<&'a ()>()],
}

but that requires a bunch of additional design so I will only track that in rust-lang/project-const-generics#32

Thanks for reminding me that this issue exists 😅