Move scala.internal.quoted.{ Matcher.unapply => Expr.unapply }

Author: nicolasstucki

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

@@ -651,8 +651,8 @@ class Definitions {
     @tu lazy val InternalQuoted_patternBindHoleAnnot: ClassSymbol = InternalQuotedModule.requiredClass("patternBindHole")
     @tu lazy val InternalQuoted_QuoteTypeTagAnnot: ClassSymbol = InternalQuotedModule.requiredClass("quoteTypeTag")
 
-  @tu lazy val InternalQuotedMatcherModule: Symbol = ctx.requiredModule("scala.internal.quoted.Matcher")
-    @tu lazy val InternalQuotedMatcher_unapply: Symbol = InternalQuotedMatcherModule.requiredMethod(nme.unapply)
+  @tu lazy val InternalQuotedExprModule: Symbol = ctx.requiredModule("scala.internal.quoted.Expr")
+    @tu lazy val InternalQuotedExpr_unapply: Symbol = InternalQuotedExprModule.requiredMethod(nme.unapply)
 
   @tu lazy val QuotedTypeClass: ClassSymbol = ctx.requiredClass("scala.quoted.Type")
     @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.splice)

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

@@ -249,7 +249,7 @@ trait QuotesAndSplices { self: Typer =>
   }
 
   /** Type a quote pattern `case '{ <quoted> } =>` qiven the a current prototype. Typing the pattern
-   *  will also transform it into a call to `scala.internal.quoted.Matcher.unapply`.
+   *  will also transform it into a call to `scala.internal.quoted.Expr.unapply`.
    *
    *  Code directly inside the quote is typed as an expression using Mode.QuotedPattern. Splices
    *  within the quotes become patterns again and typed acordingly.
@@ -276,7 +276,7 @@ trait QuotesAndSplices { self: Typer =>
    *  and the patterns in the splices. All these are recombined into a call to `Matcher.unapply`.
    *
    *  ```
-   *  case scala.internal.quoted.Matcher.unapply[
+   *  case scala.internal.quoted.Expr.unapply[
    *          Tuple1[$t @ _], // Type binging definition
    *          Tuple2[Type[$t], Expr[List[$t]]] // Typing the result of the pattern match
    *        ](
@@ -347,7 +347,7 @@ trait QuotesAndSplices { self: Typer =>
     val splicePat = typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
 
     UnApply(
-      fun = ref(defn.InternalQuotedMatcher_unapply.termRef).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
+      fun = ref(defn.InternalQuotedExpr_unapply.termRef).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
       implicits =
           ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(defn.AnyType).appliedTo(shape).select(nme.apply).appliedTo(qctx) ::
           Literal(Constant(typeBindings.nonEmpty)) ::

docs/docs/reference/other-new-features/quoted-pattern-spec.md

@@ -18,18 +18,18 @@ def foo(x: Expr[Int]) given tasty.Reflect: Expr[Int] = x match {
 ```
 In the example above we have `$a` which provides a `Bind[Int]`, `$x` which provides an `Expr[Int]` and `${Bind(`a`)}` which probides an `Expr[Int]` that is pattern matched against `Bind(`a`)` to check that it is a reference to `a`.
 
-Quoted patterns are transformed during typer to a call of `scala.internal.quoted.Matcher.unapply` which splits the quoted code into the patterns and a reifiable quote that will be used as witnesses at runtime.
+Quoted patterns are transformed during typer to a call of `scala.internal.quoted.Expr.unapply` which splits the quoted code into the patterns and a reifiable quote that will be used as witnesses at runtime.
 
 ```scala
 def foo(x: Expr[Int]) given tasty.Reflect: Expr[Int] = x match {
-  case scala.internal.quoted.Matcher.unapply[Tuple3[Bind[Int], Expr[Int], Expr[Int]]](Tuple3(a, x, Bind(`a`), y))('{ @patternBindHole val a: Int = patternHole[Int]; patternHole[Int] + 1 }) =>
+  case scala.internal.quoted.Expr.unapply[Tuple3[Bind[Int], Expr[Int], Expr[Int]]](Tuple3(a, x, Bind(`a`), y))('{ @patternBindHole val a: Int = patternHole[Int]; patternHole[Int] + 1 }) =>
 }
 ```
 
 
 ## Runtime semantics
 
-At runtime to a `quoted.Expr` can be matched to another using `scala.internal.quoted.Matcher.unapply`.
+At runtime to a `quoted.Expr` can be matched to another using `scala.internal.quoted.Expr.unapply`.
 
 ```scala
 def unapply[Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup]
@@ -49,7 +49,7 @@ def matched[T](x: T) = Some(Tuple1(x))
 def (x: Matching) && (y: Matching) = if (x == None || y == None) None else Some(x.get ++ y.get)
 def fold[T](m: Mattching*) given Env: Matching = m.fold(matched)(_ && _)
 
-// `a =#= b` stands for `a` matches `b` 
+// `a =#= b` stands for `a` matches `b`
 def (scrutinee: Tree) =#= pattern: Tree) given Env: Matching // described by cases in the tables below
 
 def envWith(equiv: (Symbol, Symbol)*) given Env: Env // Adds to the current environment the fact that s1 from the scrutinee is equivalent to s2 in the pattern

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

@@ -0,0 +1,34 @@
+package scala.internal.quoted
+
+import scala.quoted._
+
+object Expr {
+
+  /** Pattern matches an the scrutineeExpr against the patternExpr and returns a tuple
+   *  with the matched holes if successful.
+   *
+   *  Examples:
+   *    - `Matcher.unapply('{ f(0, myInt) })('{ f(0, myInt) }, _)`
+   *       will return `Some(())` (where `()` is a tuple of arity 0)
+   *    - `Matcher.unapply('{ f(0, myInt) })('{ f(patternHole[Int], patternHole[Int]) }, _)`
+   *       will return `Some(Tuple2('{0}, '{ myInt }))`
+   *    - `Matcher.unapply('{ f(0, "abc") })('{ f(0, patternHole[Int]) }, _)`
+   *       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 scrutineeExpr `Expr[_]` on which we are pattern matching
+   *  @param patternExpr `Expr[_]` containing the pattern tree
+   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
+   *  @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: Expr[_])(implicit patternExpr: Expr[_],
+        hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
+    import qctx.tasty._
+    new Matcher.QuoteMatcher[qctx.type].termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+  }
+
+}

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

@@ -5,40 +5,13 @@ import scala.annotation.internal.sharable
 import scala.quoted._
 import scala.quoted.matching.Bind
 
-object Matcher {
-
-  private final val debug = false
-
-  /** Pattern matches an the scrutineeExpr against the patternExpr and returns a tuple
-   *  with the matched holes if successful.
-   *
-   *  Examples:
-   *    - `Matcher.unapply('{ f(0, myInt) })('{ f(0, myInt) }, _)`
-   *       will return `Some(())` (where `()` is a tuple of arity 0)
-   *    - `Matcher.unapply('{ f(0, myInt) })('{ f(patternHole[Int], patternHole[Int]) }, _)`
-   *       will return `Some(Tuple2('{0}, '{ myInt }))`
-   *    - `Matcher.unapply('{ f(0, "abc") })('{ f(0, patternHole[Int]) }, _)`
-   *       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 scrutineeExpr `Expr[_]` on which we are pattern matching
-   *  @param patternExpr `Expr[_]` containing the pattern tree
-   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
-   *  @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: Expr[_])(implicit patternExpr: Expr[_],
-        hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
-    import qctx.tasty._
-    new QuoteMatcher[qctx.type].termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
-  }
+private[quoted] object Matcher {
 
-  private class QuoteMatcher[QCtx <: QuoteContext & Singleton] given (val qctx: QCtx) {
+  class QuoteMatcher[QCtx <: QuoteContext & Singleton] given (val qctx: QCtx) {
     // TODO improve performance
 
+    private final val debug = false
+
     import qctx.tasty.{Bind => BindPattern, _}
     import Matching._
 

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

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

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

@@ -1,7 +1,7 @@
 
 import Macros._
 
-import scala.internal.quoted.Matcher._
+import scala.internal.quoted.Expr._
 
 import scala.internal.Quoted._