Fixed cycle detection.

Now detects the cycles reported by @retronym

Author: odersky

src/dotty/tools/dotc/core/StdNames.scala

@@ -304,6 +304,8 @@ object StdNames {
     val ArrayAnnotArg: N        = "ArrayAnnotArg"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
+    val DummyHi: N              = "DummyHi"
+    val DummyLo: N              = "DummyLo"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
     val Flag : N                = "Flag"
     val Ident: N                = "Ident"

src/dotty/tools/dotc/typer/Namer.scala

@@ -673,7 +673,7 @@ class Namer { typer: Typer =>
 
   def typeDefSig(tdef: TypeDef, sym: Symbol)(implicit ctx: Context): Type = {
     completeParams(tdef.tparams)
-    sym.info = TypeBounds.empty // avoid cyclic reference errors for F-bounds
+    setDummyInfo(sym)
     val tparamSyms = tdef.tparams map symbolOfTree
     val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
     val toParameterize = tparamSyms.nonEmpty && !isDerived
@@ -690,4 +690,21 @@ class Namer { typer: Typer =>
     sym.info = NoCompleter
     checkNonCyclic(sym, unsafeInfo, reportErrors = true)
   }
+
+  /** Temporarily set info of defined type T to
+   *
+   *     T >: dummyLo <: dummyHi
+   *     type dummyLo, dummyHi
+   *
+   *  This is done to avoid cyclic reference errors for F-bounds.
+   *  The type is intentionally chosen so that it cannot possibly be
+   *  elided when taking a union or intersection.
+   */
+  private def setDummyInfo(sym: Symbol)(implicit ctx: Context): Unit = {
+    def dummyBound(name: TypeName) =
+      ctx.newSymbol(sym.owner, name, Synthetic | Deferred, TypeBounds.empty)
+    val dummyLo = dummyBound(tpnme.DummyLo)
+    val dummyHi = dummyBound(tpnme.DummyHi)
+    sym.info = TypeBounds(TypeRef(NoPrefix, dummyLo), TypeRef(NoPrefix, dummyHi))
+  }
 }

test/dotc/tests.scala

@@ -104,7 +104,7 @@ class tests extends CompilerTest {
   @Test def neg_badAuxConstr = compileFile(negDir, "badAuxConstr", xerrors = 2)
   @Test def neg_typetest = compileFile(negDir, "typetest", xerrors = 1)
   @Test def neg_t1569_failedAvoid = compileFile(negDir, "t1569-failedAvoid", xerrors = 1)
-  @Test def neg_cycles = compileFile(negDir, "cycles", xerrors = 6)
+  @Test def neg_cycles = compileFile(negDir, "cycles", xerrors = 8)
   @Test def neg_boundspropagation = compileFile(negDir, "boundspropagation", xerrors = 4)
 
   @Test def dotc = compileDir(dotcDir + "tools/dotc", twice)(allowDeepSubtypes)

tests/neg/cycles.scala

@@ -27,3 +27,16 @@ class E {
   }
   val x: F#T = ???
 }
+
+class T1 {
+  type X = (U, U) // cycle
+  type U = X & Int
+}
+class T2 {
+  type X = (U, U) // cycle
+  type U = X | Int
+}
+object T12 {
+  ??? : (T1 {})#U
+  ??? : (T2 {})#U
+}