Extract quote reification from Staging

Split current `Staging` into `Staging` and `ReifyQuotes`
- `Staging`
  - Just before `Pickler`
  - Checks PCP
  - Heals phase consistency by replacing `T` with `~implicitly[Type[T]]({{t}})` (actually `~t`)
  - Expand macros
  - Ycheck that PCP holds (without healing) until `ReifyQuotes`
- `ReifyQuotes`
  - Aliases all type splices by replacing `~t` by `T$1` and inserting `type T$1 = ~t` at the start of the  quoted block.
  - Transform `'{ ... ~(... ) ... }` into `unpickle('{ ... Hole(...) ... }, List(args => ....))`
- `TreeMapWithStages` a new `TreeMap` that contains the logic to track quotation levels while mapping the tree.
- Moved logic from `MacroTransformWithImplicits` to `TreeMapWithImplicits` to be able to tranform a tree without the need to be in a macro transform. This will be useful to integrate the PCP checks and macro expansion in `Typer`.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -45,8 +45,9 @@ class Compiler {
 
   /** Phases dealing with TASTY tree pickling and unpickling */
   protected def picklerPhases: List[List[Phase]] =
+    List(new Staging) ::            // Check PCP, heal quoted types and expand macros
     List(new Pickler) ::            // Generate TASTY info
-    List(new Staging) ::            // Expand macros and turn quoted trees into explicit run-time data structures
+    List(new ReifyQuotes) ::        // Turn quoted trees into explicit run-time data structures
     Nil
 
   /** Phases dealing with the transformation from pickled trees to backend trees */

compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala

@@ -0,0 +1,107 @@
+package dotty.tools.dotc
+package ast
+
+import core._
+import ast.Trees._
+import Contexts._
+import Symbols._
+import annotation.tailrec
+
+/** A TreeMap that maintains the necessary infrastructore to support
+ *  contxtual implicit searches (type-scope implicits are supported anyway).
+ */
+class TreeMapWithImplicits extends ast.tpd.TreeMap {
+  import ast.tpd._
+
+  protected def localCtx(tree: Tree)(implicit ctx: Context): FreshContext = {
+    val sym = tree.symbol
+    val owner = if (sym is Flags.PackageVal) sym.moduleClass else sym
+    ctx.fresh.setTree(tree).setOwner(owner)
+  }
+
+  def transformSelf(vd: ValDef)(implicit ctx: Context): ValDef =
+    cpy.ValDef(vd)(tpt = transform(vd.tpt))
+
+  /** Transform statements, while maintaining import contexts and expression contexts
+   *  in the same way as Typer does. The code addresses additional concerns:
+   *   - be tail-recursive where possible
+   *   - don't re-allocate trees where nothing has changed
+   */
+  def transformStats(stats: List[Tree], exprOwner: Symbol)(implicit ctx: Context): List[Tree] = {
+
+    @tailrec def traverse(curStats: List[Tree])(implicit ctx: Context): List[Tree] = {
+
+      def recur(stats: List[Tree], changed: Tree, rest: List[Tree])(implicit ctx: Context): List[Tree] = {
+        if (stats eq curStats) {
+          val rest1 = transformStats(rest, exprOwner)
+          changed match {
+            case Thicket(trees) => trees ::: rest1
+            case tree => tree :: rest1
+          }
+        }
+        else stats.head :: recur(stats.tail, changed, rest)
+      }
+
+      curStats match {
+        case stat :: rest =>
+          val statCtx = stat match {
+            case stat: DefTree => ctx
+            case _ => ctx.exprContext(stat, exprOwner)
+          }
+          val restCtx = stat match {
+            case stat: Import => ctx.importContext(stat, stat.symbol)
+            case _ => ctx
+          }
+          val stat1 = transform(stat)(statCtx)
+          if (stat1 ne stat) recur(stats, stat1, rest)(restCtx)
+          else traverse(rest)(restCtx)
+        case nil =>
+          stats
+      }
+    }
+    traverse(stats)
+  }
+
+  private def nestedScopeCtx(defs: List[Tree])(implicit ctx: Context): Context = {
+    val nestedCtx = ctx.fresh.setNewScope
+    defs foreach {
+      case d: DefTree => nestedCtx.enter(d.symbol)
+      case _ =>
+    }
+    nestedCtx
+  }
+
+  override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+    try tree match {
+      case tree: Block =>
+        super.transform(tree)(nestedScopeCtx(tree.stats))
+      case tree: DefDef =>
+        implicit val ctx1 = localCtx(tree)(ctx)
+        cpy.DefDef(tree)(
+          tree.name,
+          transformSub(tree.tparams),
+          tree.vparamss mapConserve (transformSub(_)),
+          transform(tree.tpt),
+          transform(tree.rhs)(nestedScopeCtx(tree.vparamss.flatten)))
+      case EmptyValDef =>
+        tree
+      case _: PackageDef | _: MemberDef =>
+        super.transform(tree)(localCtx(tree))
+      case impl @ Template(constr, parents, self, _) =>
+        cpy.Template(tree)(
+          transformSub(constr),
+          transform(parents)(ctx.superCallContext),
+          Nil,
+          transformSelf(self),
+          transformStats(impl.body, tree.symbol))
+      case _ =>
+        super.transform(tree)
+    }
+    catch {
+      case ex: TypeError =>
+        ctx.error(ex.toMessage, tree.sourcePos)
+        tree
+    }
+  }
+
+}

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -15,6 +15,7 @@ import annotation.internal.sharable
 import annotation.unchecked.uncheckedVariance
 import annotation.constructorOnly
 import Decorators._
+import dotty.tools.dotc.core.tasty.TreePickler.Hole
 
 object Trees {
 
@@ -1435,6 +1436,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
+            case Hole(_, args) =>
+              this(x, args)
             case _ =>
               foldMoreCases(x, tree)
           }

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

@@ -473,6 +473,7 @@ object Contexts {
     def typerPhase: Phase                  = base.typerPhase
     def sbtExtractDependenciesPhase: Phase = base.sbtExtractDependenciesPhase
     def picklerPhase: Phase                = base.picklerPhase
+    def reifyQuotesPhase: Phase            = base.reifyQuotesPhase
     def refchecksPhase: Phase              = base.refchecksPhase
     def patmatPhase: Phase                 = base.patmatPhase
     def elimRepeatedPhase: Phase           = base.elimRepeatedPhase

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

@@ -219,6 +219,7 @@ object Phases {
     private[this] var myTyperPhase: Phase = _
     private[this] var mySbtExtractDependenciesPhase: Phase = _
     private[this] var myPicklerPhase: Phase = _
+    private[this] var myReifyQuotesPhase: Phase = _
     private[this] var myCollectNullableFieldsPhase: Phase = _
     private[this] var myRefChecksPhase: Phase = _
     private[this] var myPatmatPhase: Phase = _
@@ -235,6 +236,7 @@ object Phases {
     final def typerPhase: Phase = myTyperPhase
     final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
     final def picklerPhase: Phase = myPicklerPhase
+    final def reifyQuotesPhase: Phase = myReifyQuotesPhase
     final def collectNullableFieldsPhase: Phase = myCollectNullableFieldsPhase
     final def refchecksPhase: Phase = myRefChecksPhase
     final def patmatPhase: Phase = myPatmatPhase
@@ -254,6 +256,7 @@ object Phases {
       myTyperPhase = phaseOfClass(classOf[FrontEnd])
       mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
       myPicklerPhase = phaseOfClass(classOf[Pickler])
+      myReifyQuotesPhase = phaseOfClass(classOf[ReifyQuotes])
       myCollectNullableFieldsPhase = phaseOfClass(classOf[CollectNullableFields])
       myRefChecksPhase = phaseOfClass(classOf[RefChecks])
       myElimRepeatedPhase = phaseOfClass(classOf[ElimRepeated])

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

@@ -10,7 +10,7 @@ import dotty.tools.dotc.transform.SymUtils._
 object Quoted {
 
   /** Extracts the content of a quoted tree.
-   *  The result can be the contents of a term ot type quote, which
+   *  The result can be the contents of a term or type quote, which
    *  will return a term or type tree respectively.
    */
   def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {

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

@@ -0,0 +1,19 @@
+package dotty.tools.dotc.core.quoted
+
+import dotty.tools.dotc.ast.Trees._
+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 splices */
+object Spliced {
+
+  /** Extracts the content of a spliced tree.
+   *  The result can be the contents of a term or type splice, which
+   *  will return a term or type tree respectively.
+   */
+  def unapply(tree: tpd.Select)(implicit ctx: Context): Option[tpd.Tree] =
+    if (tree.symbol.isSplice) Some(tree.qualifier) else None
+
+}

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -251,8 +251,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def blockText[T >: Untyped](trees: List[Tree[T]]): Text =
     ("{" ~ toText(trees, "\n") ~ "}").close
 
-  protected def typeApplyText[T >: Untyped](tree: TypeApply[T]): Text =
-    toTextLocal(tree.fun) ~ "[" ~ toTextGlobal(tree.args, ", ") ~ "]"
+  protected def typeApplyText[T >: Untyped](tree: TypeApply[T]): Text = {
+    if (tree.fun.hasType && tree.fun.symbol == defn.QuotedType_apply)
+      keywordStr("'[") ~ toTextGlobal(tree.args, ", ") ~ keywordStr("]")
+    else
+      toTextLocal(tree.fun) ~ "[" ~ toTextGlobal(tree.args, ", ") ~ "]"
+  }
 
   protected def toTextCore[T >: Untyped](tree: Tree[T]): Text = {
     import untpd.{modsDeco => _, _}
@@ -320,7 +324,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>
-        if (tree.hasType && tree.symbol == defn.QuotedExpr_~ || tree.symbol == defn.QuotedType_~) keywordStr("~(") ~ toTextLocal(qual) ~ keywordStr(")")
+        if (tree.hasType && tree.symbol == defn.QuotedExpr_~) keywordStr("~(") ~ toTextLocal(qual) ~ keywordStr(")")
+        else if (tree.hasType && tree.symbol == defn.QuotedType_~) typeText("~(") ~ toTextLocal(qual) ~ typeText(")")
         else if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
         else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided name != nme.CONSTRUCTOR)
       case tree: This =>
@@ -334,8 +339,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           }
         else if (fun.hasType && fun.symbol == defn.QuotedExpr_apply)
           keywordStr("'{") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
-        else if (fun.hasType && fun.symbol == defn.QuotedType_apply)
-          keywordStr("'[") ~ toTextGlobal(args, ", ") ~ keywordStr("]")
         else
           toTextLocal(fun) ~ "(" ~ toTextGlobal(args, ", ") ~ ")"
       case tree: TypeApply =>

compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala

@@ -777,7 +777,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
         tpd.Return(expr, ctx.owner)
 
       def copy(original: Tree)(expr: Term)(implicit ctx: Context): Return =
-        tpd.cpy.Return(original)(expr, tpd.EmptyTree)
+        tpd.cpy.Return(original)(expr, tpd.ref(ctx.owner))
 
       def unapply(x: Term)(implicit ctx: Context): Option[Term] = x match {
         case x: tpd.Return => Some(x.expr)