ReifyQuotes v2

A rewrite to handle embedded holes correctly

Author: odersky

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

@@ -591,13 +591,11 @@ class Definitions {
   def ClassTagClass(implicit ctx: Context) = ClassTagType.symbol.asClass
   def ClassTagModule(implicit ctx: Context) = ClassTagClass.companionModule
 
-  lazy val QuotedType = ctx.requiredClassRef("scala.quoted.Quoted")
-  def QuotedClass(implicit ctx: Context) = QuotedType.symbol.asClass
-
   lazy val QuotedExprType = ctx.requiredClassRef("scala.quoted.Expr")
   def QuotedExprClass(implicit ctx: Context) = QuotedExprType.symbol.asClass
 
     def QuotedExpr_~(implicit ctx: Context) = QuotedExprClass.requiredMethod(nme.UNARY_~)
+    def QuotedExpr_run(implicit ctx: Context) = QuotedExprClass.requiredMethod(nme.run)
 
   lazy val QuotedTypeType = ctx.requiredClassRef("scala.quoted.Type")
   def QuotedTypeClass(implicit ctx: Context) = QuotedTypeType.symbol.asClass

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

@@ -485,6 +485,7 @@ object StdNames {
     val reflect : N             = "reflect"
     val reify : N               = "reify"
     val rootMirror : N          = "rootMirror"
+    val run: N                  = "run"
     val runOrElse: N            = "runOrElse"
     val runtime: N              = "runtime"
     val runtimeClass: N         = "runtimeClass"

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

@@ -4,7 +4,7 @@ package core
 package tasty
 
 import ast.Trees._
-import ast.untpd
+import ast.{untpd, tpd}
 import TastyFormat._
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
 import collection.mutable
@@ -14,22 +14,30 @@ import StdNames.nme
 import TastyBuffer._
 import TypeApplications._
 import transform.SymUtils._
-import Splicing.Hole
+import printing.Printer
+import printing.Texts._
 import config.Config
 
+object TreePickler {
+
+  case class Hole(idx: Int, args: List[tpd.Tree]) extends tpd.TermTree {
+    override def fallbackToText(printer: Printer): Text =
+      s"[[$idx|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]"
+  }
+}
+
 class TreePickler(pickler: TastyPickler) {
   val buf = new TreeBuffer
   pickler.newSection("ASTs", buf)
+  import TreePickler._
   import buf._
   import pickler.nameBuffer.nameIndex
-  import ast.tpd._
+  import tpd._
 
   private val symRefs = Symbols.newMutableSymbolMap[Addr]
   private val forwardSymRefs = Symbols.newMutableSymbolMap[List[Addr]]
   private val pickledTypes = new java.util.IdentityHashMap[Type, Any] // Value type is really Addr, but that's not compatible with null
 
-  private var holeCount = 0
-
   private def withLength(op: => Unit) = {
     val lengthAddr = reserveRef(relative = true)
     op
@@ -545,11 +553,10 @@ class TreePickler(pickler: TastyPickler) {
         case TypeBoundsTree(lo, hi) =>
           writeByte(TYPEBOUNDStpt)
           withLength { pickleTree(lo); pickleTree(hi) }
-        case Hole(args) =>
+        case Hole(idx, args) =>
           writeByte(HOLE)
           withLength {
-            writeNat(holeCount)
-            holeCount += 1
+            writeNat(idx)
             args.foreach(pickleTree)
           }
       }

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

@@ -8,10 +8,9 @@ import StdNames._, Denotations._, Flags._, Constants._, Annotations._
 import NameKinds._
 import typer.Checking.checkNonCyclic
 import util.Positions._
-import ast.{tpd, Trees, untpd}
+import ast.{tpd, untpd, Trees}
 import Trees._
 import Decorators._
-import Splicing.Splice
 import transform.SymUtils._
 import TastyUnpickler._, TastyBuffer._
 import scala.annotation.{tailrec, switch}
@@ -29,7 +28,7 @@ import config.Config
 class TreeUnpickler(reader: TastyReader,
                     nameAtRef: NameRef => TermName,
                     posUnpicklerOpt: Option[PositionUnpickler],
-                    splices: Seq[Splice]) {
+                    splices: Seq[Any]) {
   import TastyFormat._
   import TreeUnpickler._
   import tpd._
@@ -1038,7 +1037,9 @@ class TreeUnpickler(reader: TastyReader,
             case HOLE =>
               val idx = readNat()
               val args = until(end)(readTerm())
-              (splices(idx) /: args)(_.asInstanceOf[Tree => Tree](_)).asInstanceOf[Tree]
+              val splice = splices(idx)
+              if (args.isEmpty) splice.asInstanceOf[Tree]
+              else splice.asInstanceOf[Seq[Any] => Tree](args)
             case _ =>
               readPathTerm()
           }