normalization does not use impls covered by param env candidates

[lcnr]

the old solver does not consider impl candidates for normalization if there is also a candidate from the environment:

trait Trait {
    type Assoc;
}

impl<T> Trait for T {
    type Assoc = T;
}

fn foo<T: Trait>(x: T) -> <T as Trait>::Assoc {
    x // ERROR
}

godbolt

This will presumably break if we instead normalize projections for environment trait bounds to "rigid projections" because there will now be ambiguity again. This is concerning as "rigid projections" are considered as one of the longterm solutions for #1.

[lcnr]

see https://rust-lang.zulipchat.com/#narrow/stream/362009-t-types.2Fetc.2Flazy-norm-strategems/topic/.60Projection.60.20assumption.20vs.20requirement/near/350538718 for some discussion about using rigid projections to solve #1.

I remember there being some discussion on zulip whether this behavior is desirable but I can't find that discussion right now.

I am also worried that this is a breaking change:

#![allow(warnings)]
trait Trait<U> {
    type Assoc;
}

impl<T> Trait<u64> for T {
    type Assoc = T;
}

fn lazy_init<T: Trait<U>, U>() -> (T, <T as Trait<U>>::Assoc) {
    todo!()
}

fn foo<T: Trait<u32, Assoc = T>>(x: T) {
    // `U` can be both `u32` and `u64` here.
    let (delayed, mut proj) = lazy_init::<_, _>();
    proj = x;
    let _: T = delayed;
}

This snippet is currently incomplete and I think only works with -Ztrait-solver=next because the new solver still relies on the old project code.

[lcnr]

this impacts inference (and causes issues for eager norm)

pub trait Trait {
    type Assoc;
}

pub trait ImplementedDownstream {}

impl<T: ImplementedDownstream> Trait for Vec<T> {
    type Assoc = T;
}

pub fn foo<T>()
where
    Vec<T>: Trait
{
   let _: <Vec<_> as Trait>::Assoc = todo!();
} 

[aliemjay]

From #31 (comment):

This means that we're using a different candidate when solving T: Trait than when normalizing <T as Trait>::Ty. I don't think it is unsound but it can lead to some surprising behavior like this requiring 'a == 'static despite using the impl candidate for normalization:

trait Trait<'a> {
    type Ty;
}

impl<T> Trait<'_> for T {
    type Ty = ();
}

fn test<'a, T: Trait<'static>>() {
    let _: <T as Trait<'a>>::Ty = ();
    //~^ ERROR lifetime may not live long enough
}

[lcnr]

this results in a fun breaking change: #76

[lcnr]

another breaking change because of this:

trait Trait<'a> {
    type Assoc;
}

impl<T> Trait<'static> for T {
    type Assoc = ();
}

// normalizing requires `'a == 'static`, the trait bound does not.
fn foo<'a, T: Trait<'a>>(_: T::Assoc) {}