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

@@ -1416,6 +1416,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 {
@@ -1960,6 +1964,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 {
@@ -1990,6 +2001,9 @@ class Typer extends Namer
             patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(exprTpe)).withSpan(ddef.span)
           }
           super.transform(tree)
+        case tree @ UnApply(_, _, (bind: Bind) :: Nil) if tree.fun.symbol == defn.InternalQuoted_patternMatchBindHole_unapply =>
+          patBuf += bindExpr(bind.name, bind.tpe.widen, bind.span)
+          cpy.UnApply(tree)(patterns = untpd.Ident(nme.WILDCARD).withType(bind.tpe.widen) :: Nil)
         case _ =>
           super.transform(tree)
       }

library/src-bootstrapped/scala/internal/Quoted.scala

@@ -21,7 +21,13 @@ object Quoted {
   def patternHole[T]: T =
     throw new Error("Internal error: this method call should have been replaced by the compiler")
 
-  /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
+  /** A splice of a name in a quoted pattern is desugared by adding this annotation */
   class patternBindHole extends Annotation
 
+  /** A splice of a name in a quoted pattern in pattern position is desugared by wrapping it in this extractor */
+  object patternMatchBindHole {
+    def unapply(x: Any): Some[x.type] =
+      throw new Error("Internal error: this method call should have been replaced by the compiler")
+  }
+
 }

library/src-bootstrapped/scala/internal/quoted/Matcher.scala

@@ -35,6 +35,10 @@ object Matcher {
 
     // TODO improve performance
 
+    /** Create a new matching with the resulting binding for the symbol */
+    def bindingMatched(sym: Symbol) =
+      Some(Tuple1(new Binding(sym.name, sym)))
+
     /** Check that the trees match and return the contents from the pattern holes.
      *  Return None if the trees do not match otherwise return Some of a tuple containing all the contents in the holes.
      *
@@ -253,9 +257,19 @@ object Matcher {
      *         `None` if it did not match or `Some(tup: Tuple)` if it matched where `tup` contains the contents of the holes.
      */
     def patternMatches(scrutinee: Pattern, pattern: Pattern)(implicit env: Set[(Symbol, Symbol)]): (Set[(Symbol, Symbol)], Option[Tuple]) = (scrutinee, pattern) match {
-      case (Pattern.Value(v1), Pattern.Unapply(TypeApply(Select(patternHole @ Ident("patternHole"), "unapply"), List(tpt)), Nil, Nil))
-          if patternHole.symbol.owner.fullName == "scala.runtime.quoted.Matcher$" =>
-        (env, Some(Tuple1(v1.seal)))
+//      case (Pattern.Value(v1), Pattern.Unapply(TypeApply(Select(patternHole @ Ident("patternHole"), "unapply"), List(tpt)), Nil, Nil))
+//          if patternHole.symbol.owner.fullName == "scala.runtime.quoted.Matcher$" =>
+//        (env, Some(Tuple1(v1.seal)))
+
+      case (Pattern.Bind(name1, pat1), Pattern.Unapply(Select(Ident("patternMatchBindHole"), "unapply"), Nil, List(Pattern.Bind(name2, pat2))))
+// TODO            if pattern.symbol == ... =>
+          =>
+        val (env1, patMatch) = patternMatches(pat1, pat2)
+        (env1, foldMatchings(bindingMatched(scrutinee.symbol), patMatch))
+
+      case (Pattern.Value(Ident("_")), Pattern.Value(Ident("_"))) => // TODO add Wildcard to patterns
+        val bindEnv = env + (scrutinee.symbol -> pattern.symbol)
+        (bindEnv, Some(()))
 
       case (Pattern.Value(v1), Pattern.Value(v2)) =>
         (env, treeMatches(v1, v2))

tests/pos/quotedPatterns.scala

@@ -34,6 +34,10 @@ object Test {
     case '{ def $ff[T](i: T): Int = $z; 2 } =>
       val a: quoted.matching.Bind[[T] => T => Int] = ff
       z
+    case '{ Option(1) match { case $a @ Some(_) => $z } } => z
+    case '{ Option(1) match { case $b: Some[_] => $z } } => z
+    //    case '{ Option(1) match { case Some($n @ _) => $z } } => z
+//    case '{ Option(1) match { case $c => $z } } => z
     case _ => '{1}
   }
 }

tests/run-with-compiler/quote-matcher-runtime.check

@@ -622,6 +622,26 @@ Pattern: scala.Predef.??? match {
 }
 Result: Some(List())
 
+Scrutinee: scala.Predef.??? match {
+  case scala.Some(n) =>
+    2
+}
+Pattern: scala.Predef.??? match {
+  case scala.Some(scala.internal.Quoted.patternMatchBindHole(n)) =>
+    2
+}
+Result: Some(List(Binding(n)))
+
+Scrutinee: scala.Predef.??? match {
+  case scala.Some(n @ scala.Some(m)) =>
+    2
+}
+Pattern: scala.Predef.??? match {
+  case scala.Some(scala.internal.Quoted.patternMatchBindHole(n @ scala.Some(scala.internal.Quoted.patternMatchBindHole(m)))) =>
+    2
+}
+Result: Some(List(Binding(n), Binding(m)))
+
 Scrutinee: try 1 catch {
   case _ =>
     2

tests/run-with-compiler/quote-matcher-runtime/quoted_2.scala

@@ -3,7 +3,7 @@ import Macros._
 
 import scala.internal.quoted.Matcher._
 
-import scala.internal.Quoted.{patternHole, patternBindHole}
+import scala.internal.Quoted.{patternHole, patternBindHole, patternMatchBindHole}
 
 object Test {
 
@@ -123,8 +123,8 @@ object Test {
     matches(??? match { case None => 2 }, ??? match { case None => 2 })
     matches(??? match { case Some(1) => 2 }, ??? match { case Some(1) => 2 })
     // matches(??? match { case Some(1) => 2 }, ??? match { case Some(patternMatchHole()) => 2 })
-    // matches(??? match { case Some(n) => 2 }, ??? match { case Some(patternMatchBindHole(n)) => 2 })
-    // matches(??? match { case Some(n @ Some(m)) => 2 }, ??? match { case Some(patterMatchBindHole(n @ Some(patternMatchBindHole(m)))) => 2 })
+    matches(??? match { case Some(n) => 2 }, ??? match { case Some(patternMatchBindHole(n)) => 2 })
+    matches(??? match { case Some(n @ Some(m)) => 2 }, ??? match { case Some(patternMatchBindHole(n @ Some(patternMatchBindHole(m)))) => 2 })
     matches(try 1 catch { case _ => 2 }, try 1 catch { case _ => 2 })
     matches(try 1 finally 2, try 1 finally 2)
     matches(try 1 catch { case _ => 2 }, try patternHole[Int] catch { case _ => patternHole[Int] })