wip

Author: nicolasstucki

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

@@ -34,6 +34,10 @@ object Matcher {
     import reflection._
     // 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.
      *
@@ -52,9 +56,6 @@ object Matcher {
         sFlags.is(Lazy) == pFlags.is(Lazy) && sFlags.is(Mutable) == pFlags.is(Mutable)
       }
 
-      def bindingMatch(sym: Symbol) =
-        Some(Tuple1(new Binding(sym.name, sym)))
-
       def hasBindingTypeAnnotation(tpt: TypeTree): Boolean = tpt match {
         case Annotated(tpt2, Apply(Select(New(TypeIdent("patternBindHole")), "<init>"), Nil)) => true
         case Annotated(tpt2, _) => hasBindingTypeAnnotation(tpt2)
@@ -148,7 +149,7 @@ object Matcher {
 
         case (ValDef(_, tpt1, rhs1), ValDef(_, tpt2, rhs2)) if checkValFlags() =>
           val bindMatch =
-            if (hasBindingAnnotation(pattern.symbol) || hasBindingTypeAnnotation(tpt2)) bindingMatch(scrutinee.symbol)
+            if (hasBindingAnnotation(pattern.symbol) || hasBindingTypeAnnotation(tpt2)) bindingMatched(scrutinee.symbol)
             else Some(())
           val returnTptMatch = treeMatches(tpt1, tpt2)
           val rhsEnv = env + (scrutinee.symbol -> pattern.symbol)
@@ -161,7 +162,7 @@ object Matcher {
             if (paramss1.size != paramss2.size) None
             else foldMatchings(paramss1.zip(paramss2).map { (params1, params2) => treesMatch(params1, params2) }: _*)
           val bindMatch =
-            if (hasBindingAnnotation(pattern.symbol)) bindingMatch(scrutinee.symbol)
+            if (hasBindingAnnotation(pattern.symbol)) bindingMatched(scrutinee.symbol)
             else Some(())
           val tptMatch = treeMatches(tpt1, tpt2)
           val rhsEnv =
@@ -244,13 +245,24 @@ 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))
 
+
       case (Pattern.Bind(name1, body1), Pattern.Bind(name2, body2)) =>
         val bindEnv = env + (scrutinee.symbol -> pattern.symbol)
         patternMatches(body1, body2)(bindEnv)

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] })