Use Expr and Type to unpickle in CompilerInterface

Author: nicolasstucki

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

@@ -2617,17 +2617,19 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
 
   end reflect
 
-  def unpickleTerm(pickledQuote: PickledQuote): reflect.Term =
-    PickledQuotes.unpickleTerm(pickledQuote)(using reflect.rootContext)
+  def unpickleExpr(pickledQuote: PickledQuote): scala.quoted.Expr[Any] =
+    val tree = PickledQuotes.unpickleTerm(pickledQuote)(using reflect.rootContext)
+    new scala.internal.quoted.Expr(tree, hash)
 
-  def unpickleTypeTree(pickledQuote: PickledQuote): reflect.TypeTree =
-    PickledQuotes.unpickleTypeTree(pickledQuote)(using reflect.rootContext)
+  def unpickleType(pickledQuote: PickledQuote): scala.quoted.Type[?] =
+    val tree = PickledQuotes.unpickleTypeTree(pickledQuote)(using reflect.rootContext)
+    new scala.internal.quoted.Type(tree, hash)
 
-  def termMatch(scrutinee: reflect.Term, pattern: reflect.Term): Option[Tuple] =
-    treeMatch(scrutinee, pattern)
+  def exprMatch(scrutinee: scala.quoted.Expr[Any], pattern: scala.quoted.Expr[Any]): Option[Tuple] =
+    treeMatch(scrutinee.unseal(using this), pattern.unseal(using this))
 
-  def typeTreeMatch(scrutinee: reflect.TypeTree, pattern: reflect.TypeTree): Option[Tuple] =
-    treeMatch(scrutinee, pattern)
+  def typeMatch(scrutinee: scala.quoted.Type[?], pattern: scala.quoted.Type[?]): Option[Tuple] =
+    treeMatch(scrutinee.unseal(using this), pattern.unseal(using this))
 
   private def treeMatch(scrutinee: reflect.Tree, pattern: reflect.Tree): Option[Tuple] = {
     import reflect._

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

@@ -54,7 +54,7 @@ object Expr {
   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)
-    qctx1.termMatch(scrutineeExpr.unseal, patternExpr.unseal).asInstanceOf[Option[Tup]]
+    qctx1.exprMatch(scrutineeExpr, patternExpr).asInstanceOf[Option[Tup]]
   }
 
   /** Returns a null expresssion equivalent to `'{null}` */

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

@@ -37,7 +37,7 @@ object Type {
   def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeType: scala.quoted.Type[_])
       (using patternType: scala.quoted.Type[_], qctx: QuoteContext): Option[Tup] = {
     val qctx1 = quoteContextWithCompilerInterface(qctx)
-    qctx1.typeTreeMatch(scrutineeType.unseal, patternType.unseal).asInstanceOf[Option[Tup]]
+    qctx1.typeMatch(scrutineeType, patternType).asInstanceOf[Option[Tup]]
   }
 
 

library/src/scala/internal/quoted/CompilerInterface.scala

@@ -12,12 +12,12 @@ trait CompilerInterface { self: scala.quoted.QuoteContext =>
   /** Unpickle `repr` which represents a pickled `Expr` tree,
    *  replacing splice nodes with `holes`
    */
-  def unpickleTerm(pickledQuote: PickledQuote): Term
+  def unpickleExpr(pickledQuote: PickledQuote): scala.quoted.Expr[Any]
 
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `holes`
    */
-  def unpickleTypeTree(pickledQuote: PickledQuote): TypeTree
+  def unpickleType(pickledQuote: PickledQuote): scala.quoted.Type[?]
 
   /** Pattern matches the scrutinee against the pattern and returns a tuple
    *  with the matched holes if successful.
@@ -34,20 +34,20 @@ trait CompilerInterface { self: scala.quoted.QuoteContext =>
    *    - 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
+   *  @param scrutinee `Expr` on which we are pattern matching
+   *  @param pattern `Expr` 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]
+  def exprMatch(scrutinee: scala.quoted.Expr[Any], pattern: scala.quoted.Expr[Any]): Option[Tuple]
 
   /** Pattern matches 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]``
+   *  @param scrutinee `Type` on which we are pattern matching
+   *  @param pattern `Type` containing the pattern tree
+   *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `scala.quoted.Type[Ti]``
    */
-  def typeTreeMatch(scrutinee: TypeTree, pattern: TypeTree): Option[Tuple]
+  def typeMatch(scrutinee: scala.quoted.Type[?], pattern: scala.quoted.Type[?]): Option[Tuple]
 
 }
 

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

@@ -18,13 +18,11 @@ object PickledQuote:
 
   def unpickleExpr[T](pickledQuote: PickledQuote): QuoteContext ?=> Expr[T] =
     val qctx = CompilerInterface.quoteContextWithCompilerInterface(summon[QuoteContext])
-    val tree = qctx.unpickleTerm(pickledQuote)
-    new scala.internal.quoted.Expr(tree, qctx.hashCode).asInstanceOf[Expr[T]]
+    qctx.unpickleExpr(pickledQuote).asInstanceOf[Expr[T]]
 
   def unpickleType[T](pickledQuote: PickledQuote): QuoteContext ?=> Type[T] =
     val qctx = CompilerInterface.quoteContextWithCompilerInterface(summon[QuoteContext])
-    val tree = qctx.unpickleTypeTree(pickledQuote)
-    new scala.internal.quoted.Type(tree, qctx.hashCode).asInstanceOf[Type[T]]
+    qctx.unpickleType(pickledQuote).asInstanceOf[Type[T]]
 
   /** Create an instance of PickledExpr from encoded tasty and sequence of labmdas to fill holes
    *