Add quoted pattern type splices runtime

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -39,6 +39,15 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Context_withoutColors(self: Context): Context = ctx.fresh.setSetting(ctx.settings.color, "never")
 
+  def Context_GADT_setFreshGADTBounds(self: Context): Context =
+    self.fresh.setFreshGADTBounds.addMode(Mode.GADTflexible)
+
+  def Context_GADT_addToConstraint(self: Context)(syms: List[Symbol]): Boolean =
+    self.gadt.addToConstraint(syms)
+
+  def Context_GADT_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type =
+    self.gadt.approximation(sym, fromBelow)
+
   //
   // REPORTING
   //

library/src-3.x/scala/internal/Quoted.scala

@@ -24,4 +24,6 @@ object Quoted {
   /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
   class patternBindHole extends Annotation
 
+  class patternType extends Annotation
+
 }

library/src-3.x/scala/internal/quoted/Matcher.scala

@@ -47,7 +47,7 @@ object Matcher {
     }
 
     /** Check that all trees match with =#= and concatenate the results with && */
-    def (scrutinees: List[Tree]) =##= (patterns: List[Tree]) given Env: Matching =
+    def (scrutinees: List[Tree]) =##= (patterns: List[Tree]) given Context, Env: Matching =
       matchLists(scrutinees, patterns)(_ =#= _)
 
     /** Check that the trees match and return the contents from the pattern holes.
@@ -58,7 +58,17 @@ object Matcher {
      * @param `the[Env]` Set of tuples containing pairs of symbols (s, p) where s defines a symbol in `scrutinee` which corresponds to symbol p in `pattern`.
      * @return `None` if it did not match or `Some(tup: Tuple)` if it matched where `tup` contains the contents of the holes.
      */
-    def (scrutinee: Tree) =#= (pattern: Tree) given Env: Matching = {
+    def (scrutinee0: Tree) =#= (pattern0: Tree) given Context, Env: Matching = {
+
+      /** Normalieze the tree */
+      def normalize(tree: Tree): Tree = tree match {
+        case Block(Nil, expr) => normalize(expr)
+        case Inlined(_, Nil, expr) => normalize(expr)
+        case _ => tree
+      }
+
+      val scrutinee = normalize(scrutinee0)
+      val pattern = normalize(pattern0)
 
       /** Check that both are `val` or both are `lazy val` or both are `var` **/
       def checkValFlags(): Boolean = {
@@ -80,14 +90,7 @@ object Matcher {
       def hasBindAnnotation(sym: Symbol) =
         sym.annots.exists { case Apply(Select(New(TypeIdent("patternBindHole")),"<init>"),List()) => true; case _ => true }
 
-      /** Normalieze the tree */
-      def normalize(tree: Tree): Tree = tree match {
-        case Block(Nil, expr) => normalize(expr)
-        case Inlined(_, Nil, expr) => normalize(expr)
-        case _ => tree
-      }
-
-      (normalize(scrutinee), normalize(pattern)) match {
+      (scrutinee, pattern) match {
 
         // Match a scala.internal.Quoted.patternHole typed as a repeated argument and return the scrutinee tree
         case (IsTerm(scrutinee @ Typed(s, tpt1)), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
@@ -112,6 +115,9 @@ object Matcher {
         case (Typed(expr1, tpt1), Typed(expr2, tpt2)) =>
           expr1 =#= expr2 && tpt1 =#= tpt2
 
+        case (scrutinee, Typed(expr2, _)) =>
+          scrutinee =#= expr2
+
         case (Ident(_), Ident(_)) if scrutinee.symbol == pattern.symbol || the[Env].apply((scrutinee.symbol, pattern.symbol)) =>
           matched
 
@@ -144,9 +150,6 @@ object Matcher {
         case (While(cond1, body1), While(cond2, body2)) =>
           cond1 =#= cond2 && body1 =#= body2
 
-        case (NamedArg(name1, expr1), NamedArg(name2, expr2)) if name1 == name2 =>
-          expr1 =#= expr2
-
         case (New(tpt1), New(tpt2)) =>
           tpt1 =#= tpt2
 
@@ -159,10 +162,11 @@ object Matcher {
         case (Repeated(elems1, _), Repeated(elems2, _)) if elems1.size == elems2.size =>
           elems1 =##= elems2
 
+        // TODO is this case required
         case (IsTypeTree(scrutinee @ TypeIdent(_)), IsTypeTree(pattern @ TypeIdent(_))) if scrutinee.symbol == pattern.symbol =>
           matched
 
-        case (IsInferred(scrutinee), IsInferred(pattern)) if scrutinee.tpe <:< pattern.tpe =>
+        case (IsTypeTree(scrutinee), IsTypeTree(pattern)) if scrutinee.tpe <:< pattern.tpe =>
           matched
 
         case (Applied(tycon1, args1), Applied(tycon2, args2)) =>
@@ -173,7 +177,7 @@ object Matcher {
             if (hasBindAnnotation(pattern.symbol) || hasBindTypeAnnotation(tpt2)) bindingMatch(scrutinee.symbol)
             else matched
           def rhsEnv = the[Env] + (scrutinee.symbol -> pattern.symbol)
-          bindMatch && tpt1 =#= tpt2 && (treeOptMatches(rhs1, rhs2) given rhsEnv)
+          bindMatch && tpt1 =#= tpt2 && (treeOptMatches(rhs1, rhs2) given (the[Context], rhsEnv))
 
         case (DefDef(_, typeParams1, paramss1, tpt1, Some(rhs1)), DefDef(_, typeParams2, paramss2, tpt2, Some(rhs2))) =>
           val bindMatch =
@@ -229,15 +233,15 @@ object Matcher {
       }
     }
 
-    def treeOptMatches(scrutinee: Option[Tree], pattern: Option[Tree]) given Env: Matching = {
+    def treeOptMatches(scrutinee: Option[Tree], pattern: Option[Tree]) given Context, Env: Matching = {
       (scrutinee, pattern) match {
         case (Some(x), Some(y)) => x =#= y
         case (None, None) => matched
         case _ => notMatched
       }
     }
 
-    def caseMatches(scrutinee: CaseDef, pattern: CaseDef) given Env: Matching = {
+    def caseMatches(scrutinee: CaseDef, pattern: CaseDef) given Context, Env: Matching = {
       val (caseEnv, patternMatch) = scrutinee.pattern =%= pattern.pattern
       withEnv(caseEnv) {
         patternMatch &&
@@ -256,7 +260,7 @@ object Matcher {
      * @return The new environment containing the bindings defined in this pattern tuppled with
      *         `None` if it did not match or `Some(tup: Tuple)` if it matched where `tup` contains the contents of the holes.
      */
-    def (scrutinee: Pattern) =%= (pattern: Pattern) given Env: (Env, Matching) = (scrutinee, pattern) match {
+    def (scrutinee: Pattern) =%= (pattern: Pattern) given Context, Env: (Env, Matching) = (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$" =>
         (the[Env], matched(v1.seal))
@@ -266,7 +270,7 @@ object Matcher {
 
       case (Pattern.Bind(name1, body1), Pattern.Bind(name2, body2)) =>
         val bindEnv = the[Env] + (scrutinee.symbol -> pattern.symbol)
-        (body1 =%= body2) given bindEnv
+        (body1 =%= body2) given (the[Context], bindEnv)
 
       case (Pattern.Unapply(fun1, implicits1, patterns1), Pattern.Unapply(fun2, implicits2, patterns2)) =>
         val (patEnv, patternsMatch) = foldPatterns(patterns1, patterns2)
@@ -302,16 +306,33 @@ object Matcher {
         (the[Env], notMatched)
     }
 
-    def foldPatterns(patterns1: List[Pattern], patterns2: List[Pattern]) given Env: (Env, Matching) = {
+    def foldPatterns(patterns1: List[Pattern], patterns2: List[Pattern]) given Context, Env: (Env, Matching) = {
       if (patterns1.size != patterns2.size) (the[Env], notMatched)
       else patterns1.zip(patterns2).foldLeft((the[Env], matched)) { (acc, x) =>
-        val (env, res) = (x._1 =%= x._2) given acc._1
+        val (env, res) = (x._1 =%= x._2) given (the[Context], acc._1)
         (env, acc._2 && res)
       }
     }
 
+    def isTypeBinding(tree: Tree): Boolean = tree match {
+      case IsTypeDef(tree) =>
+        tree.symbol.annots.exists(_.symbol.owner.fullName == "scala.internal.Quoted$.patternType")
+      case _ => false
+    }
+
     implied for Env = Set.empty
-    (scrutineeExpr.unseal =#= patternExpr.unseal).asOptionOfTuple.asInstanceOf[Option[Tup]]
+    val res = patternExpr.unseal.underlyingArgument match {
+      case Block(typeBindings, pattern) if typeBindings.forall(isTypeBinding) =>
+        implicit val ctx2 = reflection.kernel.Context_GADT_setFreshGADTBounds(rootContext)
+        val bindingSymbols = typeBindings.map(_.symbol(ctx2))
+        reflection.kernel.Context_GADT_addToConstraint(ctx2)(bindingSymbols)
+        val matchings = scrutineeExpr.unseal.underlyingArgument =#= pattern
+        val constainedTypes = bindingSymbols.map(s => reflection.kernel.Context_GADT_approximation(ctx2)(s, true))
+        constainedTypes.foldRight(matchings)((x, acc) => matched(x.seal) && acc)
+      case pattern =>
+        scrutineeExpr.unseal.underlyingArgument =#= pattern
+    }
+    res.asOptionOfTuple.asInstanceOf[Option[Tup]]
   }
 
   /** Result of matching a part of an expression */

library/src/scala/tasty/reflect/Kernel.scala

@@ -149,6 +149,9 @@ trait Kernel {
   /** Returns a new context where printColors is false */
   def Context_withoutColors(self: Context): Context
 
+  def Context_GADT_setFreshGADTBounds(self: Context): Context
+  def Context_GADT_addToConstraint(self: Context)(syms: List[Symbol]): Boolean
+  def Context_GADT_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type
 
   //
   // REPORTING

tests/run-macros/quote-matcher-runtime.check

@@ -16,7 +16,7 @@ Result: Some(List())
 
 Scrutinee: 1
 Pattern: (1: scala.Int)
-Result: None
+Result: Some(List())
 
 Scrutinee: 3
 Pattern: scala.internal.Quoted.patternHole[scala.Int]
@@ -714,3 +714,118 @@ Pattern: try scala.internal.Quoted.patternHole[scala.Int] finally {
 }
 Result: Some(List(Expr(1), Expr(2)))
 
+Scrutinee: scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int])).foreach[scala.Unit](((x: scala.Int) => scala.Predef.println(x)))
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+  scala.internal.Quoted.patternHole[scala.List[scala.Int]].foreach[T](scala.internal.Quoted.patternHole[scala.Function1[scala.Int, T]])
+}
+Result: Some(List(Type(scala.Unit), Expr(scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int]))), Expr(((x: scala.Int) => scala.Predef.println(x)))))
+
+Scrutinee: scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int])).foreach[scala.Unit](((x: scala.Int) => scala.Predef.println(x)))
+Pattern: {
+  @scala.internal.Quoted.patternType type T = scala.Unit
+  scala.internal.Quoted.patternHole[scala.List[scala.Int]].foreach[T](scala.internal.Quoted.patternHole[scala.Function1[scala.Int, T]])
+}
+Result: Some(List(Type(scala.Unit), Expr(scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int]))), Expr(((x: scala.Int) => scala.Predef.println(x)))))
+
+Scrutinee: scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int])).foreach[scala.Unit](((x: scala.Int) => scala.Predef.println(x)))
+Pattern: {
+  @scala.internal.Quoted.patternType type T <: scala.Predef.String
+  scala.internal.Quoted.patternHole[scala.List[scala.Int]].foreach[T](scala.internal.Quoted.patternHole[scala.Function1[scala.Int, T]])
+}
+Result: None
+
+Scrutinee: {
+  val a: scala.Int = 4
+  val b: scala.Int = 4
+  ()
+}
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+  val a: T = scala.internal.Quoted.patternHole[T]
+  val b: T = scala.internal.Quoted.patternHole[T]
+  ()
+}
+Result: Some(List(Type(scala.Int), Expr(4), Expr(4)))
+
+Scrutinee: {
+  val a: scala.Int = 4
+  val b: scala.Int = 5
+  ()
+}
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+  val a: T = scala.internal.Quoted.patternHole[T]
+  val b: T = scala.internal.Quoted.patternHole[T]
+  ()
+}
+Result: Some(List(Type(scala.Int), Expr(4), Expr(5)))
+
+Scrutinee: {
+  val a: scala.Int = 4
+  val b: scala.Predef.String = "x"
+  ()
+}
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+  val a: T = scala.internal.Quoted.patternHole[T]
+  val b: T = scala.internal.Quoted.patternHole[T]
+  ()
+}
+Result: Some(List(Type(scala.Int | java.lang.String), Expr(4), Expr("x")))
+
+Scrutinee: {
+  val a: scala.Int = 4
+  val b: scala.Predef.String = "x"
+  ()
+}
+Pattern: {
+  @scala.internal.Quoted.patternType type T <: scala.Int
+  val a: T = scala.internal.Quoted.patternHole[T]
+  val b: T = scala.internal.Quoted.patternHole[T]
+  ()
+}
+Result: None
+
+Scrutinee: scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int])).map[scala.Double, scala.collection.immutable.List[scala.Double]](((x: scala.Int) => x.toDouble./(2)))(scala.collection.immutable.List.canBuildFrom[scala.Double]).map[java.lang.String, scala.collection.immutable.List[java.lang.String]](((y: scala.Double) => y.toString()))(scala.collection.immutable.List.canBuildFrom[java.lang.String])
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+  @scala.internal.Quoted.patternType type U
+  @scala.internal.Quoted.patternType type V
+
+  (scala.internal.Quoted.patternHole[scala.List[T]].map[U, scala.collection.immutable.List[U]](scala.internal.Quoted.patternHole[scala.Function1[T, U]])(scala.collection.immutable.List.canBuildFrom[U]).map[V, scala.collection.immutable.List[V]](scala.internal.Quoted.patternHole[scala.Function1[U, V]])(scala.collection.immutable.List.canBuildFrom[V]): scala.collection.immutable.List[scala.Any])
+}
+Result: Some(List(Type(scala.Int), Type(scala.Double), Type(java.lang.String), Expr(scala.List.apply[scala.Int]((1, 2, 3: scala.<repeated>[scala.Int]))), Expr(((x: scala.Int) => x.toDouble./(2))), Expr(((y: scala.Double) => y.toString()))))
+
+Scrutinee: ((x: scala.Int) => x)
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+
+  (scala.internal.Quoted.patternHole[scala.Function1[T, T]]: scala.Function1[scala.Nothing, scala.Any])
+}
+Result: Some(List(Type(scala.Int), Expr(((x: scala.Int) => x))))
+
+Scrutinee: ((x: scala.Int) => x.toString())
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+
+  (scala.internal.Quoted.patternHole[scala.Function1[T, T]]: scala.Function1[scala.Nothing, scala.Any])
+}
+Result: None
+
+Scrutinee: ((x: scala.Any) => scala.Predef.???)
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+
+  (scala.internal.Quoted.patternHole[scala.Function1[T, T]]: scala.Function1[scala.Nothing, scala.Any])
+}
+Result: Some(List(Type(scala.Nothing), Expr(((x: scala.Any) => scala.Predef.???))))
+
+Scrutinee: ((x: scala.Nothing) => (1: scala.Any))
+Pattern: {
+  @scala.internal.Quoted.patternType type T
+
+  (scala.internal.Quoted.patternHole[scala.Function1[T, T]]: scala.Function1[scala.Nothing, scala.Any])
+}
+Result: None
+

tests/run-macros/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, patternType}
 
 object Test {
 
@@ -134,6 +134,18 @@ object Test {
     matches(try 1 finally 2, try 1 finally 2)
     matches(try 1 catch { case _ => 2 }, try patternHole[Int] catch { case _ => patternHole[Int] })
     matches(try 1 finally 2, try patternHole[Int] finally patternHole[Int])
+    matches(List(1, 2, 3).foreach(x => println(x)), { @patternType type T; patternHole[List[Int]].foreach[T](patternHole[Int => T]) })
+    matches(List(1, 2, 3).foreach(x => println(x)), { @patternType type T = Unit; patternHole[List[Int]].foreach[T](patternHole[Int => T]) })
+    matches(List(1, 2, 3).foreach(x => println(x)), { @patternType type T <: String; patternHole[List[Int]].foreach[T](patternHole[Int => T]) })
+    matches({ val a: Int = 4; val b: Int = 4 }, { @patternType type T; { val a: T = patternHole[T]; val b: T = patternHole[T] } })
+    matches({ val a: Int = 4; val b: Int = 5 }, { @patternType type T; { val a: T = patternHole[T]; val b: T = patternHole[T] } })
+    matches({ val a: Int = 4; val b: String = "x" }, { @patternType type T; { val a: T = patternHole[T]; val b: T = patternHole[T] } })
+    matches({ val a: Int = 4; val b: String = "x" }, { @patternType type T <: Int; { val a: T = patternHole[T]; val b: T = patternHole[T] } })
+    matches(List(1, 2, 3).map(x => x.toDouble / 2).map(y => y.toString), { @patternType type T; @patternType type U; @patternType type V; patternHole[List[T]].map(patternHole[T => U]).map(patternHole[U => V]) })
+    matches((x: Int) => x, { @patternType type T; patternHole[T => T] })
+    matches((x: Int) => x.toString, { @patternType type T; patternHole[T => T] })
+    matches((x: Any) => ???, { @patternType type T; patternHole[T => T] })
+    matches((x: Nothing) => (1 : Any), { @patternType type T; patternHole[T => T] })
 
   }
 }