Make i7044 typecheck with old version of recover

Author: abgruszecki

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

@@ -751,7 +751,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
                 case _ => false
             }
           case _ => false
-        comparePaths || isNewSubType(tp1.underlying.widenExpr)
+        comparePaths || isSubType(tp1.underlying.widenExpr, tp2, approx.addLow)
       case tp1: RefinedType =>
         isNewSubType(tp1.parent)
       case tp1: RecType =>

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

@@ -198,10 +198,12 @@ object Inferencing {
       *   - If we have A <: Int and F <: [A] => Option[A] (note the invariance),
       *     then we should approximate F[A] ~~ Option[A]. That is, we should
       *     respect the invariance of the type constructor.
-      *   - If we have A <: Option[B] and B <: Int, we approximate A ~~ Option[Int].
-      *     That is, we recursively approximate all nested GADT-constrained types.
-      *     This is certain to be sound (because we maintain necessary subtyping),
-      *     but not accurate.
+      *   - If we have A <: Option[B] and B <: Int, we approximate A ~~
+      *     Option[B]. That is, we don't recurse into already approximated
+      *     types. Since GADT approximation is (for now) only used for member
+      *     selection, this behaviour is expected, as nested types cannot affect
+      *     member selection (note that given/extension lookup doesn't need GADT
+      *     approx, see gadt-approximation-interaction.scala).
       */
     def apply(tp: Type): Type = tp.dealias match {
       case tp @ TypeRef(qual, nme) if (qual eq NoPrefix)

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

@@ -3458,37 +3458,10 @@ class Typer extends Namer
 
       // try an implicit conversion
       val prevConstraint = ctx.typerState.constraint
-      def recover(failure: SearchFailureType) = {
-        def canTryGADTHealing: Boolean = {
-          def isDummy = tree.hasAttachment(dummyTreeOfType.IsDummyTree)
-          tryGadtHealing // allow GADT healing only once to avoid a loop
-          && ctx.gadt.nonEmpty // GADT healing only makes sense if there are GADT constraints present
-          && !isDummy // avoid healing a dummy tree as it can lead to an error in a very specific case
-        }
-
+      def recover(failure: SearchFailureType) =
         if (isFullyDefined(wtp, force = ForceDegree.all) &&
             ctx.typerState.constraint.ne(prevConstraint)) readapt(tree)
-        else if (canTryGADTHealing) {
-          // try recovering with a GADT approximation
-          // note: this seems be be important only in a very specific case
-          // where we select a member from so
-          val nestedCtx = ctx.fresh.setNewTyperState()
-          val ascribed = tpd.Typed(tree, TypeTree(gadtApprox))
-          val res =
-            readapt(
-              tree = ascribed,
-              shouldTryGadtHealing = false,
-            )(using nestedCtx)
-          if (!nestedCtx.reporter.hasErrors) {
-            // GADT recovery successful
-            nestedCtx.typerState.commit()
-            res
-          } else {
-            // otherwise fail with the error that would have been reported without the GADT recovery
-            err.typeMismatch(tree, pt, failure)
-          }
-        } else 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