Split treeMatch into exprMatch and typeMatch

Author: nicolasstucki

compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala

@@ -124,63 +124,76 @@ object QuoteMatcher {
 
   private def withEnv[T](env: Env)(body: Env ?=> T): T = body(using env)
 
-  /** Evaluate the the result of pattern matching against a quote pattern.
-   *  Implementation of the runtime of `QuoteMatching.{ExprMatch,TypeMatch}.unapply`.
+  /** Evaluate the result of pattern matching against a quote pattern.
+   *  Implementation of the runtime of `QuoteMatching.ExprMatch.unapply`.
    */
-  def treeMatch(scrutinee: Tree, pattern: Tree)(using Context): Option[Tuple] = {
-    def isTypeHoleDef(tree: Tree): Boolean =
-      tree match
-        case tree: TypeDef =>
-          tree.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot)
-        case _ => false
-
-    def extractTypeHoles(pat: Tree): (Tree, List[Symbol]) =
-      pat match
-        case tpd.Inlined(_, Nil, pat2) => extractTypeHoles(pat2)
-        case tpd.Block(stats @ ((typeHole: TypeDef) :: _), expr) if isTypeHoleDef(typeHole) =>
-          val holes = stats.takeWhile(isTypeHoleDef).map(_.symbol)
-          val otherStats = stats.dropWhile(isTypeHoleDef)
-          (tpd.cpy.Block(pat)(otherStats, expr), holes)
-        case _ =>
-          (pat, Nil)
-
-    val (pat1, typeHoles) = extractTypeHoles(pattern)
+  def exprMatch(scrutinee: Tree, pattern: Tree)(using Context): Option[Tuple] = {
+    val (pat1, typeHoles, ctx1) = instrumentTypeHoles(pattern)
+    inContext(ctx1) {
+      optional {
+        given Env = Map.empty
+        scrutinee =?= pat1
+      }.map { matchings =>
+        import QuoteMatcher.MatchResult.*
+        lazy val spliceScope = SpliceScope.getCurrent
+        // After matching and doing all subtype checks, we have to approximate all the type bindings
+        // that we have found, seal them in a quoted.Type and add them to the result
+        val typeHoleApproximations = typeHoles.map(typeHoleApproximation)
+        val typeHoleMapping = Map(typeHoles.zip(typeHoleApproximations)*)
+        val typeHoleMap = new TypeMap {
+          def apply(tp: Type): Type = tp match
+            case TypeRef(NoPrefix, _) => typeHoleMapping.getOrElse(tp.typeSymbol, tp)
+            case _ => mapOver(tp)
+        }
+        val matchedExprs = matchings.map(_.toExpr(typeHoleMap, spliceScope))
+        val matchedTypes = typeHoleApproximations.map(tpe => new TypeImpl(TypeTree(tpe), spliceScope))
+        val results = matchedTypes ++ matchedExprs
+        Tuple.fromIArray(IArray.unsafeFromArray(results.toArray))
+      }
+    }
+  }
 
-    val ctx1 =
-      if typeHoles.isEmpty then ctx
-      else
-        val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(GadtConstraintInference)
-        ctx1.gadtState.addToConstraint(typeHoles)
-        ctx1
-
-    // After matching and doing all subtype checks, we have to approximate all the type bindings
-    // that we have found, seal them in a quoted.Type and add them to the result
-    def typeHoleApproximation(sym: Symbol) =
-      val fromAboveAnnot = sym.hasAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot)
-      val fullBounds = ctx1.gadt.fullBounds(sym)
-      if fromAboveAnnot then fullBounds.nn.hi else fullBounds.nn.lo
-
-    optional {
-      given Context = ctx1
-      given Env = Map.empty
-      scrutinee =?= pat1
-    }.map { matchings =>
-      import QuoteMatcher.MatchResult.*
-      lazy val spliceScope = SpliceScope.getCurrent
-      val typeHoleApproximations = typeHoles.map(typeHoleApproximation)
-      val typeHoleMapping = Map(typeHoles.zip(typeHoleApproximations)*)
-      val typeHoleMap = new TypeMap {
-        def apply(tp: Type): Type = tp match
-          case TypeRef(NoPrefix, _) => typeHoleMapping.getOrElse(tp.typeSymbol, tp)
-          case _ => mapOver(tp)
+  /** Evaluate the the result of pattern matching against a quote pattern.
+   *  Implementation of the runtime of `QuoteMatching.TypeMatch.unapply`.
+   */
+  def typeMatch(scrutinee: Tree, pattern: Tree)(using Context): Option[Tuple] = {
+    val (pat1, typeHoles, ctx1) = instrumentTypeHoles(pattern)
+    inContext(ctx1) {
+      optional {
+        given Env = Map.empty
+        scrutinee =?= pat1
+      }.map { matchings =>
+        assert(matchings.isEmpty)
+        lazy val spliceScope = SpliceScope.getCurrent
+        val matchedTypes = typeHoles.map(tpe => new TypeImpl(TypeTree(typeHoleApproximation(tpe)), spliceScope))
+        Tuple.fromIArray(IArray.unsafeFromArray(matchedTypes.toArray))
       }
-      val matchedExprs = matchings.map(_.toExpr(typeHoleMap, spliceScope))
-      val matchedTypes = typeHoleApproximations.map(tpe => new TypeImpl(TypeTree(tpe), spliceScope))
-      val results = matchedTypes ++ matchedExprs
-      Tuple.fromIArray(IArray.unsafeFromArray(results.toArray))
     }
   }
 
+  def instrumentTypeHoles(pat: Tree)(using Context): (Tree, List[Symbol], Context) =
+    def isTypeHoleDef(tree: Tree): Boolean = tree match
+      case tree: TypeDef => tree.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot)
+      case _ => false
+    pat match
+      case tpd.Inlined(_, Nil, pat2) => instrumentTypeHoles(pat2)
+      case tpd.Block(stats @ ((typeHole: TypeDef) :: _), expr) if isTypeHoleDef(typeHole) =>
+        val (holeDefs, otherStats) = stats.span(isTypeHoleDef)
+        val holeSyms = holeDefs.map(_.symbol)
+        val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(GadtConstraintInference)
+        ctx1.gadtState.addToConstraint(holeSyms)
+        (tpd.cpy.Block(pat)(otherStats, expr), holeSyms, ctx1)
+      case _ =>
+        (pat, Nil, ctx)
+
+  /** Type approximation of a quote pattern type variable.
+   *  Should only be approximated after matching the tree.
+   */
+  def typeHoleApproximation(sym: Symbol)(using Context): Type =
+    val fromAboveAnnot = sym.hasAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot)
+    val fullBounds = ctx.gadt.fullBounds(sym)
+    if fromAboveAnnot then fullBounds.nn.hi else fullBounds.nn.lo
+
   /** Check that all trees match with `mtch` and concatenate the results with &&& */
   private def matchLists[T](l1: List[T], l2: List[T])(mtch: (T, T) => MatchingExprs): optional[MatchingExprs] = (l1, l2) match {
     case (x :: xs, y :: ys) => mtch(x, y) &&& matchLists(xs, ys)(mtch)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -46,7 +46,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       reflect.Printer.TreeCode.show(reflect.asTerm(self))
 
     def matches(that: scala.quoted.Expr[Any]): Boolean =
-      QuoteMatcher.treeMatch(reflect.asTerm(self), reflect.asTerm(that)).nonEmpty
+      QuoteMatcher.exprMatch(reflect.asTerm(self), reflect.asTerm(that)).nonEmpty
 
     def valueOrAbort(using fromExpr: FromExpr[T]): T =
       def reportError =
@@ -3110,14 +3110,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     def unapply[TypeBindings, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =
       val scrutineeTree = reflect.asTerm(scrutinee)
       val patternTree = reflect.asTerm(pattern)
-      QuoteMatcher.treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
+      QuoteMatcher.exprMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
   end ExprMatch
 
   object TypeMatch extends TypeMatchModule:
     def unapply[TypeBindings, Tup <: Tuple](scrutinee: scala.quoted.Type[?])(using pattern: scala.quoted.Type[?]): Option[Tup] =
       val scrutineeTree = reflect.TypeTree.of(using scrutinee)
       val patternTree = reflect.TypeTree.of(using pattern)
-      QuoteMatcher.treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
+      QuoteMatcher.typeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
   end TypeMatch
 
 end QuotesImpl