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