nll: respect user type annotations with constants in expressions

[nikomatsakis]

Breaking out from #47184 as a subtask:

We need to respect user annotations when referencing constants in expressions. First job: come up with some test cases.

[nikomatsakis]

Assigning to myself to investigate, write up some instructions, etc

[nikomatsakis]

Test case #1 (should not compile, does):

#![feature(nll)]

trait Foo<'a> {
    const C: &'a u32;
}

impl<'a, T> Foo<'a> for T {
    const C: &'a u32 = &22;
}

fn foo<'a>(_: &'a u32) -> &'static u32 {
    <() as Foo<'a>>::C
}

fn main() {
}

[nikomatsakis]

Test case #2 (same story):

#![feature(nll)]

struct Foo<'a> { x: &'a u32 }

impl<'a> Foo<'a> {
    const C: &'a u32 = &22;
}

fn foo<'a>(_: &'a u32) -> &'static u32 {
    <Foo<'a>>::C
}

fn main() {
}

[nikomatsakis]

Test case #3:

#![feature(nll)]

trait Foo<'a> {
    const C: &'a u32;
}

impl<'a, T> Foo<'a> for T {
    const C: &'a u32 = &22;
}

fn foo<'a, T: Foo<'a>>() -> &'static u32 {
    <T as Foo<'a>>::C
}

fn main() {
}

[nikomatsakis]

The fix for this will have to build on #55093

[nikomatsakis]

That PR adds the ability for user type annotations to be more complex than they presently are. I think we need to extend the UserTypeAnnotation type to account for constants. In the branch, it is:

pub enum UserTypeAnnotation<'tcx> {
    Ty(CanonicalTy<'tcx>),
    FnDef(DefId, CanonicalUserSubsts<'tcx>),
    AdtDef(&'tcx AdtDef, CanonicalUserSubsts<'tcx>),
}

So something like this:

pub enum UserTypeAnnotation<'tcx> {
    Ty(CanonicalTy<'tcx>),
    FnDef(DefId, CanonicalUserSubsts<'tcx>),
    AdtDef(&'tcx AdtDef, CanonicalUserSubsts<'tcx>),
    ConstantDef(DefId, CanonicalUserSubsts<'tcx>),
}

Next, there is code that instantiates these "user type annotations" in various ways in:

src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs

It looks sort of like this:

    match user_ty {
        UserTypeAnnotation::Ty(canonical_ty) => ...,
        UserTypeAnnotation::FnDef(def_id, canonical_substs) => ...,
        ...
    }

I think we need to extend this with a case for ConstantDef -- or maybe we can actually adapt the FnDef code so it works for both cases (maybe even merge the two variants).

It would work like so:

• Instantiate the canonical_substs with fresh variables (like FnDef)
• Fetch the type_of for def_id and substitute the canonical_substs (different from FnDef, but that same code would probably work for fns too)
• Relate the types and apply the user_self_ty exactly as with FnDef

If we do that, then the only thing we have left to do is to find the FIXME(#47184) spots that pertain to constants and propagate the user-substs onto those spots.