Merge pull request #9904 from dotty-staging/refactor-quote-pattern-entry-points

Refactor quote matching internal logic

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -922,7 +922,7 @@ object desugar {
   def quotedPatternTypeDef(tree: TypeDef)(using Context): TypeDef = {
     assert(ctx.mode.is(Mode.QuotedPattern))
     if (tree.name.startsWith("$") && !tree.isBackquoted) {
-      val patternBindHoleAnnot = New(ref(defn.InternalQuotedMatcher_patternTypeAnnot.typeRef)).withSpan(tree.span)
+      val patternBindHoleAnnot = New(ref(defn.InternalQuotedPatterns_patternTypeAnnot.typeRef)).withSpan(tree.span)
       val mods = tree.mods.withAddedAnnotation(patternBindHoleAnnot)
       tree.withMods(mods)
     }

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -808,12 +808,12 @@ class Definitions {
     @tu lazy val InternalQuoted_exprNestedSplice : Symbol = InternalQuotedModule.requiredMethod("exprNestedSplice")
     @tu lazy val InternalQuoted_QuoteTypeTagAnnot: ClassSymbol = InternalQuotedModule.requiredClass("quoteTypeTag")
 
-  @tu lazy val InternalQuotedMatcher: Symbol = requiredModule("scala.internal.quoted.Matcher")
-    @tu lazy val InternalQuotedMatcher_patternHole: Symbol = InternalQuotedMatcher.requiredMethod("patternHole")
-    @tu lazy val InternalQuotedMatcher_patternHigherOrderHole: Symbol = InternalQuotedMatcher.requiredMethod("patternHigherOrderHole")
-    @tu lazy val InternalQuotedMatcher_higherOrderHole: Symbol = InternalQuotedMatcher.requiredMethod("higherOrderHole")
-    @tu lazy val InternalQuotedMatcher_patternTypeAnnot: ClassSymbol = InternalQuotedMatcher.requiredClass("patternType")
-    @tu lazy val InternalQuotedMatcher_fromAboveAnnot: ClassSymbol = InternalQuotedMatcher.requiredClass("fromAbove")
+  @tu lazy val InternalQuotedPatterns: Symbol = requiredModule("scala.internal.quoted.Patterns")
+    @tu lazy val InternalQuotedPatterns_patternHole: Symbol = InternalQuotedPatterns.requiredMethod("patternHole")
+    @tu lazy val InternalQuotedPatterns_patternHigherOrderHole: Symbol = InternalQuotedPatterns.requiredMethod("patternHigherOrderHole")
+    @tu lazy val InternalQuotedPatterns_higherOrderHole: Symbol = InternalQuotedPatterns.requiredMethod("higherOrderHole")
+    @tu lazy val InternalQuotedPatterns_patternTypeAnnot: ClassSymbol = InternalQuotedPatterns.requiredClass("patternType")
+    @tu lazy val InternalQuotedPatterns_fromAboveAnnot: ClassSymbol = InternalQuotedPatterns.requiredClass("fromAbove")
 
   @tu lazy val InternalQuotedExprModule: Symbol = requiredModule("scala.internal.quoted.Expr")
     @tu lazy val InternalQuotedExpr_unapply: Symbol = InternalQuotedExprModule.requiredMethod(nme.unapply)

library/src-bootstrapped/scala/internal/quoted/Matcher.scala renamed to compiler/src/dotty/tools/dotc/quoted/Matcher.scala

@@ -1,4 +1,4 @@
-package scala.internal.quoted
+package dotty.tools.dotc.quoted
 
 import scala.annotation.internal.sharable
 import scala.annotation.{Annotation, compileTimeOnly}
@@ -98,33 +98,8 @@ import scala.internal.tasty.CompilerInterface.quoteContextWithCompilerInterface
  */
 object Matcher {
 
-  /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternHole`")
-  def patternHole[T]: T = ???
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternHigherOrderHole`")
-  /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
-  def patternHigherOrderHole[U](pat: Any, args: Any*): U = ???
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.higherOrderHole`")
-  /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
-  def higherOrderHole[U](args: Any*): U = ???
-
-  // TODO remove
-  /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternBindHole`")
-  class patternBindHole extends Annotation
-
-  /** A splice of a name in a quoted pattern is that marks the definition of a type splice */
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternType`")
-  class patternType extends Annotation
-
-  /** A type pattern that must be aproximated from above */
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.fromAbove`")
-  class fromAbove extends Annotation
-
   class QuoteMatcher[QCtx <: QuoteContext & Singleton](val qctx0: QCtx) {
-    val qctx = quoteContextWithCompilerInterface(qctx0)
+    val qctx = qctx0.asInstanceOf[qctx0.type { val tasty: qctx0.tasty.type & scala.internal.tasty.CompilerInterface }]
 
     // TODO improve performance
 
@@ -145,54 +120,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 {
@@ -244,23 +178,23 @@ object Matcher {
 
           /* Term hole */
           // Match a scala.internal.Quoted.patternHole typed as a repeated argument and return the scrutinee tree
-          case (scrutinee as Typed(s, tpt1), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
-              if patternHole.symbol == qctx.tasty.Definitions_InternalQuotedMatcher_patternHole &&
+          case (scrutinee @ Typed(s, tpt1), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
+              if patternHole.symbol == qctx.tasty.Definitions_InternalQuotedPatterns_patternHole &&
                  s.tpe <:< tpt.tpe &&
                  tpt2.tpe.derivesFrom(defn.RepeatedParamClass) =>
             matched(scrutinee.seal)
 
           /* Term hole */
           // Match a scala.internal.Quoted.patternHole and return the scrutinee tree
           case (ClosedPatternTerm(scrutinee), TypeApply(patternHole, tpt :: Nil))
-              if patternHole.symbol == qctx.tasty.Definitions_InternalQuotedMatcher_patternHole &&
+              if patternHole.symbol == qctx.tasty.Definitions_InternalQuotedPatterns_patternHole &&
                  scrutinee.tpe <:< tpt.tpe =>
             matched(scrutinee.seal)
 
           /* Higher order term hole */
           // Matches an open term and wraps it into a lambda that provides the free variables
-          case (scrutinee, pattern as Apply(TypeApply(Ident("higherOrderHole"), List(Inferred())), Repeated(args, _) :: Nil))
-              if pattern.symbol == qctx.tasty.Definitions_InternalQuotedMatcher_higherOrderHole =>
+          case (scrutinee, pattern @ Apply(TypeApply(Ident("higherOrderHole"), List(Inferred())), Repeated(args, _) :: Nil))
+              if pattern.symbol == qctx.tasty.Definitions_InternalQuotedPatterns_higherOrderHole =>
 
             def bodyFn(lambdaArgs: List[Tree]): Tree = {
               val argsMap = args.map(_.symbol).zip(lambdaArgs.asInstanceOf[List[Term]]).toMap
@@ -317,10 +251,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 +263,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 +381,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 */

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.InternalQuotedPatterns_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 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.InternalQuotedPatterns_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 Definitions_InternalQuotedPatterns_patternHole: Symbol = dotc.core.Symbols.defn.InternalQuotedPatterns_patternHole
+    def Definitions_InternalQuotedPatterns_higherOrderHole: Symbol = dotc.core.Symbols.defn.InternalQuotedPatterns_higherOrderHole
 
     def betaReduce(tree: Term): Option[Term] =
       tree match

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

@@ -139,7 +139,7 @@ trait QuotesAndSplices {
         report.error("Missing arguments for open pattern", tree.srcPos)
       val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
       val typedPat = typedSplice(splice, defn.FunctionOf(argTypes, pt))
-      ref(defn.InternalQuotedMatcher_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
+      ref(defn.InternalQuotedPatterns_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
   }
 
   /** Translate ${ t: Type[T] }` into type `t.splice` while tracking the quotation level in the context */
@@ -166,7 +166,7 @@ trait QuotesAndSplices {
         case pt: TypeBounds => pt
         case _ => TypeBounds.empty
       val typeSym = newSymbol(spliceOwner(ctx), name, EmptyFlags, typeSymInfo, NoSymbol, tree.expr.span)
-      typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuotedMatcher_patternTypeAnnot.typeRef)).withSpan(tree.expr.span)))
+      typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuotedPatterns_patternTypeAnnot.typeRef)).withSpan(tree.expr.span)))
       val pat = typedPattern(tree.expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
           using spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
       pat.select(tpnme.spliceType)
@@ -236,20 +236,20 @@ trait QuotesAndSplices {
           val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
           val newSplice = ref(defn.InternalQuoted_exprSplice).appliedToType(tpt1.tpe).appliedTo(Typed(pat, exprTpt))
           transform(newSplice)
-        case Apply(TypeApply(fn, targs), Apply(sp, pat :: Nil) :: args :: Nil) if fn.symbol == defn.InternalQuotedMatcher_patternHigherOrderHole =>
+        case Apply(TypeApply(fn, targs), Apply(sp, pat :: Nil) :: args :: Nil) if fn.symbol == defn.InternalQuotedPatterns_patternHigherOrderHole =>
           args match // TODO support these patterns. Possibly using scala.quoted.util.Var
             case SeqLiteral(args, _) =>
               for arg <- args; if arg.symbol.is(Mutable) do
                 report.error("References to `var`s cannot be used in higher-order pattern", arg.srcPos)
-          try ref(defn.InternalQuotedMatcher_higherOrderHole.termRef).appliedToTypeTrees(targs).appliedTo(args).withSpan(tree.span)
+          try ref(defn.InternalQuotedPatterns_higherOrderHole.termRef).appliedToTypeTrees(targs).appliedTo(args).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
             val patType1 = patType.translateFromRepeated(toArray = false)
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
         case Apply(fn, pat :: Nil) if fn.symbol.isExprSplice =>
-          try ref(defn.InternalQuotedMatcher_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
+          try ref(defn.InternalQuotedPatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
             val patType1 = patType.translateFromRepeated(toArray = false)
@@ -265,7 +265,7 @@ trait QuotesAndSplices {
           else
             tree
         case tdef: TypeDef  =>
-          if tdef.symbol.hasAnnotation(defn.InternalQuotedMatcher_patternTypeAnnot) then
+          if tdef.symbol.hasAnnotation(defn.InternalQuotedPatterns_patternTypeAnnot) then
             transformTypeBindingTypeDef(tdef, typePatBuf)
           else if tdef.symbol.isClass then
             val kind = if tdef.symbol.is(Module) then "objects" else "classes"
@@ -304,7 +304,7 @@ trait QuotesAndSplices {
 
       private def transformTypeBindingTypeDef(tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]])(using Context): Tree = {
         if (variance == -1)
-          tdef.symbol.addAnnotation(Annotation(New(ref(defn.InternalQuotedMatcher_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
+          tdef.symbol.addAnnotation(Annotation(New(ref(defn.InternalQuotedPatterns_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
         val bindingType = getBinding(tdef.symbol).symbol.typeRef
         val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
         val bindName = tdef.name.toString.stripPrefix("$").toTermName
@@ -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))
   }