`fn fudge_inference_if_ok` can result in unnormalizeable aliases

[lcnr]

trait Trait {
    type Assoc;
}
impl<T: Trait> Trait for W<T> {
    type Assoc = T::Assoc;
}
impl Trait for i32 {
    type Assoc = i32;
}

struct W<T>(T);
fn foo<T: Trait>(_: <T as Trait>::Assoc) -> T {
    todo!()
}

fn main() {
    let x: W<_> = foo(1);
    let _: W<i32> = x;
}

fails in the new solver

error[E0282]: type annotations needed
  --> src/main.rs:18:23
   |
18 |     let x: W<_> = foo(1);
   |                       ^ cannot infer type

The reason is that we fudge inference to compute the expectation for the call to foo. After equating the output of foo with W<?x> its input is <W<?new_var> as Trait>::Assoc with ?new_var :> ?x. We then fudge ?new_var, dropping the way its relatedd to ?x, meaning that this inference variable will never get constrained.

[lcnr]

impacts gramma https://rust-lang.zulipchat.com/#narrow/channel/364551-t-types.2Ftrait-system-refactor/topic/crater.20triage.3A.20.60gramma.60.20cannot.20satisfy.20.60.2E.2E.2E.20normalizes-to.20T.60/with/547825474

Thanks @lqd

enum Either<L, R> {
    Left(L),
    Right(R),
}
impl<L, R> Iterator for Either<L, R>
where
    L: Iterator,
    R: Iterator<Item = L::Item>,
{
    type Item = L::Item;
    fn next(&mut self) -> Option<Self::Item> {
        todo!()
    }
}

pub enum OneOrMany<I: Iterator> {
    One(I::Item),
    Many(I),
}
pub fn repro<T>(iter: impl IntoIterator<Item = T>) -> OneOrMany<impl Iterator<Item = T>> {
    let mut iter = iter.into_iter();
    // if the order of two ifs is reversed: no error
    if true {
        return OneOrMany::Many(Either::Left(iter));
    }
    if let Some(first) = iter.next() {
        return OneOrMany::One(first);
    }

    OneOrMany::Many(Either::Right(iter))
}

[lcnr]

impacts gitforge, crater logs, godbolt

pub struct Error;

trait Throw {
    type Error;
    fn from_error(error: Self::Error) -> Self;
}
impl<T, E> Throw for Result<T, E> {
    type Error = E;
    fn from_error(_: Self::Error) -> Self {
        unimplemented!()
    }
}

fn op<F, T>(_: F) -> Result<T, Error>
where
    F: FnOnce() -> Result<T, Error>,
{
    unimplemented!()
}
pub fn repro() -> Result<(), Error> {
    op(|| Throw::from_error(Error))?
}

We fudge the argument of from_error which ends up as <Result<?48t, Error> as Throw>::Error.