Move RawQuoted to library

Author: nicolasstucki

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

@@ -10,7 +10,6 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames._
 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._
 
@@ -34,22 +33,17 @@ 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)
+  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: TaggedType[_] =>
-      val tpe = expr.ct match {
-        case ClassTag.Unit => defn.UnitType
-        case ClassTag.Byte => defn.ByteType
-        case ClassTag.Char => defn.CharType
-        case ClassTag.Short => defn.ShortType
-        case ClassTag.Int => defn.IntType
-        case ClassTag.Long => defn.LongType
-        case ClassTag.Float => defn.FloatType
-        case ClassTag.Double => defn.FloatType
-      }
-      TypeTree(tpe)
-    case expr: RawQuoted => expr.tree
+    case expr: RawExpr[Tree] @unchecked => expr.tree
+  }
+
+  /** 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 */
@@ -113,4 +107,18 @@ object PickledQuotes {
     }
     tree
   }
+
+  private def classTagToTypeTree(ct: ClassTag[_])(implicit ctx: Context): TypeTree = {
+    val tpe = ct match {
+      case ClassTag.Unit => defn.UnitType
+      case ClassTag.Byte => defn.ByteType
+      case ClassTag.Char => defn.CharType
+      case ClassTag.Short => defn.ShortType
+      case ClassTag.Int => defn.IntType
+      case ClassTag.Long => defn.LongType
+      case ClassTag.Float => defn.FloatType
+      case ClassTag.Double => defn.FloatType
+    }
+    TypeTree(tpe)
+  }
 }

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]
+
   // Implementations of Type[T]
 
   /** A Type backed by a pickled TASTY tree */
@@ -38,4 +49,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]
+
 }