Encode quote unpickle quotes directly on QuoteContext

Author: nicolasstucki

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

@@ -795,6 +795,7 @@ 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 LiftableModule: Symbol = requiredModule("scala.quoted.Liftable")
     @tu lazy val LiftableModule_BooleanLiftable: Symbol = LiftableModule.requiredMethod("BooleanLiftable")
@@ -837,8 +838,6 @@ class Definitions {
   @tu lazy val TastyReflectionClass: ClassSymbol = requiredClass("scala.tasty.Reflection")
 
   @tu lazy val PickledQuote_make: Symbol = requiredMethod("scala.internal.quoted.PickledQuote.make")
-  @tu lazy val PickledQuote_unpickleExpr: Symbol = requiredMethod("scala.internal.quoted.PickledQuote.unpickleExpr")
-  @tu lazy val PickledQuote_unpickleType: Symbol = requiredMethod("scala.internal.quoted.PickledQuote.unpickleType")
 
   @tu lazy val EqlClass: ClassSymbol = requiredClass("scala.Eql")
     def Eql_eqlAny(using Context): TermSymbol = EqlClass.companionModule.requiredMethod(nme.eqlAny)

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

@@ -190,13 +190,30 @@ class ReifyQuotes extends MacroTransform {
         }
       }
 
+      /** Encode quote using QuoteContextInternal.{unpickleExpr, unpickleType}
+       *
+       *  Generate the code
+       *  ```scala
+       *    qctx => qctx.asInstanceOf[QuoteContextInternal].<unpickleExpr|unpickleType>(
+       *      <pickledQuote>
+       *    ).asInstanceOf[scala.quoted.<Expr|Type>[<type>]]
+       *  ```
+       *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+       */
       def pickleAsTasty() = {
-        val unpickleMeth = if isType then defn.PickledQuote_unpickleType else defn.PickledQuote_unpickleExpr
         val pickledQuoteStrings = liftList(PickledQuotes.pickleQuote(body).map(x => Literal(Constant(x))), defn.StringType)
         // TODO: generate an instance of PickledSplices directly instead of passing through a List
         val splicesList = liftList(splices, defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), defn.AnyType))
         val pickledQuote = ref(defn.PickledQuote_make).appliedTo(pickledQuoteStrings, splicesList)
-        ref(unpickleMeth).appliedToType(originalTp).appliedTo(pickledQuote)
+        val quoteClass = if isType then defn.QuotedTypeClass else defn.QuotedExprClass
+        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 unpickleMethName = if isType then "unpickleType" else "unpickleExpr"
+          qctx.select(unpickleMethName.toTermName).appliedTo(pickledQuote).asInstance(quotedType)
+        }
+        Lambda(lambdaTpe, callUnpickle).withSpan(body.span)
       }
 
       /** Encode quote using Reflection.TypeRepr.typeConstructorOf

library/src/scala/internal/quoted/PickledQuote.scala

@@ -16,12 +16,6 @@ trait PickledQuote:
 
 object PickledQuote:
 
-  def unpickleExpr[T](pickledQuote: PickledQuote): QuoteContext ?=> Expr[T] =
-    qctx.asInstanceOf[QuoteContextInternal].unpickleExpr(pickledQuote).asInstanceOf[Expr[T]]
-
-  def unpickleType[T](pickledQuote: PickledQuote): QuoteContext ?=> Type[T] =
-    qctx.asInstanceOf[QuoteContextInternal].unpickleType(pickledQuote).asInstanceOf[Type[T]]
-
   /** Create an instance of PickledExpr from encoded tasty and sequence of labmdas to fill holes
    *
    *  @param pickled: Bytes of tasty encoded using TastyString.pickle