Fix lampepfl#7044: Added GADT recovery with fallback to default error on failure.

Author: radeusgd

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

@@ -213,21 +213,8 @@ object Inferencing {
         mapOver(tp)
     }
 
-    // private class UpperInstantiator(implicit ctx: Context) extends TypeAccumulator[Unit] {
-    //   def apply(x: Unit, tp: Type): Unit = {
-    //     tp match {
-    //       case tvar: TypeVar if !tvar.isInstantiated =>
-    //         instantiate(tvar, fromBelow = false)
-    //       case _ =>
-    //     }
-    //     foldOver(x, tp)
-    //   }
-    // }
-
     def process(tp: Type): Type = {
-      val res = apply(tp)
-      // if (res && toMaximize) new UpperInstantiator().apply((), tp)
-      res
+      apply(tp)
     }
   }
 

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

@@ -2765,7 +2765,7 @@ class Typer extends Namer
    */
   def adapt(tree: Tree, pt: Type, locked: TypeVars, tryGadtHealing: Boolean = true)(using Context): Tree = {
     val last = Thread.currentThread.getStackTrace()(2).toString;
-    trace/*.force*/(i"adapting (tryGadtHealing=$tryGadtHealing) $tree to $pt\n{callsite: $last}", typr, show = true) {
+    trace(i"adapting (tryGadtHealing=$tryGadtHealing) $tree to $pt\n{callsite: $last}", typr, show = true) {
       record("adapt")
       adapt1(tree, pt, locked, tryGadtHealing)
     }
@@ -2775,7 +2775,6 @@ class Typer extends Namer
     adapt(tree, pt, ctx.typerState.ownedVars)
 
   private def adapt1(tree: Tree, pt: Type, locked: TypeVars, tryGadtHealing: Boolean)(using Context): Tree = {
-    // assert(pt.exists && !pt.isInstanceOf[ExprType])
     assert(pt.exists && !pt.isInstanceOf[ExprType] || ctx.reporter.errorsReported)
     def methodStr = err.refStr(methPart(tree).tpe)
 
@@ -3272,6 +3271,7 @@ class Typer extends Namer
         foo = $foo
         pt.isInstanceOf[SelectionProto] = ${pt.isInstanceOf[SelectionProto]}
         ctx.gadt.nonEmpty = ${ctx.gadt.nonEmpty}
+        ctx.gadt = ${ctx.gadt.debugBoundsDescription}
         pt.isMatchedBy = ${
           if (pt.isInstanceOf[SelectionProto])
             pt.asInstanceOf[SelectionProto].isMatchedBy(foo).toString
@@ -3316,20 +3316,31 @@ class Typer extends Namer
       def recover(failure: SearchFailureType) =
         {
           debug.println("recover")
-        if (isFullyDefined(wtp, force = ForceDegree.all) &&
-            ctx.typerState.constraint.ne(prevConstraint)) readapt(tree)
-        // else if ({
-        //   debug.println(i"tryGadtHealing=$tryGadtHealing && \n\tctx.gadt.nonEmpty=${ctx.gadt.nonEmpty}")
-        //   tryGadtHealing && ctx.gadt.nonEmpty
-        // })
-        //  {
-        //    debug.println("here")
-        //    readapt(
-        //    tree = tpd.Typed(tree, TypeTree(Inferencing.approximateGADT(wtp))),
-        //    shouldTryGadtHealing = false,
-        //    )
-        //  }
-        else err.typeMismatch(tree, pt, failure)
+          if (isFullyDefined(wtp, force = ForceDegree.all) &&
+              ctx.typerState.constraint.ne(prevConstraint)) readapt(tree)
+          else if ({
+            debug.println(i"tryGadtHealing=$tryGadtHealing && \n\tctx.gadt.nonEmpty=${ctx.gadt.nonEmpty}")
+            tryGadtHealing && ctx.gadt.nonEmpty
+          })
+           {
+             debug.println("//try recover with GADT approximation")
+             val nestedCtx = ctx.fresh.setNewTyperState()
+             val res =
+               readapt(
+                 tree = tpd.Typed(tree, TypeTree(Inferencing.approximateGADT(wtp))),
+                 shouldTryGadtHealing = false,
+               )(using nestedCtx)
+             if (!nestedCtx.reporter.hasErrors) {
+               nestedCtx.typerState.commit()
+               debug.println("// GADT recovery successful")
+               res
+             } else {
+               // otherwise fail with the error that would have been reported without GADT recovery
+               debug.println("// GADT recovery failed, falling back to original error")
+               err.typeMismatch(tree, pt, failure)
+             }
+           }
+          else err.typeMismatch(tree, pt, failure)
         }
       if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
         if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then

tests/neg/boundspropagation.scala

@@ -25,19 +25,6 @@ object test3 {
   }
 }
 
-// Example contributed by Jason.
-object test4 {
-  class Base {
-    type N
-
-    class Tree[-S, -T >: Option[S]]
-
-    def g(x: Any): Tree[_, _ <: Option[N]] = x match {
-      case y: Tree[_, _] => y                         // error -- used to work (because of capture conversion?)
-    }
-  }
-}
-
 class Test5 {
 "": ({ type U = this.type })#U                        // error
 }

tests/pos/i7044.scala

@@ -0,0 +1,14 @@
+object i7044 {
+  case class Seg[T](pat:Pat[T], body:T)
+
+  trait Pat[T]
+  object Pat {
+    case class Expr()            extends Pat[Int]
+    case class Opt[S](el:Pat[S]) extends Pat[Option[S]]
+  }
+
+  def test[T](s:Seg[T]):Int = s match {
+    case Seg(Pat.Expr(),body)          => body + 1
+    case Seg(Pat.Opt(Pat.Expr()),body) => body.get
+  }
+}