Consider types appearing in const expressions to be invariant

[voidc]

This is an approach to fix #80977.
Currently, a type parameter which is only used in a constant expression is considered bivariant and will trigger error E0392 "parameter T is never used".
Here is a short example:

pub trait Foo {
    const N: usize;
}

struct Bar<T: Foo>([u8; T::N])
where [(); T::N]:;

(playgound)

While it is possible to silence this error by adding a PhantomData<T> field, I think the better solution would be to make T invariant.
This would be analogous to the invariance constraints added for associated types.
However, I'm quite new to the compiler and unsure whether this is the right approach.

r? @varkor (since you authored #60058)

[varkor]

Thanks for looking into this issue! I don't have a lot of time to review right now, so I'm going to reassign to @lcnr, who's up-to-date on the const generics internals.

r? @lcnr

[lcnr]

Thanks for the PR 👍

I am a bit unsure about this. As variance shouldn't influence the result of const eval (and any well formed requirements are checked for the parent anyways) we could let parameters only used in constants be bivariant afaik. Now, doing that doesn't actually fix the "unused parameter" errors, as these get triggered for all bivariant parameters which are not the target of a projection. We could change this to also allow bivariant parameters if they are used by constants, which I probably prefer 🤔

Making the substs invariant prevents the following from compiling, which is a bit unfortunate:

#![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
}

We generally have the issue that unevaluated.substs(tcx) isn't perfect. The generic arguments of an anonymous constant include parameters which aren't actually used by the constant. Right now we include all generic arguments, but even after filtering them, we will still include slightly too many as we can't wait until after we've typechecked the constant to figure out which generic parameters are used.

Considering the generic parameters used by constants to be "actually used" therefore has some forward compatibility concerns (once generic_const_exprs is stable):

#![feature(generic_const_exprs)]
struct Foo<T, const N: usize>([u8; N + 1]) where [u8; N + 1]: Trait<T>;
trait Trait<T> {}
impl<T, U> Trait<T> for U {}

The way we currently intend to filter the generic arguments supplied to anonymous constants should end up considering T to be used by N + 1. So this would compile. If we then find a need to improve this check or think of a better approach, changing this would be a break this code asT would then be unused.

This will probably be fine as writing code like that by accident is probably pretty rare, so even if this causes theoretical breakage, it shouldn't be an issue in real code.

Another solution to this far off potential breakage would be to change the "parameter never used" errors to be a deny by default lint. Having generic parameters be unused or bivariant isn't unsound so this way we should be able to allow this as a lint.

---

We could change this to also allow bivariant parameters if they are used by constants, which I probably prefer 🤔

@rust-lang/project-const-generics thoughts here?

[lcnr]

talked with @nikomatsakis about this and came to the following conclusions if i remember correctly:

• as long as the coherence_leak_check future compat lint is not an error having the substs of constants be bivariant is unsound, consider the following example

#![feature(generic_const_exprs)]
use std::marker::PhantomData;

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;
}

struct Foo<T: SadBee>([u8; <T as SadBee>::ASSOC], PhantomData<T>) where [(); <T as SadBee>::ASSOC]:,;

fn covariant(v: &'static Foo<for<'a> fn(&'a ())>) -> &'static Foo<fn(&'static ())> {
    v
}

fn main() {
    let y = covariant(&Foo([], PhantomData));
    println!("{:?}", y.0);
}

• making the substs invariant is therefore probably the right choice, if a bit unfortunate
• I am going to open an issue to improve this in the future once this PR is merged and also add the above example as a test.

[lcnr]

going to approve this PR even if it was previously a draft as it looks ready to me. Good job 👍

@bors r+

[bors]

📌 Commit a400f10 has been approved by lcnr