Move Staging before Pickler

nicolasstucki · nicolasstucki · commit 40ba19ad6277 · 2019-01-18T14:35:52.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -45,8 +45,8 @@ class Compiler {
 
   /** Phases dealing with TASTY tree pickling and unpickling */
   protected def picklerPhases: List[List[Phase]] =
-    List(new Pickler) ::            // Generate TASTY info
     List(new Staging) ::            // Check quotation levels (while healing types) and expand macros
+    List(new Pickler) ::            // Generate TASTY info
     List(new ReifyQuotes) ::        // Turn quoted trees into explicit run-time data structures
     Nil
 
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
@@ -162,7 +162,7 @@ class TreeTypeMap(
       assert(!to.exists(substFrom contains _))
       assert(!from.exists(newOwners contains _))
       assert(!to.exists(oldOwners contains _))
-      new TreeTypeMap(
+      newTreeTypeMap(
         typeMap,
         treeMap,
         from ++ oldOwners,
@@ -171,6 +171,11 @@ class TreeTypeMap(
         to ++ substTo)
     }
 
+  protected def newTreeTypeMap(typeMap: Type => Type, treeMap: tpd.Tree => tpd.Tree,
+      oldOwners: List[Symbol], newOwners: List[Symbol], substFrom: List[Symbol], substTo: List[Symbol]) = {
+    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+  }
+
   /** Apply `typeMap` and `ownerMap` to given symbols `syms`
    *  and return a treemap that contains the substitution
    *  between original and mapped symbols.
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
@@ -775,7 +775,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)
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -1,21 +1,24 @@
-package dotty.tools.dotc
-package transform
-
-import core._
-import Decorators._, Flags._, Types._, Contexts._, Symbols._, Constants._
-import ast.Trees._
-import ast.{TreeTypeMap, untpd}
-import util.Positions._
-import tasty.TreePickler.Hole
-import SymUtils._
-import NameKinds._
-import dotty.tools.dotc.ast.tpd
-import typer.Implicits.SearchFailureType
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.{TreeTypeMap, tpd, untpd}
+import dotty.tools.dotc.core.Constants._
+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.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.tasty.TreePickler.Hole
+import dotty.tools.dotc.reporting
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Implicits.SearchFailureType
+import dotty.tools.dotc.util.Positions._
+import dotty.tools.dotc.util.SourcePosition
 
 import scala.collection.mutable
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
-import dotty.tools.dotc.util.SourcePosition
 
 
 /** Checks that the phase consistency principle (PCP) holds, heals types and expand macros.
@@ -83,7 +86,7 @@ class Staging extends MacroTransformWithImplicits {
       * These will be turned into splices using `addTags` and represent types spliced
       * explicitly.
       */
-    val explicitTags = new mutable.LinkedHashSet[TypeRef]()
+    val explicitTags = new mutable.LinkedHashSet[(TypeRef, Position)]()
 
     /** A stack of entered symbols, to be unwound after scope exit */
     var enteredSyms: List[Symbol] = Nil
@@ -111,7 +114,8 @@ class Staging extends MacroTransformWithImplicits {
           name = UniqueName.fresh("T".toTermName).toTypeName,
           flags = Synthetic,
           info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)),
-          coord = typeRef.prefix.termSymbol.coord).asType
+          coord = alias.pos
+        ).asType
 
         ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
       }
@@ -126,11 +130,11 @@ class Staging extends MacroTransformWithImplicits {
         importedTags.clear()
 
         // The tree of the tag for each tag comes from a type ref e.g., ~t
-        val explicitTypeDefs = for (tref <- explicitTags) yield {
-          val tag = ref(tref.prefix.termSymbol)
+        val explicitTypeDefs = for ((tref, pos) <- explicitTags) yield {
+          val tag = ref(tref.prefix.termSymbol).withPos(pos)
           mkTagSymbolAndAssignType(tref, tag)
         }
-        val tagsExplicitTypeDefsPairs = explicitTags.zip(explicitTypeDefs)
+        val tagsExplicitTypeDefsPairs = explicitTags.map(_._1).zip(explicitTypeDefs)
         explicitTags.clear()
 
         // Maps type splices to type references of tags e.g., ~t -> some type T$1
@@ -150,8 +154,52 @@ class Staging extends MacroTransformWithImplicits {
           }
         }
 
+        /** Type tree map that does not tag type at level 0 */
+        class QuoteTreeTypeMap(
+            typeMap: Type => Type = IdentityTypeMap,
+            treeMap: tpd.Tree => tpd.Tree = identity _,
+            oldOwners: List[Symbol] = Nil,
+            newOwners: List[Symbol] = Nil,
+            substFrom: List[Symbol] = Nil,
+            substTo: List[Symbol] = Nil
+        )(implicit ctx: Context) extends TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo) { self =>
+
+          protected var level = 1 // TODO use context to keep track of the level
+
+          override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+            if (level == 0) {
+              // Keep transforming but do not replace insert the taged types. Types in nested quotes are also not taged.
+              val (sFrom, sTo) = substFrom.zip(substTo).filterNot(_._2.is(Synthetic)).unzip // TODO Syntetic is probably not enugh to distinguish added types
+              new TreeTypeMap(typeMap, treeMap,
+                oldOwners, newOwners,
+                sFrom, sTo
+              ).transform(tree)
+            }
+            else if (tree.symbol.isSplice) {
+              level -= 1
+              try super.transform(tree)
+              finally level += 1
+            } else if (tree.symbol.isQuote) {
+              level += 1
+              try super.transform(tree)
+              finally level -= 1
+            }
+            else super.transform(tree)
+
+          }
+
+          protected override def newTreeTypeMap(typeMap: Type => Type, treeMap: tpd.Tree => tpd.Tree,
+                                                oldOwners: List[Symbol], newOwners: List[Symbol],
+                                                substFrom: List[Symbol], substTo: List[Symbol]) = {
+            new QuoteTreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo) {
+              level = self.level
+            }
+          }
+
+        }
+
         Block(typeDefs ++ explicitTypeDefs,
-          new TreeTypeMap(
+          new QuoteTreeTypeMap(
             treeMap = trMap,
             typeMap = tpMap,
             substFrom = itags.map(_._1.symbol),
@@ -243,7 +291,7 @@ class Staging extends MacroTransformWithImplicits {
         tp match {
           case tp: TypeRef if tp.symbol.isSplice =>
             if (inQuote) {
-              explicitTags += tp
+              explicitTags += Tuple2(tp, pos)
               outer.checkType(pos).foldOver(acc, tp)
             }
             else {
@@ -333,7 +381,7 @@ class Staging extends MacroTransformWithImplicits {
       }
       else if (enclosingInlineds.nonEmpty) { // level 0 in an inlined call
         val spliceCtx = ctx.outer // drop the last `inlineContext`
-        val pos: SourcePosition = Decorators.sourcePos(enclosingInlineds.head.pos)(spliceCtx)
+        val pos: SourcePosition = sourcePos(enclosingInlineds.head.pos)(spliceCtx)
         val evaluatedSplice = Splicer.splice(splice.qualifier, pos, macroClassLoader)(spliceCtx).withPos(splice.pos)
         if (ctx.reporter.hasErrors) splice else transform(evaluatedSplice)
       }
@@ -396,7 +444,7 @@ class Staging extends MacroTransformWithImplicits {
             tree.rhs match {
               case InlineSplice(_) =>
                 mapOverTree(enteredSyms) // Ignore output, only check PCP
-                cpy.DefDef(tree)(rhs = defaultValue(tree.rhs.tpe))
+                tree
               case _ =>
                 ctx.error(
                   """Malformed macro.
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -637,7 +637,7 @@ trait TreeOps extends Core {
 
     /** Scala local `return` */
     val Return: ReturnModule
-    abstract class ReturnModule {
+    abstract class ReturnModule { // TODO should we expose explicitly the returns `from`?
 
       /** Creates `return <expr: Term>` */
       def apply(expr: Term)(implicit ctx: Context): Return
diff --git a/tests/plugins/neg/divideZero/plugin_1.scala b/tests/plugins/neg/divideZero/plugin_1.scala
@@ -8,7 +8,7 @@ import transform.MegaPhase.MiniPhase
 import Decorators._
 import Symbols.Symbol
 import Constants.Constant
-import transform.{Pickler, Staging}
+import transform.{Pickler, ReifyQuotes}
 import StdNames._
 
 class DivideZero extends PluginPhase with StandardPlugin {
@@ -18,7 +18,7 @@ class DivideZero extends PluginPhase with StandardPlugin {
   val phaseName = name
 
   override val runsAfter = Set(Pickler.name)
-  override val runsBefore = Set(Staging.name)
+  override val runsBefore = Set(ReifyQuotes.name)
 
   override def init(options: List[String]): List[PluginPhase] = this :: Nil
 
