wip

Author: nicolasstucki

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

@@ -1413,6 +1413,10 @@ class Typer extends Namer
   }
 
   def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Tree = track("typedBind") {
+    if (ctx.mode.is(Mode.QuotedPattern) && tree.name.startsWith("$")) {
+      val bind1 = untpd.cpy.Bind(tree)(tree.name.toString.substring(1).toTermName, tree.body)
+      return typed(untpd.Apply(untpd.ref(defn.InternalQuoted_patternMatchBindHoleModuleR), bind1 :: Nil).withSpan(tree.span), pt)
+    }
     val pt1 = fullyDefinedType(pt, "pattern variable", tree.span)
     val body1 = typed(tree.body, pt1)
     body1 match {
@@ -1976,7 +1980,7 @@ class Typer extends Namer
           finally patBuf += pat
         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)
+          cpy.UnApply(tree)(patterns = untpd.Ident(nme.WILDCARD).withType(bind.tpe.widen) :: Nil)
         case vdef: ValDef if vdef.symbol.annotations.exists(_.symbol == defn.InternalQuoted_patternBindHoleAnnot) =>
           patBuf += bindExpr(vdef.name, vdef.tpt.tpe, vdef.span)
           super.transform(tree)
@@ -1986,15 +1990,6 @@ class Typer extends Namer
     }
 
     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,22 +6,25 @@ 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
-    // TODO do NOT support syntax this syntax
-    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
+//    // TODO do NOT support syntax this syntax
+//    case '{ ((`$y`: Int) => 1 + y + ($z: Int))(2) } => z
     // TODO support syntax this syntax
     // case '{ (($y: Int) => 1 + y + ($z: Int))(2) } => z
-    case '{ Option(1) match { case Some($n) => $z } } => z
+//    case '{ Option(1) match { case Some($n) => $z } } => z
+    case '{ Option(1) match { case $a @ Some($n) => $z } } => z
+    case '{ Option(1) match { case $b: Some[_] => $z } } => z
+    case '{ Option(1) match { case $c => $z } } => z
     case _ => '{1}
   }
 }