builtin object candidates: `ReplaceProjectionWith` relate failures

[lcnr]

encountered during try builds when compiling wasmparser.

pub trait Trait: Super {}
pub trait Super {
    type Output;
}

fn bound<T: Trait + ?Sized>() {}
fn visit_simd_operator<V: Super + ?Sized>() {
    bound::<dyn Trait<Output = <V as Super>::Output>>();
}

compiles on stable, results in the following ICE with the new solver

thread 'rustc' panicked at /home/lcnr/rust/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs:930:26:
expected to be able to unify goal projection with dyn's projection: NoSolution

[compiler-errors]

Above example shouldn't ICE if we don't walk into the dyn Trait type itself (which we shouldn't need to, of course, but we do b/c of the way the folder is set up today), but that's insufficient b/c this still ICEs:

trait Other<X> {}

trait Foo<T: Foo<T>>: Other<<T as Foo<T>>::Assoc> {
    type Assoc;
}

impl<T> Foo<T> for T {
    type Assoc = ();
}

impl<T: ?Sized> Other<()> for T {}

fn is_foo<T: Foo<()> + ?Sized>() {}

fn main() {
    is_foo::<dyn Foo<(), Assoc = ()>>();
}

It should be sufficient just to check that the self type of the projection to be replaced is Self (the trait object itself) b/c any other recursive mentions of <Self as Trait>::Assoc should be disallowed by the logic in rust-lang/rust#126090.

[compiler-errors]

A more interesting example that shows that we can't just use structural relation:

trait Other<T> {}
impl<T> Other<T> for T {}

trait Super<T> {
    type Assoc;
}

trait Mirror {
    type Assoc;
}
impl<T> Mirror for T {
    type Assoc = T;
}

trait Foo<A, B>: Super<<A as Mirror>::Assoc, Assoc = A> {
    type FooAssoc: Other<<Self as Super<<A as Mirror>::Assoc>>::Assoc>;
}

fn is_foo<T, U>(x: &(impl Foo<T, U> + ?Sized)) {}

fn test(x: &dyn Foo<i32, u32, FooAssoc = i32>) {
    is_foo::<i32, u32>(x);
}

fn main() {}

b/c we'll need to emit <i32 as Mirror>::Assoc == i32 goals when relating the alias w/ its replacement.