Move RawQuoted to library

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -7,11 +7,10 @@ import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
-import dotty.tools.dotc.interpreter.RawQuoted
 
 import scala.quoted.Quoted._
 
@@ -35,17 +34,19 @@ object PickledQuotes {
   }
 
   /** Transform the expression into its fully spliced Tree */
-  def quotedToTree(expr: quoted.Quoted)(implicit ctx: Context): Tree = expr match {
-    case expr: TastyQuoted =>
-      unpickleQuote(expr)
-    case expr: ConstantExpr[_] =>
-      Literal(Constant(expr.value))
+  def quotedExprToTree(expr: quoted.Expr[_])(implicit ctx: Context): Tree = expr match {
+    case expr: TastyExpr[_] => unpickleQuote(expr)
+    case expr: ConstantExpr[_] => Literal(Constant(expr.value))
+    case expr: RawExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
-      functionAppliedTo(quotedToTree(expr.f), quotedToTree(expr.x))
-    case expr: TaggedType[_] =>
-      classTagToTypeTree(expr.ct)
-    case expr: RawQuoted =>
-      expr.tree
+      functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
+  }
+
+  /** Transform the expression into its fully spliced TypeTree */
+  def quotedTypeToTree(expr: quoted.Type[_])(implicit ctx: Context): Tree = expr match {
+    case expr: TastyType[_] => unpickleQuote(expr)
+    case expr: TaggedType[_] => classTagToTypeTree(expr.ct)
+    case expr: RawType[Tree] @unchecked => expr.tree
   }
 
   /** Unpickle the tree contained in the TastyQuoted */

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -20,8 +20,8 @@ import config.Printers.pickling
 import typer.Checking
 import config.Config
 import dotty.tools.dotc.core.quoted.PickledQuotes
-import dotty.tools.dotc.interpreter.RawQuoted
 import scala.quoted
+import scala.quoted.Quoted.{RawExpr, RawType}
 
 /** Unpickler for typed trees
  *  @param reader          the reader from which to unpickle
@@ -288,7 +288,7 @@ class TreeUnpickler(reader: TastyReader,
             case ENUMconst =>
               ConstantType(Constant(readTermRef().termSymbol))
             case HOLE =>
-              readHole(end).tpe
+              readHole(end, isType = true).tpe
           }
         assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
@@ -1040,7 +1040,7 @@ class TreeUnpickler(reader: TastyReader,
             case TYPEBOUNDStpt =>
               TypeBoundsTree(readTpt(), readTpt())
             case HOLE =>
-              readHole(end)
+              readHole(end, isType = false)
             case _ =>
               readPathTerm()
           }
@@ -1091,14 +1091,23 @@ class TreeUnpickler(reader: TastyReader,
       new LazyReader(localReader, op)
     }
 
-    def readHole(end: Addr)(implicit ctx: Context): Tree = {
+    def readHole(end: Addr, isType: Boolean)(implicit ctx: Context): Tree = {
       val idx = readNat()
       val args = until(end)(readTerm())
       val splice = splices(idx)
-      val quotedType =
-        if (args.isEmpty) splice.asInstanceOf[quoted.Quoted]
-        else splice.asInstanceOf[Seq[Any] => quoted.Quoted](args.map(RawQuoted.apply))
-      PickledQuotes.quotedToTree(quotedType)
+
+      if (isType) {
+        val quotedType =
+          if (args.isEmpty) splice.asInstanceOf[quoted.Type[_]]
+          else splice.asInstanceOf[Seq[Any] => quoted.Type[_]](args.map(tree => new RawType(tree)))
+        PickledQuotes.quotedTypeToTree(quotedType)
+      } else {
+        val quotedExpr =
+          if (args.isEmpty) splice.asInstanceOf[quoted.Expr[_]]
+          else splice.asInstanceOf[Seq[Any] => quoted.Expr[_]](args.map(tree => new RawExpr(tree)))
+        PickledQuotes.quotedExprToTree(quotedExpr)
+      }
+
     }
 
 // ------ Setting positions ------------------------------------------------

compiler/src/dotty/tools/dotc/interpreter/Interpreter.scala

@@ -71,7 +71,9 @@ class Interpreter(implicit ctx: Context) {
     implicit val pos: Position = tree.pos
 
     tree match {
-      case Quoted(quotedTree) => RawQuoted(quotedTree)
+      case Quoted(quotedTree) =>
+        if (tree.isTerm) new scala.quoted.Quoted.RawExpr(quotedTree)
+        else new scala.quoted.Quoted.RawType(quotedTree)
 
       case Literal(Constant(c)) => c.asInstanceOf[Object]
 

compiler/src/dotty/tools/dotc/interpreter/RawQuoted.scala

@@ -61,7 +61,7 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
         case exprUnit: ExprCompilationUnit =>
           val tree =
             if (putInClass) inClass(exprUnit.expr)
-            else PickledQuotes.quotedToTree(exprUnit.expr)
+            else PickledQuotes.quotedExprToTree(exprUnit.expr)
           val source = new SourceFile("", Seq())
           CompilationUnit.mkCompilationUnit(source, tree, forceTrees = true)
       }
@@ -80,7 +80,7 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
       cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
       val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
 
-      val quoted = PickledQuotes.quotedToTree(expr)(ctx.withOwner(meth))
+      val quoted = PickledQuotes.quotedExprToTree(expr)(ctx.withOwner(meth))
 
       val run = DefDef(meth, quoted)
       val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)

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

@@ -24,7 +24,7 @@ object Splicer {
   /** Splice the Tree for a Quoted expression which is constructed via a reflective call to the given method */
   private def reflectiveSplice(tree: Tree)(implicit ctx: Context): Tree = {
     val interpreter = new Interpreter
-    interpreter.interpretTree[scala.quoted.Expr[_]](tree).map(PickledQuotes.quotedToTree(_)).getOrElse(tree)
+    interpreter.interpretTree[scala.quoted.Expr[_]](tree).map(PickledQuotes.quotedExprToTree).getOrElse(tree)
   }
 
 }

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

@@ -14,6 +14,14 @@ object Quoted {
     def args: Seq[Any]
   }
 
+  /** Quoted for which its internal representation is its tree.
+   *  - Used for trees that cannot be serialized, such as references to local symbols that will be spliced in.
+   *  - Used for trees that do not need to be serialized to avoid the overhead of serialization/deserialization.
+   */
+  trait RawQuoted[Tree] extends quoted.Quoted {
+    def tree: Tree
+  }
+
   // Implementations of Expr[T]
 
   /** An Expr backed by a pickled TASTY tree */
@@ -26,6 +34,9 @@ object Quoted {
     override def toString: String = s"Expr($value)"
   }
 
+  /** An Expr backed by a tree */
+  final class RawExpr[Tree](val tree: Tree) extends quoted.Expr[Any] with RawQuoted[Tree]
+
   /** An Expr representing `'{(~f).apply(~x)}` but it is beta-reduced when the closure is known */
   final class FunctionAppliedTo[T, U](val f: Expr[T => U], val x: Expr[T]) extends Expr[U] {
     override def toString: String = s"Expr($f <applied to> $x)"
@@ -43,4 +54,7 @@ object Quoted {
     override def toString: String = s"Type($ct)"
   }
 
+  /** An Type backed by a tree */
+  final class RawType[Tree](val tree: Tree) extends quoted.Type[Any] with RawQuoted[Tree]
+
 }