reblessive regression: rely on item bounds of not-yet-defined opaque types

[compiler-errors]

https://crater-reports.s3.amazonaws.com/pr-133502-2/try%23da0a4799770027c4c578bf48cdb390acfde09023/reg/reblessive-0.4.3/log.txt

async fn mirror<T>(t: T) -> T {
    let x = Box::pin(mirror(String::new())).await;
    let recur = x.len();
    
    t
}

Recursive non-defining use. Old solver can solve {opaque#0}::<String>: Future<Output = ?x> and constrains the type of variable x.

[lcnr]

The above issue contains two issues:

Relying on inference guidance from item bounds of not yet inferred opaque types:

trait Id {
    type This;
}
impl<T> Id for T {
    type This = T;
}
fn to_assoc<T>(x: T) -> <T as Id>::This {
    x
}

fn mirror<T>(x: Vec<T>) -> impl Id<This = Vec<T>> {
    let x = to_assoc(mirror(x));
    // `?x` equals `<opaque::<T> as Id>::This`. As the hidden type of `opaque::<T>`
    // is still unknown at this point, the method below.
    x.len();
    x
}

[lcnr]

and #135. From what I can tell reblessive only breaks due to this issue and does not have a non-universal use in the defining scope.

[compiler-errors]

Another repro:

trait Test {
    type Output;
    fn method(self) -> Self::Output;
}
impl Test for () {
    type Output = Bar;
    fn method(self) -> Bar { Bar }
}

struct Bar;
impl Bar {
    fn bar(&self) {}
}

fn foo() -> impl Test<Output = Bar> {
    let x = Test::method(foo());
    x.bar();
}

Fixing this requires us to fix two independent issues:

1. Opaques may only be related to the goal's self ty via subtyping. This requires us to canonicalize at least part of the subtyping graph.
2. We get a cycle when (e.g.) equating the assumption impl Sized: Sized and the goal ?0: Sized, since that then subsequently requires proving ?0: Sized in the process of normalizing impl Sized to its hidden type ?0. We could get around this by folding the item bounds of the opaque.

[compiler-errors]

We also probably should not equate the self type of the goal with the hidden type of the opaque. This probably necessitates folding the item bounds of the opaque like I mentioned in (2.) above.