Add TASTY pickling of quotes and implement ~ on quotes

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

@@ -1047,7 +1047,7 @@ class Definitions {
 
 //  private val unboxedTypeRef = mutable.Map[TypeName, TypeRef]()
 //  private val javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]()
-//  private val valueTypeNameToJavaType = mutable.Map[TypeName, Class[_]]()
+  private val valueTypeNamesToJavaType = mutable.Map[TypeName, Class[_]]()
 
   private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int, tag: Name): TypeRef = {
     val vcls = ctx.requiredClassRef(name)
@@ -1056,7 +1056,7 @@ class Definitions {
     typeTags(vcls.name) = tag
 //    unboxedTypeRef(boxed.name) = vcls
 //    javaTypeToValueTypeRef(jtype) = vcls
-//    valueTypeNameToJavaType(vcls.name) = jtype
+    valueTypeNamesToJavaType(vcls.name) = jtype
     vcls
   }
 
@@ -1066,6 +1066,10 @@ class Definitions {
   /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
   def typeTag(tp: Type)(implicit ctx: Context): Name = typeTags(scalaClassName(tp))
 
+  /** The `Class[_]` of a primitive value type name */
+  def valueTypeNameToJavaType(name: TypeName)(implicit ctx: Context): Option[Class[_]] =
+    valueTypeNamesToJavaType.get(if (name.firstPart eq nme.scala_) name.lastPart.toTypeName else name)
+
   type PrimitiveClassEnc = Int
 
   val ByteEnc = 2

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

@@ -0,0 +1,97 @@
+package dotty.tools.dotc.core.quoted
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.config.Printers._
+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.Symbols._
+import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
+import dotty.tools.dotc.interpreter.RawQuoted
+
+object PickledQuotes {
+  import tpd._
+
+  /** Pickle the quote into a TASTY string */
+  def pickleQuote(tree: Tree)(implicit ctx: Context): String = {
+    if (ctx.reporter.hasErrors) "<error>"
+    else {
+      val encapsulated = encapsulateQuote(tree)
+      val pickled = pickle(encapsulated)
+      TastyString.tastyToString(pickled)
+    }
+  }
+
+  /** Transform the expression into its fully spliced Tree */
+  def quotedToTree(expr: quoted.Quoted)(implicit ctx: Context): Tree = expr match {
+    case expr: quoted.TastyQuoted => unpickleQuote(expr)
+    case expr: quoted.Liftable.ConstantExpr[_] => Literal(Constant(expr.value))
+    case expr: RawQuoted => expr.tree
+  }
+
+  /** Unpickle the tree contained in the TastyQuoted */
+  private def unpickleQuote(expr: quoted.TastyQuoted)(implicit ctx: Context): Tree = {
+    val tastyBytes = TastyString.stringToTasty(expr.tasty)
+    val unpickled = unpickle(tastyBytes, expr.args)
+    unpickled match {
+      case PackageDef(_, (vdef: ValDef) :: Nil) => vdef.rhs
+      case PackageDef(_, (tdef: TypeDef) :: Nil) => tdef.rhs
+    }
+  }
+
+  /** Encapsulate the tree in a top level `val` or `type`
+   *    `<tree>` ==> `package _root_ { val ': Any = <tree> }`
+   *    or
+   *    `<type tree>` ==> `package _root_ { type ' = <tree tree> }`
+   */
+  private def encapsulateQuote(tree: Tree)(implicit ctx: Context): Tree = {
+    def encapsulatedTerm = {
+      val sym = ctx.newSymbol(ctx.owner, "'".toTermName, Synthetic, defn.AnyType, coord = tree.pos)
+      ValDef(sym, tree).withPos(tree.pos)
+    }
+
+    def encapsulatedType =
+      untpd.TypeDef("'".toTypeName, tree).withPos(tree.pos).withType(defn.AnyType)
+
+    val quoted = if (tree.isTerm) encapsulatedTerm else encapsulatedType
+    PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], quoted :: Nil).withPos(tree.pos)
+  }
+
+  // TASTY picklingtests/pos/quoteTest.scala
+
+  /** Pickle tree into it's TASTY bytes s*/
+  private def pickle(tree: Tree)(implicit ctx: Context): Array[Byte] = {
+    val pickler = new TastyPickler(defn.RootClass)
+    val treePkl = pickler.treePkl
+    treePkl.pickle(tree :: Nil)
+    treePkl.compactify()
+    pickler.addrOfTree = treePkl.buf.addrOfTree
+    pickler.addrOfSym = treePkl.addrOfSym
+    // if (tree.pos.exists)
+    //   new PositionPickler(pickler, treePkl.buf.addrOfTree).picklePositions(tree :: Nil)
+
+    // other pickle sections go here.
+    val pickled = pickler.assembleParts()
+
+    if (pickling ne noPrinter) {
+      println(i"**** pickled quote of \n${tree.show}")
+      new TastyPrinter(pickled).printContents()
+    }
+
+    pickled
+  }
+
+  /** Unpickle TASTY bytes into it's tree */
+  private def unpickle(bytes: Array[Byte], splices: Seq[Any])(implicit ctx: Context): Tree = {
+    val unpickler = new TastyUnpickler(bytes, splices)
+    unpickler.enter(roots = Set(defn.RootPackage))
+    val tree = unpickler.body.head
+    if (pickling ne noPrinter) {
+      println(i"**** unpickled quote for \n${tree.show}")
+      new TastyPrinter(bytes).printContents()
+    }
+    tree
+  }
+}

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

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.core.quoted
+
+import dotty.tools.dotc.ast.Trees.GenericApply
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.transform.SymUtils._
+
+/** Extractors for quotes */
+object Quoted {
+
+  /** Extracts the content of a quoted tree.
+   *  The result can be the contents of a term ot type quote, which
+   *  will return a term or type tree respectively.
+   */
+  def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
+    case tree: GenericApply[Type] if tree.symbol.isQuote => Some(tree.args.head)
+    case _ => None
+  }
+}

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

@@ -0,0 +1,24 @@
+package dotty.tools.dotc.core.quoted
+
+import dotty.tools.dotc.core.tasty._
+import dotty.tools.dotc.core.tasty.TastyUnpickler.NameTable
+
+object TastyUnpickler {
+  class QuotedTreeSectionUnpickler(posUnpickler: Option[PositionUnpickler], splices: Seq[Any])
+    extends DottyUnpickler.TreeSectionUnpickler(posUnpickler) {
+    override def unpickle(reader: TastyReader, nameAtRef: NameTable) =
+      new TreeUnpickler(reader, nameAtRef, posUnpickler, splices)
+  }
+}
+
+/** A class for unpickling quoted Tasty trees and symbols.
+ *  @param bytes         the bytearray containing the Tasty file from which we unpickle
+ *  @param splices       splices that will fill the holes in the quote
+ */
+class TastyUnpickler(bytes: Array[Byte], splices: Seq[Any]) extends DottyUnpickler(bytes) {
+  import DottyUnpickler._
+  import TastyUnpickler._
+
+  protected override def treeSectionUnpickler(posUnpicklerOpt: Option[PositionUnpickler]): TreeSectionUnpickler =
+    new QuotedTreeSectionUnpickler(posUnpicklerOpt, splices)
+}

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

@@ -38,14 +38,18 @@ class DottyUnpickler(bytes: Array[Byte]) extends ClassfileParser.Embedded {
 
   val unpickler = new TastyUnpickler(bytes)
   private val posUnpicklerOpt = unpickler.unpickle(new PositionsSectionUnpickler)
-  private val treeUnpickler = unpickler.unpickle(new TreeSectionUnpickler(posUnpicklerOpt)).get
+  private val treeUnpickler = unpickler.unpickle(treeSectionUnpickler(posUnpicklerOpt)).get
 
   /** Enter all toplevel classes and objects into their scopes
    *  @param roots          a set of SymDenotations that should be overwritten by unpickling
    */
   def enter(roots: Set[SymDenotation])(implicit ctx: Context): Unit =
     treeUnpickler.enterTopLevel(roots)
 
+  protected def treeSectionUnpickler(posUnpicklerOpt: Option[PositionUnpickler]): TreeSectionUnpickler = {
+    new TreeSectionUnpickler(posUnpicklerOpt)
+  }
+
   /** Only used if `-Yretain-trees` is set. */
   private[this] var myBody: List[Tree] = _
   /** The unpickled trees, and the source file they come from. */

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

@@ -67,7 +67,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
               printName(); printTrees()
             case REFINEDtype =>
               printName(); printTree(); printTrees()
-            case RETURN =>
+            case RETURN | HOLE =>
               printNat(); printTrees()
             case METHODtype | POLYtype | TYPELAMBDAtype =>
               printTree()

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

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.core.tasty
+
+/** Utils for String representation of TASTY */
+object TastyString {
+
+  /** Decode the TASTY String into TASTY bytes */
+  def stringToTasty(str: String): Array[Byte] = {
+    val bytes = new Array[Byte](str.length)
+    for (i <- str.indices) bytes(i) = str.charAt(i).toByte
+    bytes
+  }
+
+  /** Encode TASTY bytes into a TASTY String */
+  def tastyToString(bytes: Array[Byte]): String = {
+    val chars = new Array[Char](bytes.length)
+    for (i <- bytes.indices) chars(i) = (bytes(i) & 0xff).toChar
+    new String(chars)
+  }
+
+}

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

@@ -300,7 +300,7 @@ class TreePickler(pickler: TastyPickler) {
       pickleName(sym.name)
       pickleParams
       tpt match {
-        case templ: Template => pickleTree(tpt)
+        case _: Template | _: Hole => pickleTree(tpt)
         case _ if tpt.isType => pickleTpt(tpt)
       }
       pickleTreeUnlessEmpty(rhs)

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

@@ -19,6 +19,9 @@ import scala.collection.{ mutable, immutable }
 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.Expr
 
 /** Unpickler for typed trees
  *  @param reader          the reader from which to unpickle
@@ -1030,8 +1033,10 @@ class TreeUnpickler(reader: TastyReader,
               val idx = readNat()
               val args = until(end)(readTerm())
               val splice = splices(idx)
-              if (args.isEmpty) splice.asInstanceOf[Tree]
-              else splice.asInstanceOf[Seq[Any] => Tree](args)
+              val expr =
+                if (args.isEmpty) splice.asInstanceOf[Expr[_]]
+                else splice.asInstanceOf[Seq[Any] => Expr[_]](args.map(RawQuoted.apply))
+              PickledQuotes.quotedToTree(expr)
             case _ =>
               readPathTerm()
           }