class Foo[T <: U, U <: T] // error: cycle

class Bar[T >: T] // error: cycle

class A {
  val x: T = ???
  type T <: x.type // error: cycle
}

class B {
  type T <: x.type // error: cycle
  final val x: T = ???
}

class C {
  final val x: D#T = ???
  class D {
    type T <: x.type // error: cycle
    val z: x.type = ???
  }
}

class E {
  class F {
    type T <: x.type // error: not stable
    val z: x.type = ??? // error: not stable
  }
  lazy val x: F#T = ???
}

class T1 {
  type X = (U, U) // error: cycle
  type U = X & Int
}
class T2 {
  type X = (U, U) // error: cycle
  type U = X | Int
}
object T12 {
  ??? : (T1 {})#U // error: conflicting bounds
  ??? : (T2 {})#U // error: conflicting bounds
}

class Foo[T <: U, U <: T] // error: illegal cyclic reference: upper bound U of type T refers back to the type itself

class Bar[T >: T] // error: illegal cyclic reference: lower bound T of type T refers back to the type itself


class A {
  val x: T = ???
  type T <: x.type // error: cyclic reference involving value x
}

class B {
  type T <: x.type // error: illegal cyclic reference: upper bound B.this.T(B.this.x) of type T refers back to the type itself
  val x: T = ???
}

class C {
  final val x: D#T = ???
  class D {
    type T <: x.type // error: cyclic reference involving value x
    val z: x.type = ???
  }
}

class E {
  class F {
    type T <: x.type // error: not stable
    val z: x.type = ??? // error: not stable
  }
  lazy val x: F#T = ???
}

class T1 {
  type X = (U, U) // error: cycle
  type U = X & Int
}
class T2 {
  type X = (U, U) // error: cycle
  type U = X | Int
}
object T12 {
  ??? : (T1 {})#U // error: conflicting bounds
  ??? : (T2 {})#U // error: conflicting bounds
}

Annotate test with // error indications
Annotate test with // error indications

We had same fleyness in number of errors of cycle.scala
which prompted this.
