Fix #7820: Break cycle when computing completerTypeParams

The following no longer crashes:

    class C { type F[X <: F[_, _], Y] }

But it is still flagged as a cyclic reference error, whereas nsc accepts it. I believe it would be
tricky/risky to change dotc's algorithms to accept it as well, and I am not sure it's
necessary. Generally, we want to get away from F-bounds, so just accepting the most
common use case (F-bounds in method type parameters) is hopefully OK.

Author: odersky

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

@@ -944,28 +944,27 @@ class Namer { typer: Typer =>
     private var nestedCtx: Context = null
     assert(!original.isClassDef)
 
-    override def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] = {
-      if (myTypeParams == null) {
+    override def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] =
+      if myTypeParams == null then
         //println(i"completing type params of $sym in ${sym.owner}")
         nestedCtx = localContext(sym).setNewScope
-        myTypeParams = {
-          implicit val ctx = nestedCtx
-          def typeParamTrees(tdef: Tree): List[TypeDef] = tdef match {
-            case TypeDef(_, original) =>
-              original match {
-                case LambdaTypeTree(tparams, _) => tparams
-                case original: DerivedFromParamTree => typeParamTrees(original.watched)
-                case _ => Nil
-              }
-            case _ => Nil
-          }
-          val tparams = typeParamTrees(original)
-          completeParams(tparams)
-          tparams.map(symbolOfTree(_).asType)
-        }
-      }
+        given Context = nestedCtx
+
+        def typeParamTrees(tdef: Tree): List[TypeDef] = tdef match
+          case TypeDef(_, original) =>
+            original match
+              case LambdaTypeTree(tparams, _) => tparams
+              case original: DerivedFromParamTree => typeParamTrees(original.watched)
+              case _ => Nil
+          case _ => Nil
+
+        val tparams = typeParamTrees(original)
+        index(tparams)
+        myTypeParams = tparams.map(symbolOfTree(_).asType)
+        for param <- tparams do typedAheadExpr(param)
+      end if
       myTypeParams
-    }
+    end completerTypeParams
 
     override protected def typeSig(sym: Symbol): Type =
       typeDefSig(original, sym, completerTypeParams(sym)(ictx))(nestedCtx)

tests/neg/i7820.scala

@@ -0,0 +1,3 @@
+trait A1 { type F[X <: F[_, _], Y] }  // error: cyclic reference involving type F
+trait A2 { type F[X <: F, Y] }        // error: cyclic reference involving type F
+trait A3 { type F[X >: F, Y] }        // error: cyclic reference involving type F