Quoted patterns: type checking

Author: odersky

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

@@ -1178,6 +1178,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
+  /** An extractor for typed splices */
+  object Splice {
+    def apply(tree: Tree)(implicit ctx: Context): Tree =
+      ref(defn.InternalQuoted_exprSplice).appliedTo(tree)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
+      case Apply(fn, arg :: Nil) if fn.symbol == defn.InternalQuoted_exprSplice => Some(arg)
+      case _ => None
+    }
+  }
+
   /** A key to be used in a context property that tracks enclosing inlined calls */
   private val InlinedCalls = new Property.Key[List[Tree]]
 

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

@@ -93,7 +93,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = !isTerm
   }
   case class Throw(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
-  case class Quote(t: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Quote(quoted: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class Splice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class TypSplice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
   case class DoWhile(body: Tree, cond: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
@@ -492,9 +492,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Throw if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Throw(expr)(tree.source))
     }
-    def Quote(tree: Tree)(t: Tree)(implicit ctx: Context): Tree = tree match {
-      case tree: Quote if t eq tree.t => tree
-      case _ => finalize(tree, untpd.Quote(t)(tree.source))
+    def Quote(tree: Tree)(quoted: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: Quote if quoted eq tree.quoted => tree
+      case _ => finalize(tree, untpd.Quote(quoted)(tree.source))
     }
     def Splice(tree: Tree)(expr: Tree)(implicit ctx: Context): Tree = tree match {
       case tree: Splice if expr eq tree.expr => tree

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

@@ -104,4 +104,7 @@ object Mode {
 
   /** Are we trying to find a hidden implicit? */
   val FindHiddenImplicits: Mode = newMode(24, "FindHiddenImplicits")
+
+  /** Are we in a quote in a pattern? */
+  val QuotedPattern: Mode = newMode(25, "QuotedPattern")
 }

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

@@ -1930,17 +1930,51 @@ class Typer extends Namer
    *  while tracking the quotation level in the context.
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
-    tree.t match {
+    tree.quoted match {
       case untpd.Splice(innerExpr) =>
         ctx.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.sourcePos)
         typed(innerExpr, pt)
-      case t if t.isType =>
-        typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuoteR), List(tree.t)), pt)(quoteContext).withSpan(tree.span)
-      case t=>
-        typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), tree.t), pt)(quoteContext).withSpan(tree.span)
+      case quoted if quoted.isType =>
+        typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuoteR), quoted :: Nil), pt)(quoteContext).withSpan(tree.span)
+      case quoted =>
+        if (ctx.mode.is(Mode.Pattern)) {
+          val exprPt = pt.baseType(defn.QuotedExprClass)
+          val quotedPt = if (exprPt.exists) exprPt.argTypesHi.head else defn.AnyType
+          val quoted1 = typedExpr(quoted, quotedPt)(quoteContext.addMode(Mode.QuotedPattern))
+          val (shape, splices) = splitQuotePattern(quoted1)
+          val splicePat = typed(untpd.Tuple(splices.map(untpd.TypedSplice(_))).withSpan(quoted.span))
+          val patType = TypeOps.tupleOf(splices.tpes)
+          UnApply(
+            ref(defn.QuotedMatcher_unapplyR).appliedToType(patType),
+            ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) :: givenReflection :: Nil,
+            splicePat :: Nil,
+            pt)
+        }
+        else
+          typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), quoted), pt)(quoteContext).withSpan(tree.span)
+    }
+  }
+
+  def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
+    object splitter extends tpd.TreeMap {
+      val patBuf = new mutable.ListBuffer[Tree]
+      override def transform(tree: Tree)(implicit ctx: Context) = tree match {
+        case Typed(Splice(pat), tpt) =>
+          val exprTpt = ref(defn.QuotedExprType).appliedToTypeTrees(tpt :: Nil)
+          transform(Splice(Typed(pat, exprTpt)))
+        case Splice(pat) =>
+          try tasty.TreePickler.Hole(patBuf.length, Nil)
+          finally patBuf += pat
+        case _ =>
+          super.transform(tree)
+      }
     }
+    val result = splitter.transform(quoted)
+    (result, splitter.patBuf.toList)
   }
 
+  def givenReflection(implicit ctx: Context): Tree = Literal(Constant(null)) // FIXME: fill in
+
   /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
   def typedSplice(tree: untpd.Splice, pt: Type)(implicit ctx: Context): Tree = track("typedSplice") {
     checkSpliceOutsideQuote(tree)
@@ -1949,7 +1983,14 @@ class Typer extends Namer
         ctx.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.sourcePos)
         typed(innerExpr, pt)
       case expr =>
-        typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext).withSpan(tree.span)
+        if (ctx.mode.is(Mode.QuotedPattern)) {
+          fullyDefinedType(pt, "quoted pattern selector", tree.span)
+          val pat = typedPattern(expr, defn.QuotedExprType.appliedTo(pt))(
+            spliceContext.retractMode(Mode.QuotedPattern))
+          Splice(pat)
+        }
+        else
+          typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext).withSpan(tree.span)
     }
   }
 

library/src/scala/runtime/quoted/Matcher.scala

@@ -0,0 +1,10 @@
+package scala.runtime.quoted
+
+import scala.quoted.Expr
+import scala.tasty.Reflection
+
+/** THIS IS A PLACEHOLDER
+ */
+object Matcher {
+  def unapply[Tup <: Tuple](scrut: Expr[_])(implicit pattern: Expr[_], reflection: Reflection): Option[Tup] = ???
+}

tests/pos/quotedPatterns.scala

@@ -0,0 +1,9 @@
+object Test {
+
+  val x = '{1 + 2}
+
+  x match {
+    case '{1 + 2} =>
+    case _ =>
+  }
+}