Handle AvoidMap recursions

Issue a diagnostic instead of crashing when there is a stack overflow

Avoids the crash in the minimized version of #15365

Author: odersky

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

@@ -423,38 +423,42 @@ object TypeOps:
         sym.is(Package) || sym.isStatic && isStaticPrefix(pre.prefix)
       case _ => true
 
-    override def apply(tp: Type): Type = tp match
-      case tp: TermRef
-      if toAvoid(tp) =>
-        tp.info.widenExpr.dealias match {
-          case info: SingletonType => apply(info)
-          case info => range(defn.NothingType, apply(info))
-        }
-      case tp: TypeRef if toAvoid(tp) =>
-        tp.info match {
-          case info: AliasingBounds =>
-            apply(info.alias)
-          case TypeBounds(lo, hi) =>
-            range(atVariance(-variance)(apply(lo)), apply(hi))
-          case info: ClassInfo =>
-            range(defn.NothingType, apply(classBound(info)))
+    override def apply(tp: Type): Type =
+      try
+        tp match
+          case tp: TermRef
+          if toAvoid(tp) =>
+            tp.info.widenExpr.dealias match {
+              case info: SingletonType => apply(info)
+              case info => range(defn.NothingType, apply(info))
+            }
+          case tp: TypeRef if toAvoid(tp) =>
+            tp.info match {
+              case info: AliasingBounds =>
+                apply(info.alias)
+              case TypeBounds(lo, hi) =>
+                range(atVariance(-variance)(apply(lo)), apply(hi))
+              case info: ClassInfo =>
+                range(defn.NothingType, apply(classBound(info)))
+              case _ =>
+                emptyRange // should happen only in error cases
+            }
+          case tp: ThisType =>
+            // ThisType is only used inside a class.
+            // Therefore, either they don't appear in the type to be avoided, or
+            // it must be a class that encloses the block whose type is to be avoided.
+            tp
+          case tp: LazyRef =>
+            if localParamRefs.contains(tp.ref) then tp
+            else if isExpandingBounds then emptyRange
+            else mapOver(tp)
+          case tl: HKTypeLambda =>
+            localParamRefs ++= tl.paramRefs
+            mapOver(tl)
           case _ =>
-            emptyRange // should happen only in error cases
-        }
-      case tp: ThisType =>
-        // ThisType is only used inside a class.
-        // Therefore, either they don't appear in the type to be avoided, or
-        // it must be a class that encloses the block whose type is to be avoided.
-        tp
-      case tp: LazyRef =>
-        if localParamRefs.contains(tp.ref) then tp
-        else if isExpandingBounds then emptyRange
-        else mapOver(tp)
-      case tl: HKTypeLambda =>
-        localParamRefs ++= tl.paramRefs
-        mapOver(tl)
-      case _ =>
-        super.apply(tp)
+            super.apply(tp)
+      catch case ex: Throwable =>
+        handleRecursive("traversing for avoiding local references", s"${tp.show}" , ex)
     end apply
 
     /** Three deviations from standard derivedSelect:
@@ -498,6 +502,7 @@ object TypeOps:
    *  this as Future Work™.
    */
   def avoid(tp: Type, symsToAvoid: => List[Symbol])(using Context): Type = {
+    println(i"WIDEN $tp with $symsToAvoid%, % in ${ctx.typerState.constraint}")
     val widenMap = new AvoidMap {
       @threadUnsafe lazy val forbidden = symsToAvoid.toSet
       def toAvoid(tp: NamedType) =
@@ -508,6 +513,7 @@ object TypeOps:
         case tp: TypeVar if mapCtx.typerState.constraint.contains(tp) =>
           val lo = TypeComparer.instanceType(
             tp.origin, fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound)(using mapCtx)
+          println(i"INST $tp to $lo")
           val lo1 = apply(lo)
           if (lo1 ne lo) lo1 else tp
         case _ =>
@@ -516,6 +522,7 @@ object TypeOps:
     }
 
     widenMap(tp)
+      .showing(i"DONE $tp")
   }
 
   /** If `tpe` is of the form `p.x` where `p` refers to a package

tests/pos/i15365.scala

@@ -0,0 +1,17 @@
+trait Tagged[U]
+type WithTag[+TT, UU] = TT & Tagged[UU]
+
+trait FromInput[Val]
+implicit def coercedScalaInput[Tc1]: FromInput[WithTag[Tc1, Int]] = ???
+implicit def optionInput[To](implicit ev: FromInput[To]): FromInput[Option[To]] = ???
+
+trait WithoutInputTypeTags[TW]
+implicit def coercedOptArgTpe[Tc]: WithoutInputTypeTags[Option[WithTag[Tc, Int]]] = ???
+
+trait InputType[+TI]
+class OptionInputType[TO](ofType: InputType[TO]) extends InputType[Option[TO]]
+
+type Argument[TA]
+def argument[Ta](argumentType: InputType[Ta])(implicit fromInput: FromInput[Ta], res: WithoutInputTypeTags[Ta]): Argument[Option[Ta]] = ???
+
+def test = argument(OptionInputType(??? : InputType[WithTag[Boolean, Int]])) :: Nil