the same projection may use different candidates

[lcnr]

fn callee<T>(t: <T as Iterator>::Item) -> <T as IntoIterator>::Item
where
    T: Iterator,
{
    t
}

fn caller<T>(t: <T as Iterator>::Item) -> <T as IntoIterator>::Item
where
    T: Iterator + IntoIterator,
{
    callee::<T>(t)
}

here caller uses the IntoIterator ParamEnv candidate while callee uses an impl candidate.

[eddyb]

I believe this shows the same behavior (playground):

pub trait Id {
    type Out;
}

impl<T> Id for T {
    type Out = T;
}

pub fn callee<T>(x: T) -> <T as Id>::Out { x }

pub fn caller<T: Id>(x: T) -> <T as Id>::Out {
    // Uncomment to see what rustc thinks the type `<T as Id>::Out` is.
    // let _: <T as Id>::Out = x;

    callee(x)
}

Uncommenting that let gives an error with:

   = note: expected associated type `<T as Id>::Out`
               found type parameter `T`

[lcnr]

normalization via impl and where-bound may result in different types even without impossible where-bounds:

trait Trait {
    type Item;
}
impl<T> Trait for T {
    type Item = T;
}

fn callee<T>(t: T) -> <T as Trait>::Item {
    t
}

fn caller<T: Trait<Item = U>, U>(t: T) -> U {
    callee(t)
}