Avoid cyclic references due to F-bounds

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1120,7 +1120,12 @@ object Denotations {
       then this
       else if symbol.isAllOf(ClassTypeParam) then
         val arg = symbol.typeRef.argForParam(pre, widenAbstract = true)
-        if arg.exists then derivedSingleDenotation(symbol, symbol.info.bounds & arg.bounds, pre)
+        if arg.exists then
+          val newBounds =
+            if symbol.isCompleted && !symbol.info.containsLazyRefs
+            then symbol.info.bounds & arg.bounds
+            else arg.bounds
+          derivedSingleDenotation(symbol, newBounds, pre)
         else derived(symbol.info)
       else derived(symbol.info)
     }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -442,6 +442,14 @@ object Types {
     final def containsWildcardTypes(using Context) =
       existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false)
 
+    /** Does this type contain LazyRef types? */
+    final def containsLazyRefs(using Context) =
+      val acc = new TypeAccumulator[Boolean]:
+        def apply(x: Boolean, tp: Type): Boolean = tp match
+          case _: LazyRef => true
+          case _ => x || foldOver(x, tp)
+      acc(false, this)
+
 // ----- Higher-order combinators -----------------------------------
 
     /** Returns true if there is a part of this type that satisfies predicate `p`.