Keep QuotePattern until staging

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -740,6 +740,11 @@ object Trees {
   case class QuotePattern[+T <: Untyped] private[ast] (bindings: List[Tree[T]], body: Tree[T], quotes: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends PatternTree[T] {
     type ThisTree[+T <: Untyped] = QuotePattern[T]
+
+    /** Type of the quoted expression as seen from outside the quote */
+    def bodyType(using Context): Type =
+      val quoteType = typeOpt // `Expr[T]` or `Type[T]`
+      quoteType.argInfos.head // T
   }
 
   /** A tree representing a pattern splice `${ pattern }`, `$ident` or `$ident(args*)` in a quote pattern.

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -19,6 +19,7 @@ import config.Config
 import collection.mutable
 import reporting.{Profile, NoProfile}
 import dotty.tools.tasty.TastyFormat.ASTsSection
+import quoted.QuotePatterns
 
 object TreePickler:
   class StackSizeExceeded(val mdef: tpd.MemberDef) extends Exception
@@ -685,6 +686,9 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
+        case tree: QuotePattern =>
+          // TODO: Add QUOTEPATTERN tag to TASTy
+          pickleTree(QuotePatterns.encode(tree))
         case Hole(_, idx, args, _) =>
           writeByte(HOLE)
           withLength {

compiler/src/dotty/tools/dotc/quoted/QuotePatterns.scala

@@ -67,7 +67,9 @@ object QuotePatterns:
         val patternTypes = quotePattern.bindings.map { binding =>
           val sym = binding.symbol
           val typeSym = newSymbol(ctx.owner, sym.name ++ "$inPattern" /* TODO remove $inPattern */, EmptyFlags, sym.info, NoSymbol, binding.span)
-          typeSym.addAnnotation(Annotation(New(ref(defn.QuotedRuntimePatterns_patternTypeAnnot.typeRef)).withSpan(binding.span)))
+          typeSym.addAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot)
+          for fromAbove <- sym.getAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot) do
+            typeSym.addAnnotation(fromAbove)
           TypeDef(typeSym.asType).withSpan(binding.span)
         }
         new TreeTypeMap(
@@ -195,6 +197,9 @@ object QuotePatterns:
               case _ => false
             }
             val shapeBindingSyms = tdef.symbol :: tdefs.map(_.symbol)
+            for (binding, shapeBinding) <- bindings.zip(shapeBindingSyms) do
+              if shapeBinding.hasAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot) then
+                binding.symbol.addAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot)
             val body1 = if stats.isEmpty then expr else cpy.Block(block)(stats, expr)
             body1.subst(shapeBindingSyms, bindings.map(_.symbol))
           case body => body

compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala

@@ -10,8 +10,9 @@ import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.quoted.QuotePatterns
 import dotty.tools.dotc.staging.QuoteTypeTags.*
+import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.SrcPos
@@ -104,6 +105,16 @@ class CrossStageSafety extends TreeMapWithStages {
       case _: DefDef if tree.symbol.isInlineMethod =>
         tree
 
+      case tree: CaseDef if level == 0 =>
+        val pat1 = new TreeMap {
+          override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match
+            case tree: QuotePattern if level == 0 =>
+              super.transform(QuotePatterns.encode(tree))
+            case tree => super.transform(tree)
+        }.transform(tree.pat)
+        val tree1 = cpy.CaseDef(tree)(pat1, tree.guard, tree.body)
+        super.transform(tree1)
+
       case _ if !inQuoteOrSpliceScope =>
         checkAnnotations(tree) // Check quotes in annotations
         super.transform(tree)

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -488,6 +488,15 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case _: Quote =>
           ctx.compilationUnit.needsStaging = true
           super.transform(tree)
+        case _: QuotePattern =>
+          if !ctx.reporter.errorsReported then
+            Checking.checkAppliedTypesIn(TypeTree(tree.tpe).withSpan(tree.span))
+          ctx.compilationUnit.needsStaging = true
+          super.transform(tree)
+        case tree: SplicePattern =>
+          if !ctx.reporter.errorsReported then
+            Checking.checkAppliedTypesIn(TypeTree(tree.tpe).withSpan(tree.span))
+          super.transform(tree)
         case tree =>
           super.transform(tree)
       }

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

@@ -102,6 +102,9 @@ trait QuotesAndSplices {
       case tree => tree
   }
 
+  def typedQuotePattern(tree: untpd.QuotePattern, pt: Type)(using Context): Tree =
+    throw new UnsupportedOperationException("cannot type check a Hole node")
+
   def typedSplicePattern(tree: untpd.SplicePattern, pt: Type)(using Context): Tree = {
     record("typedSplicePattern")
     if isFullyDefined(pt, ForceDegree.flipBottom) then
@@ -448,7 +451,6 @@ trait QuotesAndSplices {
 
     val decoded = QuotePatterns.decode(patternUnapply)
     decoded.foreach(QuotePatterns.checkPattern)
-    val encoded = decoded.map(QuotePatterns.encode).getOrElse(patternUnapply)
-    encoded
+    decoded.getOrElse(patternUnapply)
   }
 }

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

@@ -111,6 +111,27 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
     val expr1 = typed(tree.expr, quoteType)(using spliceContext)
     untpd.cpy.Splice(tree)(expr1).withType(tree.typeOpt)
 
+  override def typedQuotePattern(tree: untpd.QuotePattern, pt: Type)(using Context): Tree =
+    assertTyped(tree)
+    val bindings1 = tree.bindings.map(typed(_))
+    val bodyCtx = quoteContext.retractMode(Mode.Pattern)//.addMode(Mode.QuotedPattern)
+    val body1 = typed(tree.body, tree.bodyType)(using bodyCtx)
+    val quotes1 = typed(tree.quotes, defn.QuotesClass.typeRef)
+    untpd.cpy.QuotePattern(tree)(bindings1, body1, quotes1).withType(tree.typeOpt)
+
+
+  override def typedSplicePattern(tree: untpd.SplicePattern, pt: Type)(using Context): Tree =
+    assertTyped(tree)
+    val args1 = tree.args.mapconserve(typedExpr(_))
+    val patternTpe =
+      if args1.isEmpty then tree.typeOpt
+      else defn.FunctionType(args1.size).appliedTo(args1.map(_.tpe) :+ tree.typeOpt)
+    val bodyCtx = spliceContext.addMode(Mode.Pattern)
+    val body1 = typed(tree.body, defn.QuotedExprClass.typeRef.appliedTo(patternTpe))(using bodyCtx)
+    val args = tree.args.mapconserve(typedExpr(_))
+    untpd.cpy.SplicePattern(tree)(body1, args1).withType(tree.typeOpt)
+
+
   override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
     promote(tree)
 

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

@@ -3102,6 +3102,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case untpd.EmptyTree => tpd.EmptyTree
           case tree: untpd.Quote => typedQuote(tree, pt)
           case tree: untpd.Splice => typedSplice(tree, pt)
+          case tree: untpd.QuotePattern => typedQuotePattern(tree, pt)
           case tree: untpd.SplicePattern => typedSplicePattern(tree, pt)
           case tree: untpd.MacroTree => report.error("Unexpected macro", tree.srcPos); tpd.nullLiteral  // ill-formed code may reach here
           case tree: untpd.Hole => typedHole(tree, pt)