Add and handle test case with F-bounds.

Author: milessabin

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

@@ -4966,41 +4966,57 @@ object Types {
   }
 
   class TypeSizeAccumulator(implicit ctx: Context) extends TypeAccumulator[Int] {
-    def apply(n: Int, tp: Type): Int = tp match {
-      case tp: AppliedType =>
-        foldOver(n + 1, tp)
-      case tp: RefinedType =>
-        foldOver(n + 1, tp)
-      case tp: TypeRef if tp.info.isTypeAlias =>
-        apply(n, tp.superType)
-      case tp: TypeParamRef =>
-        apply(n, ctx.typeComparer.bounds(tp))
-      case _ =>
-        foldOver(n, tp)
+    val seen: util.HashSet[Type] = new util.HashSet[Type](64) {
+      override def hash(x: Type): Int = System.identityHashCode(x)
+      override def isEqual(x: Type, y: Type) = x.eq(y)
+    }
+    def apply(n: Int, tp: Type): Int =
+      if (seen contains tp) n
+      else {
+        seen.addEntry(tp)
+        tp match {
+        case tp: AppliedType =>
+          foldOver(n + 1, tp)
+        case tp: RefinedType =>
+          foldOver(n + 1, tp)
+        case tp: TypeRef if tp.info.isTypeAlias =>
+          apply(n, tp.superType)
+        case tp: TypeParamRef if !seen(tp) =>
+          apply(n, ctx.typeComparer.bounds(tp))
+        case _ =>
+          foldOver(n, tp)
+      }
     }
   }
 
   class CoveringSetAccumulator(implicit ctx: Context) extends TypeAccumulator[Set[Symbol]] {
+    val seen: util.HashSet[Type] = new util.HashSet[Type](64) {
+      override def hash(x: Type): Int = System.identityHashCode(x)
+      override def isEqual(x: Type, y: Type) = x.eq(y)
+    }
     def apply(cs: Set[Symbol], tp: Type): Set[Symbol] = {
-      val sym = tp.typeSymbol
-      tp match {
-        case tp if tp.isTopType || tp.isBottomType =>
-          cs
-        case tp: AppliedType =>
-          foldOver(cs + sym, tp)
-        case tp: RefinedType =>
-          foldOver(cs + sym, tp)
-        case tp: TypeRef if tp.info.isTypeAlias =>
-          apply(cs, tp.superType)
-        case tp: TypeRef if sym.isClass =>
-          foldOver(cs + sym, tp)
-        case tp: TermRef =>
-          val tsym = if (tp.termSymbol.is(Param)) tp.underlying.typeSymbol else tp.termSymbol
-          foldOver(cs + tsym, tp)
-        case tp: TypeParamRef =>
-          apply(cs, ctx.typeComparer.bounds(tp))
-        case other =>
-          foldOver(cs, tp)
+      if (seen contains tp) cs
+      else {
+        seen.addEntry(tp)
+        tp match {
+          case tp if tp.isTopType || tp.isBottomType =>
+            cs
+          case tp: AppliedType =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: RefinedType =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: TypeRef if tp.info.isTypeAlias =>
+            apply(cs, tp.superType)
+          case tp: TypeRef if tp.typeSymbol.isClass =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: TermRef =>
+            val tsym = if (tp.termSymbol.is(Param)) tp.underlying.typeSymbol else tp.termSymbol
+            foldOver(cs + tsym, tp)
+          case tp: TypeParamRef =>
+            apply(cs, ctx.typeComparer.bounds(tp))
+          case other =>
+            foldOver(cs, tp)
+        }
       }
     }
   }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -171,7 +171,8 @@ class CompilationTests extends ParallelTesting {
     compileList("duplicate source", List(
       "tests/neg-custom-args/toplevel-samesource/S.scala",
       "tests/neg-custom-args/toplevel-samesource/nested/S.scala"),
-      defaultOptions)
+      defaultOptions) +
+    compileFile("tests/neg-custom-args/i6300.scala", allowDeepSubtypes)
   }.checkExpectedErrors()
 
   @Test def fuzzyAll: Unit = {

tests/neg-custom-args/i6300.scala

@@ -0,0 +1,8 @@
+object Test {
+  class Foo[T <: Foo[T]]
+  class Bar extends Foo[Bar]
+
+  implicit def i[T <: Foo[T]](implicit t: Foo[Foo[T]]): Foo[T] = ???
+
+  implicitly[Foo[Bar]] // error
+}