Refactor quote matching internal logic

Aimed to simplify the logic exposed by the CompilerInterface

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -2546,20 +2546,62 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     def unpickleType(repr: Unpickler.PickledQuote, args: Unpickler.PickledArgs): TypeTree =
       PickledQuotes.unpickleType(repr, args)
 
-    def Constraints_context[T]: scala.quoted.QuoteContext =
-      val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(dotc.core.Mode.GadtConstraintInference)
-      dotty.tools.dotc.quoted.QuoteContextImpl()(using ctx1)
+    def termMatch(scrutinee: Term, pattern: Term): Option[Tuple] =
+      treeMatch(scrutinee, pattern)
+
+    def typeTreeMatch(scrutinee: TypeTree, pattern: TypeTree): Option[Tuple] =
+      treeMatch(scrutinee, pattern)
+
+    private def treeMatch(scrutinee: Tree, pattern: Tree): Option[Tuple] = {
+      def isTypeHoleDef(tree: Tree): Boolean =
+        tree match
+          case tree: TypeDef =>
+            tree.symbol.hasAnnotation(dotc.core.Symbols.defn.InternalQuotedMatcher_patternTypeAnnot)
+          case _ => false
+
+      def extractTypeHoles(pat: Term): (Term, 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)
 
-    def Constraints_add(syms: List[Symbol]): Boolean =
-      ctx.gadt.addToConstraint(syms)
+      val (pat1, typeHoles) = extractTypeHoles(pattern)
 
-    def Constraints_approximation(sym: Symbol, fromBelow: Boolean): Type =
-      ctx.gadt.approximation(sym, fromBelow)
+      val ctx1 =
+        if typeHoles.isEmpty then ctx
+        else
+          val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(dotc.core.Mode.GadtConstraintInference)
+          ctx1.gadt.addToConstraint(typeHoles)
+          ctx1
+
+      val qctx1 = dotty.tools.dotc.quoted.QuoteContextImpl()(using ctx1)
+        .asInstanceOf[QuoteContext { val tasty: QuoteContextImpl.this.tasty.type }]
+
+      val matcher = new scala.internal.quoted.Matcher.QuoteMatcher[qctx1.type](qctx1)
+
+      val matchings =
+        if pat1.isType then matcher.termMatch(scrutinee, pat1)
+        else matcher.termMatch(scrutinee, pat1)
+
+      // val matchings = matcher.termMatch(scrutinee, pattern)
+      if typeHoles.isEmpty then matchings
+      else {
+        // 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) =
+          ctx1.gadt.approximation(sym, !sym.hasAnnotation(dotc.core.Symbols.defn.InternalQuotedMatcher_fromAboveAnnot)).seal
+        matchings.map { tup =>
+          Tuple.fromIArray(typeHoles.map(typeHoleApproximation).toArray.asInstanceOf[IArray[Object]]) ++ tup
+        }
+      }
+    }
 
     def Definitions_InternalQuotedMatcher_patternHole: Symbol = dotc.core.Symbols.defn.InternalQuotedMatcher_patternHole
     def Definitions_InternalQuotedMatcher_higherOrderHole: Symbol = dotc.core.Symbols.defn.InternalQuotedMatcher_higherOrderHole
-    def Definitions_InternalQuotedMatcher_patternTypeAnnot: Symbol = dotc.core.Symbols.defn.InternalQuotedMatcher_patternTypeAnnot
-    def Definitions_InternalQuotedMatcher_fromAboveAnnot: Symbol = dotc.core.Symbols.defn.InternalQuotedMatcher_fromAboveAnnot
 
     def betaReduce(tree: Term): Option[Term] =
       tree match

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -450,7 +450,7 @@ trait QuotesAndSplices {
       else ref(defn.QuotedTypeModule_apply.termRef).appliedToTypeTree(shape).select(nme.apply).appliedTo(qctx)
     UnApply(
       fun = ref(unapplySym.termRef).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
-      implicits = quotedPattern :: Literal(Constant(typeBindings.nonEmpty)) :: qctx :: Nil,
+      implicits = quotedPattern :: qctx :: Nil,
       patterns = splicePat :: Nil,
       proto = quoteClass.typeRef.appliedTo(replaceBindings(quoted1.tpe) & quotedPt))
   }

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

@@ -47,16 +47,14 @@ object Expr {
    *
    *  @param scrutineeExpr `Expr[Any]` on which we are pattern matching
    *  @param patternExpr `Expr[Any]` containing the pattern tree
-   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
+   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices
    *  @param qctx the current QuoteContext
    *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]``
    */
-  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: scala.quoted.Expr[Any])(using patternExpr: scala.quoted.Expr[Any],
-        hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: scala.quoted.Expr[Any])
+        (using patternExpr: scala.quoted.Expr[Any], qctx: QuoteContext): Option[Tup] = {
     val qctx1 = quoteContextWithCompilerInterface(qctx)
-    val qctx2 = if hasTypeSplices then qctx1.tasty.Constraints_context else qctx1
-    given qctx2.type = qctx2
-    new Matcher.QuoteMatcher[qctx2.type](qctx2).termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+    qctx1.tasty.termMatch(scrutineeExpr.unseal, patternExpr.unseal).asInstanceOf[Option[Tup]]
   }
 
   /** Returns a null expresssion equivalent to `'{null}` */

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

@@ -145,54 +145,13 @@ object Matcher {
 
     inline private def withEnv[T](env: Env)(inline body: Env ?=> T): T = body(using env)
 
-    class SymBinding(val sym: Symbol, val fromAbove: Boolean)
-
-    def termMatch(scrutineeTerm: Term, patternTerm: Term, hasTypeSplices: Boolean): Option[Tuple] = {
+    def termMatch(scrutineeTerm: Term, patternTerm: Term): Option[Tuple] =
       given Env = Map.empty
-      val matchings = scrutineeTerm =?= patternTerm
-      if !hasTypeSplices then matchings
-      else {
-        // After matching and doing all subtype checks, we have to approximate all the type bindings
-        // that we have found and seal them in a quoted.Type
-        matchings.asOptionOfTuple.map { tup =>
-          Tuple.fromArray(tup.toArray.map { // TODO improve performance
-            case x: SymBinding => qctx.tasty.Constraints_approximation(x.sym, !x.fromAbove).seal
-            case x => x
-          })
-        }
-      }
-    }
+      scrutineeTerm =?= patternTerm
 
-    // TODO factor out common logic with `termMatch`
-    def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree, hasTypeSplices: Boolean): Option[Tuple] = {
+    def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree): Option[Tuple] =
       given Env = Map.empty
-      val matchings = scrutineeTypeTree =?= patternTypeTree
-      if !hasTypeSplices then matchings
-      else {
-        // After matching and doing all subtype checks, we have to approximate all the type bindings
-        // that we have found and seal them in a quoted.Type
-        matchings.asOptionOfTuple.map { tup =>
-          Tuple.fromArray(tup.toArray.map { // TODO improve performance
-            case x: SymBinding => qctx.tasty.Constraints_approximation(x.sym, !x.fromAbove).seal
-            case x => x
-          })
-        }
-      }
-    }
-
-    private def hasPatternTypeAnnotation(sym: Symbol) = sym.annots.exists(isPatternTypeAnnotation)
-
-    private def hasFromAboveAnnotation(sym: Symbol) = sym.annots.exists(isFromAboveAnnotation)
-
-    private def isPatternTypeAnnotation(tree: Tree): Boolean = tree match {
-      case New(tpt) => tpt.symbol == qctx.tasty.Definitions_InternalQuotedMatcher_patternTypeAnnot
-      case annot => annot.symbol.owner == qctx.tasty.Definitions_InternalQuotedMatcher_patternTypeAnnot
-    }
-
-    private def isFromAboveAnnotation(tree: Tree): Boolean = tree match {
-      case New(tpt) => tpt.symbol == qctx.tasty.Definitions_InternalQuotedMatcher_fromAboveAnnot
-      case annot => annot.symbol.owner == qctx.tasty.Definitions_InternalQuotedMatcher_fromAboveAnnot
-    }
+      scrutineeTypeTree =?= patternTypeTree
 
     /** 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) => Matching): Matching = (l1, l2) match {
@@ -317,10 +276,6 @@ object Matcher {
           case (TypeApply(fn1, args1), TypeApply(fn2, args2)) =>
             fn1 =?= fn2 &&& args1 =?= args2
 
-          case (Block(stats1, expr1), Block(binding :: stats2, expr2)) if isTypeBinding(binding) =>
-            qctx.tasty.Constraints_add(binding.symbol :: Nil)
-            matched(new SymBinding(binding.symbol, hasFromAboveAnnotation(binding.symbol))) &&& Block(stats1, expr1) =?= Block(stats2, expr2)
-
           /* Match block */
           case (Block(stat1 :: stats1, expr1), Block(stat2 :: stats2, expr2)) =>
             val newEnv = (stat1, stat2) match {
@@ -333,11 +288,6 @@ object Matcher {
               stat1 =?= stat2 &&& Block(stats1, expr1) =?= Block(stats2, expr2)
             }
 
-          case (scrutinee, Block(typeBindings, expr2)) if typeBindings.forall(isTypeBinding) =>
-            val bindingSymbols = typeBindings.map(_.symbol)
-            qctx.tasty.Constraints_add(bindingSymbols)
-            bindingSymbols.foldRight(scrutinee =?= expr2)((x, acc) => matched(new SymBinding(x, hasFromAboveAnnotation(x))) &&& acc)
-
           /* Match if */
           case (If(cond1, thenp1, elsep1), If(cond2, thenp2, elsep2)) =>
             cond1 =?= cond2 &&& thenp1 =?= thenp2 &&& elsep1 =?= elsep2
@@ -456,10 +406,6 @@ object Matcher {
       }
     }
 
-    private def isTypeBinding(tree: Tree): Boolean = tree match {
-      case tree: TypeDef => hasPatternTypeAnnotation(tree.symbol)
-      case _ => false
-    }
   }
 
   /** Result of matching a part of an expression */

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

@@ -28,22 +28,16 @@ object Type {
   /** Pattern matches an the scrutineeType against the patternType and returns a tuple
    *  with the matched holes if successful.
    *
-   *  Holes:
-   *    - scala.internal.Quoted.patternHole[T]: hole that matches an expression `x` of type `Type[U]`
-   *                                            if `U <:< T` and returns `x` as part of the match.
-   *
    *  @param scrutineeType `Type[_]` on which we are pattern matching
    *  @param patternType `Type[_]` containing the pattern tree
-   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
+   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices
    *  @param qctx the current QuoteContext
    *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Type[Ti]``
    */
-  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeType: scala.quoted.Type[_])(using patternType: scala.quoted.Type[_],
-        hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeType: scala.quoted.Type[_])
+      (using patternType: scala.quoted.Type[_], qctx: QuoteContext): Option[Tup] = {
     val qctx1 = quoteContextWithCompilerInterface(qctx)
-    val qctx2 = if hasTypeSplices then qctx1.tasty.Constraints_context else qctx1
-    given qctx2.type = qctx2
-    new Matcher.QuoteMatcher[qctx2.type](qctx2).typeTreeMatch(scrutineeType.unseal, patternType.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+    qctx1.tasty.typeTreeMatch(scrutineeType.unseal, patternType.unseal).asInstanceOf[Option[Tup]]
   }
 
 

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -23,7 +23,7 @@ abstract class Expr[+T] private[scala] {
    *  ```
    */
   final def matches(that: Expr[Any])(using qctx: QuoteContext): Boolean =
-    !scala.internal.quoted.Expr.unapply[EmptyTuple, EmptyTuple](this)(using that, false, qctx).isEmpty
+    !scala.internal.quoted.Expr.unapply[EmptyTuple, EmptyTuple](this)(using that, qctx).isEmpty
 
   /** Checked cast to a `quoted.Expr[U]` */
   def cast[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] = asExprOf[U]

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

@@ -32,13 +32,15 @@ object Matcher {
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.fromAbove`")
   class fromAbove extends Annotation
 
-  class QuoteMatcher[QCtx <: QuoteContext & Singleton](using val qctx: QCtx) {
+  class QuoteMatcher[QCtx <: QuoteContext & Singleton](val qctx: QCtx) {
     import qctx.tasty._
 
-    def termMatch(scrutineeTerm: Term, patternTerm: Term, hasTypeSplices: Boolean): Option[Tuple] =
+    class SymBinding(val sym: Symbol, val fromAbove: Boolean)
+
+    def termMatch(scrutineeTerm: Term, patternTerm: Term): Option[Tuple] =
       throw new Exception("Non bootstrapped lib")
 
-    def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree, hasTypeSplices: Boolean): Option[Tuple] =
+    def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree): Option[Tuple] =
       throw new Exception("Non bootstrapped lib")
   }
 

library/src/scala/internal/tasty/CompilerInterface.scala

@@ -21,10 +21,35 @@ trait CompilerInterface { self: scala.tasty.Reflection =>
    */
   def unpickleType(repr: Unpickler.PickledQuote, args: Unpickler.PickledArgs): TypeTree
 
-
-  def Constraints_context[T]: scala.quoted.QuoteContext
-  def Constraints_add(syms: List[Symbol]): Boolean
-  def Constraints_approximation(sym: Symbol, fromBelow: Boolean): Type
+  /** Pattern matches an the scrutinee against the pattern and returns a tuple
+   *  with the matched holes if successful.
+   *
+   *  Examples:
+   *    - `termMatch(< f(0, myInt) >, < f(0, myInt) >, false)`
+   *       will return `Some(())` (where `()` is a tuple of arity 0)
+   *    - `termMatch(< f(0, myInt) >, < f(patternHole[Int], patternHole[Int]) >, false)`
+   *       will return `Some(Tuple2('{0}, '{ myInt }))`
+   *    - `termMatch(< f(0, "abc") >, < f(0, patternHole[Int]) >, false)`
+   *       will return `None` due to the missmatch of types in the hole
+   *
+   *  Holes:
+   *    - scala.internal.Quoted.patternHole[T]: hole that matches an expression `x` of type `Expr[U]`
+   *                                            if `U <:< T` and returns `x` as part of the match.
+   *
+   *  @param scrutinee `Term` on which we are pattern matching
+   *  @param pattern `Term` containing the pattern tree
+   *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Term``
+   */
+  def termMatch(scrutinee: Term, pattern: Term): Option[Tuple]
+
+  /** Pattern matches an the scrutineeType against the patternType and returns a tuple
+   *  with the matched holes if successful.
+   *
+   *  @param scrutinee `TypeTree` on which we are pattern matching
+   *  @param pattern `TypeTree` containing the pattern tree
+   *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `quoted.Type[Ti]``
+   */
+  def typeTreeMatch(scrutinee: TypeTree, pattern: TypeTree): Option[Tuple]
 
   //
   // TYPES
@@ -36,12 +61,6 @@ trait CompilerInterface { self: scala.tasty.Reflection =>
   /** Symbol of scala.internal.CompileTime.higherOrderHole */
   def Definitions_InternalQuotedMatcher_higherOrderHole: Symbol
 
-  /** Symbol of scala.internal.CompileTime.patternType */
-  def Definitions_InternalQuotedMatcher_patternTypeAnnot: Symbol
-
-  /** Symbol of scala.internal.CompileTime.fromAbove */
-  def Definitions_InternalQuotedMatcher_fromAboveAnnot: Symbol
-
   /** Returns Some with a beta-reduced application or None */
   def betaReduce(tree: Term): Option[Term]
 

library/src/scala/tasty/reflect/SourceCodePrinter.scala

@@ -583,7 +583,7 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
     def printFlatBlock(stats: List[Statement], expr: Term)(using elideThis: Option[Symbol]): Buffer = {
       val (stats1, expr1) = flatBlock(stats, expr)
       val stats2 = stats1.filter {
-        case tree: TypeDef => !tree.symbol.annots.exists(_.symbol.owner == Symbol.requiredClass("scala.internal.Quoted.quoteTypeTag"))
+        case tree: TypeDef => !tree.symbol.annots.exists(_.symbol.maybeOwner == Symbol.requiredClass("scala.internal.Quoted.quoteTypeTag"))
         case _ => true
       }
       if (stats2.isEmpty) {

tests/run-macros/quote-matcher-runtime/quoted_1.scala

@@ -7,7 +7,7 @@ object Macros {
   private def impl[A, B](a: Expr[A], b: Expr[B])(using qctx: QuoteContext) : Expr[Unit] = {
     import qctx.tasty._
 
-    val res = scala.internal.quoted.Expr.unapply[Tuple, Tuple](a)(using b, true, qctx).map { tup =>
+    val res = scala.internal.quoted.Expr.unapply[Tuple, Tuple](a)(using b, qctx).map { tup =>
       tup.toArray.toList.map {
         case r: Expr[_] =>
           s"Expr(${r.unseal.show})"