inductive cycles as ambig causes unintended breakage

[lcnr]

trait Trait {
    type Item;
}

fn foo<A: Trait, B: Trait>()
where
    A::Item: Trait<Item = u32>,
    B::Item: Trait<Item = i32>,
{}

this should compile but fails with

error[E0283]: type annotations needed: cannot satisfy `<A as Trait>::Item: Trait`
 --> <source>:7:14
  |
7 |     A::Item: Trait<Item = u32>,
  |              ^^^^^^^^^^^^^^^^^
  |

The underlying issue is trying to prove <A as Trait>::Item: Trait normalizes the self type:

• normalizes-to(<A as Trait>::Item)
  • candidate A::Item: Trait<Item = u32>
    • alias-relate(A::Item, A)
      • normalizes-to(<A as Trait>::Item) inductive cycle
  • candidate B::Item: Trait<Item = i32>
    • alias-relate(B::Item, A)
      • normalizes-to(<B as Trait>::Item)
        • candidate A::Item: Trait<Item = u32>
          • alias-relate(A::Item, B)
            • normalizes-to(<A as Trait>::Item) inductive cycle
        • candidate B::Item: Trait<Item = i32>
          • alias-relate(B::Item, B)
            • normalizes-to(<B as Trait>::Item) inductive cycle

[lcnr]

original test by @aliemjay ❤️

pub trait ParallelIterator {
    type Item;
}

impl<T> ParallelIterator for T {
    type Item = u32;
}

trait Trait {}

impl<A, B> Trait for (A, B) where
    //~^ type annotations needed: cannot satisfy `<<A as ParallelIterator>::Item as ParallelIterator>::Item == u32`
    A: ParallelIterator,
    A::Item: ParallelIterator<Item = u32>,
    B: ParallelIterator,
    B::Item: ParallelIterator<Item = u32>,
{}


fn main() {}

[lcnr]

this is the underlying reason for #111, closing that issue

trait Trait<'a> {
    type Assoc;
}

fn foo<'a, T: Trait<'a>>()
where
    T::Assoc: Trait<'a>,
{}

this may also be the root cause of #89

[lcnr]

This affects nalgebra, thx @lqd for the minimization:

pub trait DimMin<D> {
    type Output;
}
pub fn repro<R: DimMin<C>, C>()
where
    <R as DimMin<C>>::Output: DimMin<C, Output = <R as DimMin<C>>::Output>,
{
}

[lcnr]

also causes an ICE when normalizing for implied bounds fails:

• tests/ui/associated-type-bounds/hrtb.rs

trait I<'a, 'b, 'c> {
    type As;
}
trait H<'d, 'e>: for<'f> I<'d, 'f, 'e> + 'd {}

struct X<'x, 'y> {
    x: std::marker::PhantomData<&'x ()>,
    y: std::marker::PhantomData<&'y ()>,
}

fn foo5<T>()
where
    T: for<'l, 'i> H<'l, 'i, As: for<'j> H<'j, 'i, As: for<'k> H<'j, 'k, As = X<'j, 'k>> + 'j> + 'i>
{
}

fn main() {}

[lcnr]

also affects, in general this issue gets avoided by the old solver as its param_env normalization doesn't handle normalizeable aliases correctly

• tests/ui/associated-type-bounds/supertrait-defines-ty.rs