wip

Author: nicolasstucki

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

@@ -8,11 +8,10 @@ import scala.tasty._
 
 object Matcher {
 
-  private final val debug = false
+  private final val debug = true
 
-  // FIXME
-//  /** Pattern representing a quoted.Type splice */
-//  type Hole[T <: AnyKind] = T
+  /** Pattern representing a quoted.Type splice */
+  type Hole[T <: AnyKind] = T
 
   /** Pattern representing a quoted.matching.Binding
    *  The pattern is placed around the type tree of the `val`, `lazy val`, `var` or `def`
@@ -79,13 +78,12 @@ object Matcher {
         case (_, Block(Nil, pat)) => treeMatches(scrutinee, pat)
 
         case (IsTerm(scrutinee), TypeApply(Ident("hole"), tpt :: Nil))
-            if isMatcherHole(pattern.symbol) && scrutinee.tpe <:< tpt.tpe =>
+            if isMatcherHole(pattern.symbol) =>
           Some(Tuple1(scrutinee.seal))
 
-          // FIXME
-//        case (IsTypeTree(scrutinee), IsTypeTree(pattern @ TypeTree.Applied(TypeIdent("Hole"), IsTypeTree(tpt) :: Nil)))
-//            if isMatcherHole(pattern.symbol) && scrutinee.tpe <:< tpt.tpe => // Is the subtype check required?
-//          Some(Tuple1(scrutinee.tpe.seal))
+        case (IsTypeTree(scrutinee), IsTypeTree(pattern @ TypeTree.Applied(TypeIdent("Hole"), IsTypeTree(tpt) :: Nil)))
+            if isMatcherHole(pattern.symbol) => // Is the subtype check required?
+          Some(Tuple1(scrutinee.tpe.seal))
 
         case (Inlined(_, Nil, scr), _) =>
           treeMatches(scr, pattern)
@@ -199,6 +197,9 @@ object Matcher {
           val finalizerMatch = treeOptMatches(finalizer1, finalizer2)
           foldMatchings(bodyMacth, casesMatch, finalizerMatch)
 
+        case (_, Block(stats, expr)) if stats.forall { case IsTypeDef(s) if s.name.toString.startsWith("Binding$") => true; case _ => false } =>
+          treeMatches(scrutinee, expr)
+
         case _ =>
           if (debug)
             println(

tests/run-with-compiler/quote-matcher-type-bind.check

@@ -0,0 +1,2 @@
+g: 5
+f: abc

tests/run-with-compiler/quote-matcher-type-bind/quoted_1.scala

@@ -0,0 +1,52 @@
+
+import scala.quoted._
+import scala.quoted.matching._
+
+import scala.tasty.Reflection
+
+import scala.runtime.quoted.Matcher._
+
+object Macros {
+
+  inline def swapFandG(x: => Unit): Unit = ${impl('x)}
+
+  private def impl(x: Expr[Unit])(implicit reflect: Reflection): Expr[Unit] = {
+
+    type TT // type binding
+    object DSLf extends ExprMatch[Tuple2[Type[TT], Expr[TT]]]('{ type Binding$T1;  DSL.f[Hole[Binding$T1]](hole[Binding$T1]) }) // case '{ DSL.f[$t]($x) } =>
+
+    x match {
+      // case '{ DSL.f[$t]($x) } =>
+      // case scala.runtime.quoted.Matcher.unapply[Tuple2[Type[tt /*type binding*/], Expr[tt]]](Tuple2(t, x)(/*implicits*/ '{ DSL.f[Hole[Nothing, Any]](hole[Any])] }, reflect) if consforms(x, t) =>
+      case DSLf(t, x) =>
+        implicit val tt = t
+        '{ DSL.g[$t]($x) }
+
+      // case '{ DSL.f[$t]($x) } =>
+//      case DSLg(t, x) =>
+//        '{ DSL.f[$t]($x) }
+
+      case _ =>
+        x
+    }
+  }
+
+}
+
+//
+// DSL in which the user write the code
+//
+
+object DSL {
+  def f[T](x: T): Unit = println("f: " + x.toString)
+  def g[T](x: T): Unit = println("g: " + x.toString)
+}
+
+//
+// Helper to abstract call to scala.runtime.quoted.Matcher.unapply and setup an object with the unapply
+//
+
+class ExprMatch[Tup <: Tuple](pattern: Expr[_]) {
+  def unapply(x: Expr[_])(implicit reflect: Reflection): Option[Tup] =
+    scala.runtime.quoted.Matcher.unapply[Tup](x)(pattern, reflect)
+}

tests/run-with-compiler/quote-matcher-type-bind/quoted_2.scala

@@ -0,0 +1,12 @@
+
+import Macros._
+
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    swapFandG(DSL.f(5))
+//    swapFandG(DSL.g("abc"))
+  }
+
+}