wip

Author: nicolasstucki

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

@@ -723,6 +723,10 @@ class Definitions {
     lazy val InternalQuoted_patternHoleR: TermRef = InternalQuotedModule.requiredMethodRef("patternHole")
     def InternalQuoted_patternHole(implicit ctx: Context): Symbol = InternalQuoted_patternHoleR.symbol
     lazy val InternalQuoted_patternBindHoleAnnot: ClassSymbol = InternalQuotedModule.requiredClass("patternBindHole")
+    lazy val InternalQuoted_patternMatchBindHoleModuleR: TermRef = InternalQuotedModule.requiredValueRef("patternMatchBindHole".toTermName)
+    def InternalQuoted_patternMatchBindHoleModule: Symbol = InternalQuoted_patternMatchBindHoleModuleR.symbol
+      lazy val InternalQuoted_patternMatchBindHole_unapplyR: TermRef = InternalQuoted_patternMatchBindHoleModule.requiredMethodRef("unapply")
+      def InternalQuoted_patternMatchBindHole_unapply(implicit ctx: Context): Symbol = InternalQuoted_patternMatchBindHole_unapplyR.symbol
 
   lazy val InternalQuotedMatcherModuleRef: TermRef = ctx.requiredModuleRef("scala.internal.quoted.Matcher")
     def InternalQuotedMatcherModule(implicit ctx: Context): Symbol = InternalQuotedMatcherModuleRef.symbol

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

@@ -1013,7 +1013,17 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       tree
   }
 
-  def typedUnApply(tree: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = track("typedUnApply") {
+  def typedUnApply(tree0: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = track("typedUnApply") {
+    val tree =
+      if (ctx.mode.is(Mode.QuotedPattern)) { // TODO move to desugar
+      val Apply(qual0, args0) = tree0
+      val args1 = args0 map {
+        case arg: untpd.Ident if arg.name.startsWith("$") =>
+          untpd.Apply(untpd.ref(defn.InternalQuoted_patternMatchBindHoleModuleR), untpd.Ident(arg.name.toString.substring(1).toTermName) :: Nil)
+        case arg => arg
+      }
+      untpd.cpy.Apply(tree0)(qual0, args1)
+    } else tree0
     val Apply(qual, args) = tree
 
     def notAnExtractor(tree: Tree) =

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

@@ -1958,6 +1958,13 @@ class Typer extends Namer
 
   def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
     val ctx0 = ctx
+
+    def bindExpr(name: Name, tpe: Type, span: Span): Tree = {
+      val exprTpe = AppliedType(defn.QuotedMatchingBindingType, tpe :: Nil)
+      val sym = ctx0.newPatternBoundSymbol(name, exprTpe, span)
+      Bind(sym, untpd.Ident(nme.WILDCARD).withType(exprTpe)).withSpan(span)
+    }
+
     object splitter extends tpd.TreeMap {
       val patBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
@@ -1967,18 +1974,27 @@ class Typer extends Namer
         case Splice(pat) =>
           try patternHole(tree)
           finally patBuf += pat
-        case vdef: ValDef =>
-          if (vdef.symbol.annotations.exists(_.symbol == defn.InternalQuoted_patternBindHoleAnnot)) {
-            val tpe = AppliedType(defn.QuotedMatchingBindingType, vdef.tpt.tpe :: Nil)
-            val sym = ctx0.newPatternBoundSymbol(vdef.name, tpe, vdef.span)
-            patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(tpe)).withSpan(vdef.span)
-          }
+        case tree @ UnApply(_, _, (bind: Bind) :: Nil) if tree.fun.symbol == defn.InternalQuoted_patternMatchBindHole_unapply =>
+          patBuf += bindExpr(bind.name, bind.tpe.widen, bind.span)
+          super.transform(tree)
+        case vdef: ValDef if vdef.symbol.annotations.exists(_.symbol == defn.InternalQuoted_patternBindHoleAnnot) =>
+          patBuf += bindExpr(vdef.name, vdef.tpt.tpe, vdef.span)
           super.transform(tree)
         case _ =>
           super.transform(tree)
       }
     }
+
     val result = splitter.transform(quoted)
+    println()
+    println(quoted.show)
+    println()
+    println(result.show)
+    println()
+    println(splitter.patBuf.toList)
+    println()
+    println()
+    println()
     (result, splitter.patBuf.toList)
   }
 

tests/pos/quotedPatterns.scala

@@ -6,18 +6,19 @@ object Test {
   def g(x: Int, y: Int) = x * y
 
   def res given tasty.Reflection: quoted.Expr[Int] = x match {
-    case '{1 + 2} => '{0}
-    case '{f($y)} => y
-    case '{g($y, $z)} => '{$y * $z}
-    case '{ ((a: Int) => 3)($y) } => y
-    case '{ 1 + ($y: Int)} => y
-    case '{ val a = 1 + ($y: Int); 3 } => y
-      // currently gives an unreachable case warning
-      // but only when used in conjunction with the others.
-      // I believe this is because implicit arguments are not taken
-      // into account when checking whether we have already seen an `unapply` before.
-    case '{ val $y: Int = $z; 1 } => z
-    case '{ ((`$y`: Int) => 1 + y + ($z: Int))(2) } => z
+//    case '{1 + 2} => '{0}
+//    case '{f($y)} => y
+//    case '{g($y, $z)} => '{$y * $z}
+//    case '{ ((a: Int) => 3)($y) } => y
+//    case '{ 1 + ($y: Int)} => y
+//    case '{ val a = 1 + ($y: Int); 3 } => y
+//      // currently gives an unreachable case warning
+//      // but only when used in conjunction with the others.
+//      // I believe this is because implicit arguments are not taken
+//      // into account when checking whether we have already seen an `unapply` before.
+//    case '{ val $y: Int = $z; 1 } => z
+//    case '{ ((`$y`: Int) => 1 + y + ($z: Int))(2) } => z
+    case '{ Option(1) match { case Some($n) => $z } } => z
     // TODO support syntax
     // case '{ (($y: Int) => 1 + y + ($z: Int))(2) } => z
     case _ => '{1}