Infinite loop when type indirectly bound by itself

[smarter]

The following (devious) code results in an infinite loop:

class A {
  type T <: x.type
  val x: T = 42
}

This could probably be fixed by improving the checks for cycles, but it might be simpler and saner to just disallow having types bound by x.type, just like scalac, what do you think?
CC @odersky @namin .

[odersky]

Yes, maybe. What would be a good rule to rule out these bounds?

[smarter]

Hmm, I don't see a better way to do it than having some kind of recursive check in TypeBounds, which isn't very nice:

def isValidBound(bound: Type): Boolean = bound match {
  case TermRef(_, _) => false
  case AndType(tp1, tp2) => isValidBound(tp1) && isValidBound(tp2)
  case OrType(tp1, tp2) => isValidBound(tp1) && isValidBound(tp2)
  case ...
  case _ => true
}

By the way, I actually misunderstood what scalac allows, this is allowed:

class A {
  type T <: x.type
  val x: AnyRef = ???
}

The difference is that dotty doesn't require x to be an AnyRef.

[smarter]

Also, I'm beginning to think that there might be somewhat legitimate uses for types bounded by singleton types like:

class O[T](t: T)
class A[T](t: T) {
  val x: O[t.type] = new O[t.type](t)
}

So I'll see if I can improve the checks for cycles instead.