Add QuotePattern AST node

Author: nicolasstucki

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

@@ -737,13 +737,18 @@ object Trees {
     type ThisTree[+T <: Untyped] = Splice[T]
   }
 
+  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]
+  }
+
   /** A tree representing a pattern splice `${ pattern }`, `$ident` or `$ident(args*)` in a quote pattern.
    *
    *  Parser will only create `${ pattern }` and `$ident`, hence they will not have args.
    *  While typing, the `$ident(args*)` the args are identified and desugared into a `SplicePattern`
    *  containing them.
    *
-   *  SplicePattern are removed after typing the pattern and are not present in TASTy.
+   *  SplicePattern are removed after typing the pattern and are not present in TASTy. (TODO update)
    *
    *  @param body  The tree that was spliced
    *  @param args  The arguments of the splice (the HOAS arguments)
@@ -1163,6 +1168,7 @@ object Trees {
     type Inlined = Trees.Inlined[T]
     type Quote = Trees.Quote[T]
     type Splice = Trees.Splice[T]
+    type QuotePattern = Trees.QuotePattern[T]
     type SplicePattern = Trees.SplicePattern[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
@@ -1342,6 +1348,10 @@ object Trees {
         case tree: Splice if (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Splice(expr)(sourceFile(tree)))
       }
+      def QuotePattern(tree: Tree)(bindings: List[Tree], body: Tree, quotes: Tree)(using Context): QuotePattern = tree match {
+        case tree: QuotePattern if (bindings eq tree.bindings) && (body eq tree.body) && (quotes eq tree.quotes) => tree
+        case _ => finalize(tree, untpd.QuotePattern(bindings, body, quotes)(sourceFile(tree)))
+      }
       def SplicePattern(tree: Tree)(body: Tree, args: List[Tree])(using Context): SplicePattern = tree match {
         case tree: SplicePattern if (body eq tree.body) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.SplicePattern(body, args)(sourceFile(tree)))
@@ -1587,6 +1597,8 @@ object Trees {
               cpy.Quote(tree)(transform(body)(using quoteContext), transform(tags))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr)(using spliceContext))
+            case tree @ QuotePattern(bindings, body, quotes) =>
+              cpy.QuotePattern(tree)(transform(bindings), transform(body)(using quoteContext), transform(quotes))
             case tree @ SplicePattern(body, args) =>
               cpy.SplicePattern(tree)(transform(body)(using spliceContext), transform(args))
             case tree @ Hole(isTerm, idx, args, content) =>
@@ -1734,6 +1746,8 @@ object Trees {
               this(this(x, body)(using quoteContext), tags)
             case Splice(expr) =>
               this(x, expr)(using spliceContext)
+            case QuotePattern(bindings, body, quotes) =>
+              this(this(this(x, bindings), body)(using quoteContext), quotes)
             case SplicePattern(body, args) =>
               this(this(x, body)(using spliceContext), args)
             case Hole(_, _, args, content) =>

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

@@ -173,6 +173,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Quote(body: Tree, tags: List[Tree])(using Context): Quote =
     untpd.Quote(body, tags).withBodyType(body.tpe)
 
+  def QuotePattern(bindings: List[Tree], body: Tree, quotes: Tree, proto: Type)(using Context): QuotePattern =
+    ta.assignType(untpd.QuotePattern(bindings, body, quotes), proto)
+
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
 

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

@@ -399,6 +399,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit src: SourceFile): Inlined = new Inlined(call, bindings, expansion)
   def Quote(body: Tree, tags: List[Tree])(implicit src: SourceFile): Quote = new Quote(body, tags)
   def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
+  def QuotePattern(bindings: List[Tree], body: Tree, quotes: Tree)(implicit src: SourceFile): QuotePattern = new QuotePattern(bindings, body, quotes)
   def SplicePattern(body: Tree, args: List[Tree])(implicit src: SourceFile): SplicePattern = new SplicePattern(body, args)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -741,6 +741,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+      case tree @ QuotePattern(bindings, body, quotes) =>
+        // TODO print quotes for debugging
+        val bindingsText = bindings.map(binding => {
+          keywordStr("type ") ~ toText(binding.symbol.name) ~ toText(binding.symbol.info) ~ "; "
+        }).reduceLeft(_ ~~ _).provided(bindings.nonEmpty)
+        val open = if (body.isTerm) keywordStr("{") else keywordStr("[")
+        val close = if (body.isTerm) keywordStr("}") else keywordStr("]")
+        keywordStr("'") ~ open ~ bindingsText ~ toTextGlobal(body) ~ close
       case SplicePattern(pattern, args) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ {

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

@@ -508,6 +508,9 @@ trait TypeAssigner {
   def assignType(tree: untpd.UnApply, proto: Type)(using Context): UnApply =
     tree.withType(proto)
 
+  def assignType(tree: untpd.QuotePattern, proto: Type)(using Context): QuotePattern =
+    tree.withType(proto)
+
   def assignType(tree: untpd.ValDef, sym: Symbol)(using Context): ValDef =
     tree.withType(if (sym.exists) assertExists(sym.termRef) else NoType)