Move QuoteContextInternal functionality in scala.quoted.internal

Split `QuoteContextInternal` into `QuoteUnpickler` and `QuoteMatching`.
Also make sure that `QuoteContext` must extend `QuoteUnpickler` and `QuoteMatching`

Author: nicolasstucki

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

@@ -795,11 +795,14 @@ class Definitions {
   @tu lazy val QuotedExprModule: Symbol = QuotedExprClass.companionModule
 
   @tu lazy val QuoteContextClass: ClassSymbol = requiredClass("scala.quoted.QuoteContext")
-  @tu lazy val QuoteContextInternalClass: ClassSymbol = requiredClass("scala.internal.quoted.QuoteContextInternal")
-    @tu lazy val QuoteContextInternal_unpickleExpr: Symbol = QuoteContextInternalClass.requiredMethod("unpickleExpr")
-    @tu lazy val QuoteContextInternal_unpickleType: Symbol = QuoteContextInternalClass.requiredMethod("unpickleType")
-    @tu lazy val QuoteContextInternal_ExprMatch: Symbol = QuoteContextInternalClass.requiredMethod("ExprMatch")
-    @tu lazy val QuoteContextInternal_TypeMatch: Symbol = QuoteContextInternalClass.requiredMethod("TypeMatch")
+
+  @tu lazy val QuoteUnpicklerClass: ClassSymbol = requiredClass("scala.quoted.internal.QuoteUnpickler")
+    @tu lazy val QuoteUnpickler_unpickleExpr: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleExpr")
+    @tu lazy val QuoteUnpickler_unpickleType: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleType")
+
+  @tu lazy val QuoteMatchingClass: ClassSymbol = requiredClass("scala.quoted.internal.QuoteMatching")
+    @tu lazy val QuoteMatching_ExprMatch: Symbol = QuoteMatchingClass.requiredMethod("ExprMatch")
+    @tu lazy val QuoteMatching_TypeMatch: Symbol = QuoteMatchingClass.requiredMethod("TypeMatch")
 
   @tu lazy val LiftableModule: Symbol = requiredModule("scala.quoted.Liftable")
     @tu lazy val LiftableModule_BooleanLiftable: Symbol = LiftableModule.requiredMethod("BooleanLiftable")

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

@@ -14,6 +14,7 @@ import dotty.tools.dotc.quoted.QuoteUtils._
 import dotty.tools.dotc.core.Decorators._
 
 import scala.quoted.QuoteContext
+import scala.quoted.internal.{QuoteUnpickler, QuoteMatching}
 import dotty.tools.dotc.quoted.printers.{Extractors, SourceCode, SyntaxHighlight}
 
 import scala.tasty.reflect._
@@ -40,7 +41,7 @@ object QuoteContextImpl {
 
 }
 
-class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.internal.quoted.QuoteContextInternal:
+class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickler, QuoteMatching:
 
   object reflect extends scala.tasty.Reflection:
 

compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala

@@ -193,11 +193,11 @@ class PickleQuotes extends MacroTransform {
         }
       }
 
-      /** Encode quote using QuoteContextInternal.{unpickleExpr, unpickleType}
+      /** Encode quote using QuoteUnpickler.{unpickleExpr, unpickleType}
        *
        *  Generate the code
        *  ```scala
-       *    qctx => qctx.asInstanceOf[QuoteContextInternal].<unpickleExpr|unpickleType>[<type>](
+       *    qctx => qctx.asInstanceOf[QuoteUnpickler].<unpickleExpr|unpickleType>[<type>](
        *      <pickledQuote>,
        *      <typeHole>,
        *      <termHole>,
@@ -255,8 +255,8 @@ class PickleQuotes extends MacroTransform {
         val quotedType = quoteClass.typeRef.appliedTo(originalTp)
         val lambdaTpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, quotedType)
         def callUnpickle(ts: List[Tree]) = {
-          val qctx = ts.head.asInstance(defn.QuoteContextInternalClass.typeRef)
-          val unpickleMeth = if isType then defn.QuoteContextInternal_unpickleType else defn.QuoteContextInternal_unpickleExpr
+          val qctx = ts.head.asInstance(defn.QuoteUnpicklerClass.typeRef)
+          val unpickleMeth = if isType then defn.QuoteUnpickler_unpickleType else defn.QuoteUnpickler_unpickleExpr
           qctx.select(unpickleMeth).appliedToType(originalTp).appliedTo(pickledQuoteStrings, typeHoles, termHoles)
         }
         Lambda(lambdaTpe, callUnpickle).withSpan(body.span)

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

@@ -463,8 +463,8 @@ trait QuotesAndSplices {
       if (tree.quoted.isTerm) ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(defn.AnyType).appliedTo(shape).select(nme.apply).appliedTo(qctx)
       else ref(defn.QuotedTypeModule_apply.termRef).appliedToTypeTree(shape).select(nme.apply).appliedTo(qctx)
 
-    val matchModule = if tree.quoted.isTerm then defn.QuoteContextInternal_ExprMatch else defn.QuoteContextInternal_TypeMatch
-    val unapplyFun = qctx.asInstance(defn.QuoteContextInternalClass.typeRef).select(matchModule).select(nme.unapply)
+    val matchModule = if tree.quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
+    val unapplyFun = qctx.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
 
     UnApply(
       fun = unapplyFun.appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),

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

@@ -18,7 +18,7 @@ abstract class Expr[+T] private[scala] {
    *  ```
    */
   final def matches(that: Expr[Any])(using qctx: QuoteContext): Boolean =
-    val ExprMatch = qctx.asInstanceOf[scala.internal.quoted.QuoteContextInternal].ExprMatch
+    val ExprMatch = qctx.asInstanceOf[scala.quoted.internal.QuoteMatching].ExprMatch
     ExprMatch.unapply[EmptyTuple, EmptyTuple](this)(using that).nonEmpty
 
   /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */

library/src-non-bootstrapped/scala/quoted/QuoteContext.scala

@@ -8,7 +8,7 @@ package scala.quoted
  *
  *  @param tasty Typed AST API. Usage: `def f(qctx: QuoteContext) = { import qctx.reflect._; ... }`.
  */
-trait QuoteContext { self =>
+trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
 
   /** Low-level Typed AST API metaprogramming API.
    *  This API does not have the static type guarantiees that `Expr` and `Type` provide.

library/src-bootstrapped/scala/quoted/QuoteContext.scala renamed to library/src/scala/quoted/QuoteContext.scala

@@ -1,20 +1,10 @@
-package scala.internal.quoted
+package scala.quoted.internal
 
 import scala.quoted.{QuoteContext, Expr, Type}
 import scala.tasty.reflect._
 
 /** Part of the QuoteContext interface that needs to be implemented by the compiler but is not visible to users */
-trait QuoteContextInternal { self: QuoteContext =>
-
-  /** Unpickle `repr` which represents a pickled `Expr` tree,
-   *  replacing splice nodes with `holes`
-   */
-  def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], QuoteContext) => Expr[?]): scala.quoted.Expr[T]
-
-  /** Unpickle `repr` which represents a pickled `Type` tree,
-   *  replacing splice nodes with `holes`
-   */
-  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], QuoteContext) => Expr[?]): scala.quoted.Type[T]
+trait QuoteMatching { self: QuoteContext & QuoteUnpickler =>
 
   val ExprMatch: ExprMatchModule
 

library/src/scala/internal/quoted/QuoteContextInternal.scala renamed to library/src/scala/quoted/internal/QuoteMatching.scala

@@ -0,0 +1,19 @@
+package scala.quoted.internal
+
+import scala.quoted.{QuoteContext, Expr, Type}
+import scala.tasty.reflect._
+
+/** Part of the QuoteContext interface that needs to be implemented by the compiler but is not visible to users */
+trait QuoteUnpickler { self: QuoteContext & QuoteMatching =>
+
+  /** Unpickle `repr` which represents a pickled `Expr` tree,
+   *  replacing splice nodes with `holes`
+   */
+  def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], QuoteContext) => Expr[?]): scala.quoted.Expr[T]
+
+  /** Unpickle `repr` which represents a pickled `Type` tree,
+   *  replacing splice nodes with `holes`
+   */
+  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], QuoteContext) => Expr[?]): scala.quoted.Type[T]
+
+}

library/src/scala/quoted/internal/QuoteUnpickler.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.reflect._
 
-    val res = qctx.asInstanceOf[scala.internal.quoted.QuoteContextInternal].ExprMatch.unapply[Tuple, Tuple](a)(using b).map { tup =>
+    val res = qctx.asInstanceOf[scala.quoted.internal.QuoteMatching].ExprMatch.unapply[Tuple, Tuple](a)(using b).map { tup =>
       tup.toArray.toList.map {
         case r: Expr[_] =>
           s"Expr(${r.show})"