Store GadtConstraint in CaseDef instead of peepholing

dwijnand · dwijnand · commit ad67b7a775a8 · 2022-10-03T15:58:17.000+01:00
diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -1852,7 +1852,7 @@ class JSCodeGen()(using genCtx: Context) {
         js.Block(genStatsAndExpr)
 
       case GadtExpr(_, expr) =>
-        genExpr(expr)
+        genStatOrExpr(expr, isStat)
 
       case Typed(expr, _) =>
         expr match {
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
@@ -125,22 +125,24 @@ class TreeTypeMap(
           transformInlined(inlined)
         case GadtExpr(gadt, expr) =>
           cpy.GadtExpr(expr)(gadt, transform(expr))
-        case cdef @ CaseDef(pat, guard, expr @ GadtExpr(gadt, rhs)) =>
-          val patVars1 = patVars(pat)
-          val tmap = withMappedSyms(patVars1 ::: gadt.symbols.diff(substFrom).diff(patVars1))
-          val gadt1 = tmap.rebuild(gadt)
-          inContext(ctx.withGadt(gadt1)) {
-            val pat1 = tmap.transform(pat)
-            val guard1 = tmap.transform(guard)
-            val rhs1 = cpy.GadtExpr(expr)(gadt1, tmap.transform(rhs))
-            cpy.CaseDef(cdef)(pat1, guard1, rhs1)
-          }
         case cdef @ CaseDef(pat, guard, rhs) =>
-          val tmap = withMappedSyms(patVars(pat))
-          val pat1 = tmap.transform(pat)
-          val guard1 = tmap.transform(guard)
-          val rhs1 = tmap.transform(rhs)
-          cpy.CaseDef(cdef)(pat1, guard1, rhs1)
+          val patVars1 = patVars(pat)
+          cdef.gadt match
+            case EmptyGadtConstraint =>
+              val tmap   = withMappedSyms(patVars1)
+              val pat1   = tmap.transform(pat)
+              val guard1 = tmap.transform(guard)
+              val rhs1   = tmap.transform(rhs)
+              cpy.CaseDef(cdef)(pat1, guard1, rhs1)
+            case _ =>
+              val tmap = withMappedSyms(patVars1 ::: cdef.gadt.symbols.diff(substFrom).diff(patVars1))
+              val gadt1 = tmap.rebuild(cdef.gadt)
+              inContext(ctx.withGadt(gadt1)) {
+                val pat1   = tmap.transform(pat)
+                val guard1 = tmap.transform(guard)
+                val rhs1   = tmap.transform(rhs)
+                cpy.CaseDef(cdef)(pat1, guard1, rhs1, gadt1)
+              }
         case labeled @ Labeled(bind, expr) =>
           val tmap = withMappedSyms(bind.symbol :: Nil)
           val bind1 = tmap.transformSub(bind)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -614,7 +614,7 @@ object Trees {
   }
 
   /** case pat if guard => body */
-  case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])(val gadt: GadtConstraint)(implicit @constructorOnly src: SourceFile)
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = CaseDef[T]
   }
@@ -1233,9 +1233,9 @@ object Trees {
         case tree: InlineMatch => finalize(tree, untpd.InlineMatch(selector, cases)(sourceFile(tree)))
         case _ => finalize(tree, untpd.Match(selector, cases)(sourceFile(tree)))
       }
-      def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef = tree match {
+      def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree, gadt: GadtConstraint)(using Context): CaseDef = tree match {
         case tree: CaseDef if (pat eq tree.pat) && (guard eq tree.guard) && (body eq tree.body) => tree
-        case _ => finalize(tree, untpd.CaseDef(pat, guard, body)(sourceFile(tree)))
+        case _ => finalize(tree, untpd.CaseDef(pat, guard, body, gadt)(sourceFile(tree)))
       }
       def Labeled(tree: Tree)(bind: Bind, expr: Tree)(using Context): Labeled = tree match {
         case tree: Labeled if (bind eq tree.bind) && (expr eq tree.expr) => tree
@@ -1355,8 +1355,8 @@ object Trees {
         If(tree: Tree)(cond, thenp, elsep)
       def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(using Context): Closure =
         Closure(tree: Tree)(env, meth, tpt)
-      def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body)(using Context): CaseDef =
-        CaseDef(tree: Tree)(pat, guard, body)
+      def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body, gadt: GadtConstraint = tree.gadt)(using Context): CaseDef =
+        CaseDef(tree: Tree)(pat, guard, body, gadt)
       def Try(tree: Try)(expr: Tree = tree.expr, cases: List[CaseDef] = tree.cases, finalizer: Tree = tree.finalizer)(using Context): Try =
         Try(tree: Tree)(expr, cases, finalizer)
       def UnApply(tree: UnApply)(fun: Tree = tree.fun, implicits: List[Tree] = tree.implicits, patterns: List[Tree] = tree.patterns)(using Context): UnApply =
@@ -1442,10 +1442,8 @@ object Trees {
               cpy.Match(tree)(transform(selector), transformSub(cases))
             case GadtExpr(gadt, expr) =>
               inContext(ctx.withGadt(gadt))(cpy.GadtExpr(tree)(gadt, transform(expr)))
-            case CaseDef(pat, guard, body @ GadtExpr(gadt, _)) =>
-              inContext(ctx.withGadt(gadt))(cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body)))
-            case CaseDef(pat, guard, body) =>
-              cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body))
+            case cdef @ CaseDef(pat, guard, body) =>
+              inContext(ctx.withGadt(cdef.gadt))(cpy.CaseDef(cdef)(transform(pat), transform(guard), transform(body)))
             case Labeled(bind, expr) =>
               cpy.Labeled(tree)(transformSub(bind), transform(expr))
             case Return(expr, from) =>
@@ -1582,10 +1580,8 @@ object Trees {
               this(this(x, selector), cases)
             case GadtExpr(gadt, expr) =>
               inContext(ctx.withGadt(gadt))(this(x, expr))
-            case CaseDef(pat, guard, body @ GadtExpr(gadt, _)) =>
-              inContext(ctx.withGadt(gadt))(this(this(this(x, pat), guard), body))
-            case CaseDef(pat, guard, body) =>
-              this(this(this(x, pat), guard), body)
+            case cdef @ CaseDef(pat, guard, body) =>
+              inContext(ctx.withGadt(cdef.gadt))(this(this(this(x, pat), guard), body))
             case Labeled(bind, expr) =>
               this(this(x, bind), expr)
             case Return(expr, from) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -131,8 +131,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Closure(meth, tss => rhsFn(tss.head).changeOwner(ctx.owner, meth))
   }
 
-  def CaseDef(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef =
-    ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
+  def CaseDef(pat: Tree, guard: Tree, body: Tree, gadt: GadtConstraint = EmptyGadtConstraint)(using Context): CaseDef =
+    ta.assignType(untpd.CaseDef(pat, guard, body, gadt), pat, body)
 
   def Match(selector: Tree, cases: List[CaseDef])(using Context): Match =
     ta.assignType(untpd.Match(selector, cases), selector, cases)
@@ -713,8 +713,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef = {
-      val tree1 = untpdCpy.CaseDef(tree)(pat, guard, body)
+    override def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree, gadt: GadtConstraint)(using Context): CaseDef = {
+      val tree1 = untpdCpy.CaseDef(tree)(pat, guard, body, gadt)
       tree match {
         case tree: CaseDef if body.tpe eq tree.body.tpe => tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, pat, body)
@@ -770,8 +770,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       If(tree: Tree)(cond, thenp, elsep)
     override def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(using Context): Closure =
       Closure(tree: Tree)(env, meth, tpt)
-    override def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body)(using Context): CaseDef =
-      CaseDef(tree: Tree)(pat, guard, body)
+    override def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body, gadt: GadtConstraint = tree.gadt)(using Context): CaseDef =
+      CaseDef(tree: Tree)(pat, guard, body, gadt)
     override def Try(tree: Try)(expr: Tree = tree.expr, cases: List[CaseDef] = tree.cases, finalizer: Tree = tree.finalizer)(using Context): Try =
       Try(tree: Tree)(expr, cases, finalizer)
   }
@@ -1305,7 +1305,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tree.tpe.widen isRef numericCls)
       tree
     else {
-      report.warning(i"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.")
+      report.warning(i"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.", tree.srcPos)
       Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withSpan(tree.span)
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -388,7 +388,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit src: SourceFile): Closure = new Closure(env, meth, tpt)
   def Match(selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): Match = new Match(selector, cases)
   def InlineMatch(selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): Match = new InlineMatch(selector, cases)
-  def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit src: SourceFile): CaseDef = new CaseDef(pat, guard, body)
+  def CaseDef(pat: Tree, guard: Tree, body: Tree, gadt: GadtConstraint = EmptyGadtConstraint)(implicit src: SourceFile): CaseDef = new CaseDef(pat, guard, body)(gadt)
   def Labeled(bind: Bind, expr: Tree)(implicit src: SourceFile): Labeled = new Labeled(bind, expr)
   def Return(expr: Tree, from: Tree)(implicit src: SourceFile): Return = new Return(expr, from)
   def WhileDo(cond: Tree, body: Tree)(implicit src: SourceFile): WhileDo = new WhileDo(cond, body)
diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -308,7 +308,7 @@ final class ProperGadtConstraint private(
       && mapping        == that.mapping
       && reverseMapping == that.reverseMapping
       && wasConstrained == that.wasConstrained
-    case _ => false
+    case _ => mapping.isEmpty
 
   override def toText(printer: Printer): Texts.Text = printer.toText(this)
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -472,21 +472,6 @@ class TreePickler(pickler: TastyPickler) {
           writeByte(BLOCK)
           stats.foreach(preRegister)
           withLength { pickleTree(expr); stats.foreach(pickleTree) }
-        case GadtExpr(gadt, expr) =>
-          writeByte(GADTEXPR)
-          withLength {
-            for (symbols, nestingLevel) <- gadt.inputs do
-              writeByte(CONSTRAINT)
-              withLength {
-                writeInt(nestingLevel)
-                for sym <- symbols do
-                  val TypeBounds(lo, hi) = gadt.fullBounds(sym).nn
-                  pickleSymRef(sym)
-                  pickleType(lo)
-                  pickleType(hi)
-              }
-            pickleTree(expr)
-          }
         case tree @ If(cond, thenp, elsep) =>
           writeByte(IF)
           withLength {
@@ -511,9 +496,23 @@ class TreePickler(pickler: TastyPickler) {
             else pickleTree(selector)
             tree.cases.foreach(pickleTree)
           }
-        case CaseDef(pat, guard, rhs) =>
+        case tree @ CaseDef(pat, guard, rhs) =>
           writeByte(CASEDEF)
-          withLength { pickleTree(pat); pickleTree(rhs); pickleTreeUnlessEmpty(guard) }
+          withLength {
+            for (symbols, nestingLevel) <- tree.gadt.inputs do
+              writeByte(CONSTRAINT)
+              withLength {
+                writeInt(nestingLevel)
+                for sym <- symbols do
+                  val TypeBounds(lo, hi) = tree.gadt.fullBounds(sym).nn
+                  pickleSymRef(sym)
+                  pickleType(lo)
+                  pickleType(hi)
+              }
+            pickleTree(pat)
+            pickleTree(rhs)
+            pickleTreeUnlessEmpty(guard)
+          }
         case Return(expr, from) =>
           writeByte(RETURN)
           withLength { pickleSymRef(from.symbol); pickleTreeUnlessEmpty(expr) }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1245,27 +1245,6 @@ class TreeUnpickler(reader: TastyReader,
               skipTree()
               readStats(ctx.owner, end,
                 (stats, ctx) => Block(stats, exprReader.readTerm()(using ctx)))
-            case GADTEXPR =>
-              val gadt = EmptyGadtConstraint.fresh
-              while nextByte == CONSTRAINT do
-                readByte()
-                val end = readEnd()
-                val nestingLevel = readInt()
-                val constraints = until(end)((readSymRef(), readType(), readType()))
-                gadt.addToConstraint(constraints.map(_._1), nestingLevel)
-                for (sym, lo, hi) <- constraints do
-                  if (sym.typeRef <:< lo)(using ctx.withGadt(gadt)) then
-                    // add in reverse order so that unification runs in the right direction (keep sym)
-                    // for a counter-example: say the symbol is c: b and the bound is b
-                    // if we add c >: b it will unify to b: c not c: b
-                    gadt.addBound(sym, hi, isUpper = true)
-                    gadt.addBound(sym, lo, isUpper = false)
-                  else
-                    gadt.addBound(sym, lo, isUpper = false)
-                    gadt.addBound(sym, hi, isUpper = true)
-              end while
-              val expr = inContext(ctx.withGadt(gadt))(readTerm())
-              GadtExpr(gadt, expr)
             case INLINED =>
               val exprReader = fork
               skipTree()
@@ -1463,10 +1442,32 @@ class TreeUnpickler(reader: TastyReader,
       val start = currentAddr
       assert(readByte() == CASEDEF)
       val end = readEnd()
-      val pat = readTerm()
-      val rhs = readTerm()
-      val guard = ifBefore(end)(readTerm(), EmptyTree)
-      setSpan(start, CaseDef(pat, guard, rhs))
+      val originalCtx = ctx
+      val gadt = if nextByte == CONSTRAINT then EmptyGadtConstraint.fresh else originalCtx.gadt
+      while nextByte == CONSTRAINT do
+        readByte()
+        val end = readEnd()
+        val nestingLevel = readInt()
+        val constraints = until(end)((readSymRef(), readType(), readType()))
+        gadt.addToConstraint(constraints.map(_._1), nestingLevel)
+        for (sym, lo, hi) <- constraints do
+          if (sym.typeRef <:< lo)(using ctx.withGadt(gadt)) then
+            // add in reverse order so that unification runs in the right direction (keep sym)
+            // for a counter-example: say the symbol is c: b and the bound is b
+            // if we add c >: b it will unify to b: c not c: b
+            gadt.addBound(sym, hi, isUpper = true)
+            gadt.addBound(sym, lo, isUpper = false)
+          else
+            gadt.addBound(sym, lo, isUpper = false)
+            gadt.addBound(sym, hi, isUpper = true)
+      end while
+      inContext(ctx.withGadt(gadt)) {
+        val pat = readTerm()
+        val rhs = readTerm()
+        val guard = ifBefore(end)(readTerm(), EmptyTree)
+        val gadt1 = if gadt eq originalCtx.gadt then EmptyGadtConstraint else gadt
+        setSpan(start, CaseDef(pat, guard, rhs, gadt1))
+      }
     }
 
     def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context ?=> T)(using Context): Trees.Lazy[T] =
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -494,8 +494,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             else toText(sel)
           selTxt ~ keywordStr(" match ") ~ blockText(cases)
         }
-      case CaseDef(pat, guard, body) =>
-        keywordStr("case ") ~ inPattern(toText(pat)) ~ optText(guard)(keywordStr(" if ") ~ _) ~ " => " ~ caseBlockText(body)
+      case cdef @ CaseDef(pat, guard, body) =>
+        keywordStr("case ") ~ inPattern(toText(pat))
+          ~ (" ~ " ~ toText(cdef.gadt)).provided(cdef.gadt != EmptyGadtConstraint)
+          ~ optText(guard)(keywordStr(" if ") ~ _)
+          ~ " => " ~ caseBlockText(body)
       case Labeled(bind, expr) =>
         changePrec(GlobalPrec) { toText(bind.name) ~ keywordStr("[") ~ toText(bind.symbol.info) ~ keywordStr("]: ") ~ toText(expr) }
       case Return(expr, from) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -816,6 +816,17 @@ object Erasure {
       }
     }
 
+    override def typedGadtExpr(tree: untpd.GadtExpr, pt: Type)(using Context): GadtExpr = tree match {
+      case GadtExpr(gadt, expr @ If(cond, _, _)) =>
+        // type the condition without installing the gadt constraints
+        // so that TypeTestsCasts can correctly check type tests
+        val cond1 = typed(cond, defn.BooleanType)
+        val expr1 = cpy.If(expr.withType(expr.tpe))(cond = cond1)
+        val gadt1 = cpy.GadtExpr(tree.withType(tree.tpe))(gadt, expr1)
+        super.typedGadtExpr(gadt1, pt)
+      case _ => super.typedGadtExpr(tree, pt)
+    }
+
     /** Besides normal typing, this method does uncurrying and collects parameters
      *  to anonymous functions of arity > 22.
      */
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -147,7 +147,7 @@ object PatternMatcher {
     sealed abstract class Plan { val id: Int = nxId; nxId += 1 }
 
     case class TestPlan(test: Test, var scrutinee: Tree, span: Span,
-                        var onSuccess: Plan) extends Plan {
+                        var onSuccess: Plan)(var gadt: GadtConstraint) extends Plan {
       override def equals(that: Any): Boolean = that match {
         case that: TestPlan => this.scrutinee === that.scrutinee && this.test == that.test
         case _ => false
@@ -164,6 +164,8 @@ object PatternMatcher {
     object TestPlan {
       def apply(test: Test, sym: Symbol, span: Span, ons: Plan): TestPlan =
         TestPlan(test, ref(sym), span, ons)
+      def apply(test: Test, scr: Tree, span: Span, ons: Plan): TestPlan =
+        TestPlan(test, scr, span, ons)(EmptyGadtConstraint)
     }
 
     /** The different kinds of tests */
@@ -453,7 +455,11 @@ object PatternMatcher {
       var onSuccess: Plan = ResultPlan(cdef.body)
       if (!cdef.guard.isEmpty)
         onSuccess = TestPlan(GuardTest, cdef.guard, cdef.guard.span, onSuccess)
-      patternPlan(scrutinee, cdef.pat, onSuccess)
+      patternPlan(scrutinee, cdef.pat, onSuccess) match
+        case plan: TestPlan =>
+          plan.gadt = cdef.gadt
+          plan
+        case plan           => plan
     }
 
     private def matchPlan(tree: Match): Plan =
@@ -930,7 +936,8 @@ object PatternMatcher {
                 If(conditions, emit(plan.onSuccess), unitLiteral)
             }
           }
-          emitWithMashedConditions(plan :: Nil)
+          val tree = emitWithMashedConditions(plan :: Nil)
+          if plan.gadt == EmptyGadtConstraint then tree else GadtExpr(plan.gadt, tree)
         case LetPlan(sym, body) =>
           val valDef = ValDef(sym, initializer(sym).ensureConforms(sym.info), inferred = true).withSpan(sym.span)
           seq(valDef :: Nil, emit(body))
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -266,9 +266,11 @@ abstract class Recheck extends Phase, SymTransformer:
       TypeComparer.lub(casesTypes)
 
     def recheckCase(tree: CaseDef, selType: Type, pt: Type)(using Context): Type =
-      recheck(tree.pat, selType)
-      recheck(tree.guard, defn.BooleanType)
-      recheck(tree.body, pt)
+      inContext(ctx.withGadt(if tree.gadt == EmptyGadtConstraint then ctx.gadt else tree.gadt)) {
+        recheck(tree.pat, selType)
+        recheck(tree.guard, defn.BooleanType)
+        recheck(tree.body, pt)
+      }
 
     def recheckReturn(tree: Return)(using Context): Type =
       // Avoid local pattern defined symbols in returns from matchResult blocks
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1302,7 +1302,8 @@ trait Applications extends Compatibility {
 
         qual match
           case TypeApply(qual1, targs) =>
-            tryWithTypeArgs(qual1, targs.mapconserve(typedType(_)))((t, ts) =>
+            val ctx1 = ctx.fresh.setFreshGADTBounds
+            tryWithTypeArgs(qual1, targs.mapconserve(typedType(_)(using ctx1)))((t, ts) =>
               tryWithTypeArgs(qual, Nil)(fallBack))
           case _ =>
             tryWithTypeArgs(qual, Nil)(fallBack)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
diff --git a/compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala b/compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
diff --git a/tests/pos/gadt-expr.protoquill.scala b/tests/pos/gadt-expr.protoquill.scala
