Show root of stackoverflow in IsFullyDefinedAccumulator

This gives a better diagnsosis for #12640.

Author: odersky

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

@@ -167,33 +167,36 @@ object Inferencing {
 
     private var toMaximize: List[TypeVar] = Nil
 
-    def apply(x: Boolean, tp: Type): Boolean = tp.dealias match {
-      case _: WildcardType | _: ProtoType =>
-        false
-      case tvar: TypeVar if !tvar.isInstantiated =>
-        force.appliesTo(tvar)
-        && ctx.typerState.constraint.contains(tvar)
-        && {
-          val direction = instDirection(tvar.origin)
-          if minimizeSelected then
-            if direction <= 0 && tvar.hasNonWildcardLowerBound then
+    def apply(x: Boolean, tp: Type): Boolean =
+      try tp.dealias match
+        case _: WildcardType | _: ProtoType =>
+          false
+        case tvar: TypeVar if !tvar.isInstantiated =>
+          force.appliesTo(tvar)
+          && ctx.typerState.constraint.contains(tvar)
+          && {
+            val direction = instDirection(tvar.origin)
+            if minimizeSelected then
+              if direction <= 0 && tvar.hasNonWildcardLowerBound then
+                instantiate(tvar, fromBelow = true)
+              else if direction >= 0 && tvar.hasNonWildcardUpperBound then
+                instantiate(tvar, fromBelow = false)
+              // else hold off instantiating unbounded unconstrained variable
+            else if direction != 0 then
+              instantiate(tvar, fromBelow = direction < 0)
+            else if variance >= 0 && (force.ifBottom == IfBottom.ok || tvar.hasLowerBound) then
               instantiate(tvar, fromBelow = true)
-            else if direction >= 0 && tvar.hasNonWildcardUpperBound then
-              instantiate(tvar, fromBelow = false)
-            // else hold off instantiating unbounded unconstrained variable
-          else if direction != 0 then
-            instantiate(tvar, fromBelow = direction < 0)
-          else if variance >= 0 && (force.ifBottom == IfBottom.ok || tvar.hasLowerBound) then
-            instantiate(tvar, fromBelow = true)
-          else if variance >= 0 && force.ifBottom == IfBottom.fail then
-            return false
-          else
-            toMaximize = tvar :: toMaximize
-          foldOver(x, tvar)
-        }
-      case tp =>
-        foldOver(x, tp)
-    }
+            else if variance >= 0 && force.ifBottom == IfBottom.fail then
+              return false
+            else
+              toMaximize = tvar :: toMaximize
+            foldOver(x, tvar)
+          }
+        case tp =>
+          foldOver(x, tp)
+      catch case ex: Throwable =>
+        handleRecursive("traverse ", s"${tp.show}" , ex)
+
 
     def process(tp: Type): Boolean =
       // Maximize type vars in the order they were visited before */

tests/neg/i12640.scala

@@ -0,0 +1,17 @@
+package x
+
+trait CpsMonad[F[_]]:
+  def pure[A](x:A): F[A]
+  def flatMap[A,B](fa:F[A])(f: A=>F[B]): F[B]
+
+abstract sealed class CpsStream[-F[_],+T]
+
+case class Cons[F[_],T](head:T, tailFun: ()=>F[CpsStream[F,T]]) extends CpsStream[F,T]
+
+case class Empty[F[_]]() extends CpsStream[F,Nothing]
+
+def unfold[S,F[_]:CpsMonad,T](s0:S)(f:S => F[Option[(S,T)]]):F[CpsStream[F,T]] =
+      summon[CpsMonad[F]].flatMap(f(s0)){
+         case Some(s1,a) => Cons(a, () => unfold(s1,f))
+         case None => summon[CpsMonad[F]].pure(Empty[F]())
+      }