Associated type bounds can be used to prove themselves with trivial where-clauses

[compiler-errors]

trait Foo {
    type Assoc: Bar
        where Self: Foo;
}

trait Bar {}

impl Foo for () {
    type Assoc = ()
        where Self: Foo;
}

This side-steps the check that associated type bounds may only be used if we have a param-env predicate that "roots" the associated type. See the doc comment on validate_alias_bound_self_from_param_env.

Turns out this is not a complete solution.

[compiler-errors]

#46 is the same problem as this, and #59 is related but for type-outlives obligations

[compiler-errors]

Unsound :(

trait Foo {
    type Assoc<'a>: Static
        where Self: Foo;
}

trait Static {
    fn uwu(self) -> &'static str;
}
impl Static for &'static str {
    fn uwu(self) -> &'static str { self }
}

impl Foo for () {
    type Assoc<'a> = &'a str
        where Self: Foo;
}

fn hello<T: Foo>(x: T::Assoc<'_>) -> &'static str {
    T::Assoc::uwu(x)
}


fn main() {
    let x = String::new();
    let x: &'static str = hello::<()>(&x);
}

[compiler-errors]

The correct fix here:

• Prove item bounds when normalizes-to being proven via impl (or built-impl, anything that requires its bounds to hold for it to be WF; i.e. not a param-env normalizes-to candidate)
• Prove concrete-ty alias-eq associated type in compare_type_predicate_entailment or whatever it's called (check_type_items_bounds?)

[compiler-errors]

But the hacky fix:

• Eagerly fold item bounds to replace with T::Alias with ConcreteTy before proving item bounds in check_type_item_bounds.