normalizes-to bound in old solver is stronger than new solver

[compiler-errors]

fn next<T: Iterator<Item = U>, U>(t: &mut T) -> Option<U> {
    t.next()
}

fn foo<T: Iterator>(t: &mut T) {
    let _: Option<T::Item> = next(t);
}

In foo, the bound T::Item normalizes-to T::Item holds in the old solver in order for us to infer U = T::Item in the call to next.

---

This issue has been fixed by splitting Projection and NormalizesTo goals. Projection goals get proven by simply equating the alias and the term while NormalizesTo actually requires normalization.

(originally compiler-errors/next-solver-hir-issues#1 (comment))

[compiler-errors]

https://rust-lang.zulipchat.com/#narrow/stream/362009-t-types.2Fetc.2Flazy-norm-strategems/topic/.60Projection.60.20assumption.20vs.20requirement

@lcnr has a doc: https://hackmd.io/noGGefTfQ0eCARFb3D0tJw

[lcnr]

this is necessary to compile core. minimized:

trait Iterator {
    type Item;
}

struct Flatten<I>(I);

impl<I, U> Iterator for Flatten<I>
where
    I: Iterator<Item = U>,
{
    type Item = U;
}

fn needs_iterator<I: Iterator>() {}

fn environment<J>()
where
    J: Iterator,
{
    needs_iterator::<Flatten<J>>();
}

fn main() {}