Allow cross-stage persistence for types

odersky · odersky · commit 0a603dd343c1 · 2017-12-11T18:16:50.000+01:00
... provided they are backed by type tags, i.e. implicit values
of type `quoted.Type`.
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
@@ -5,13 +5,18 @@ import core._
 import Decorators._, Flags._, Types._, Contexts._, Symbols._, Constants._
 import Flags._
 import ast.Trees._
+import util.Positions._
+import StdNames._
+import ast.untpd
 import MegaPhase.MiniPhase
+import typer.Implicits._
+import NameKinds.OuterSelectName
 import scala.collection.mutable
 
 /** Translates quoted terms and types to `unpickle` method calls.
  *  Checks that the phase consistency principle (PCP) holds.
  */
-class ReifyQuotes extends MacroTransform {
+class ReifyQuotes extends MacroTransformWithImplicits {
   import ast.tpd._
 
   override def phaseName: String = "reifyQuotes"
@@ -21,9 +26,9 @@ class ReifyQuotes extends MacroTransform {
 
   protected def newTransformer(implicit ctx: Context): Transformer = new Reifier
 
-  /** is tree splice operation? */
-  def isSplice(tree: Select)(implicit ctx: Context) =
-    tree.symbol == defn.QuotedExpr_~ || tree.symbol == defn.QuotedType_~
+  /** Is symbol a splice operation? */
+  def isSplice(sym: Symbol)(implicit ctx: Context) =
+    sym == defn.QuotedExpr_~ || sym == defn.QuotedType_~
 
   /** Serialize `tree`. Embedded splices are represented as nodes of the form
    *
@@ -36,13 +41,57 @@ class ReifyQuotes extends MacroTransform {
   def pickleTree(tree: Tree, isType: Boolean)(implicit ctx: Context): String =
     tree.show // TODO: replace with TASTY
 
-  private class Reifier extends Transformer {
+  private class Reifier extends ImplicitsTransformer {
+
+    /** A class for collecting the splices of some quoted expression */
+    private class Splices {
+
+      /** A listbuffer collecting splices */
+      val buf = new mutable.ListBuffer[Tree]
+
+      /** A map from type ref T to "expression of type quoted.Type[T]".
+       *  These will be turned into splices using `addTags`
+       */
+      val typeTagOfRef = new mutable.LinkedHashMap[TypeRef, Tree]()
+
+      /** Assuming typeTagOfRef = `Type1 -> tag1, ..., TypeN -> tagN`, the expression
+       *
+       *      { type <Type1> = <tag1>.unary_~
+       *        ...
+       *        type <TypeN> = <tagN>.unary.~
+       *        <expr>
+       *      }
+       *
+       *  where all references to `TypeI` in `expr` are rewired to point to the locally
+       *  defined versions. As a side effect, append the expressions `tag1, ..., `tagN`
+       *  as splices to `buf`.
+       */
+      def addTags(expr: Tree)(implicit ctx: Context): Tree =
+        if (typeTagOfRef.isEmpty) expr
+        else {
+          val assocs = typeTagOfRef.toList
+          val typeDefs = for ((tp, tag) <- assocs) yield {
+            val original = tp.symbol.asType
+            val rhs = tag.select(tpnme.UNARY_~)
+            val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
+            val local = original.copy(
+              owner = ctx.owner,
+              flags = Synthetic,
+              info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)))
+            ctx.typeAssigner.assignType(untpd.TypeDef(original.name, alias), local)
+          }
+          val (trefs, tags) = assocs.unzip
+          tags ++=: buf
+          typeTagOfRef.clear()
+          Block(typeDefs, expr).subst(trefs.map(_.symbol), typeDefs.map(_.symbol))
+        }
+    }
 
     /** The current staging level */
     private var currentLevel = 0
 
     /** The splices encountered so far, indexed by staging level */
-    private val splicesAtLevel = mutable.ArrayBuffer(new mutable.ListBuffer[Tree])
+    private val splicesAtLevel = mutable.ArrayBuffer(new Splices)
 
     // Invariant: -1 <= currentLevel <= splicesAtLevel.length
 
@@ -54,34 +103,109 @@ class ReifyQuotes extends MacroTransform {
 
     /** Enter staging level of symbol defined by `tree`, if applicable. */
     def markDef(tree: Tree)(implicit ctx: Context) = tree match {
-      case tree: MemberDef if !levelOf.contains(tree.symbol) =>
+      case tree: DefTree if !levelOf.contains(tree.symbol) =>
         levelOf(tree.symbol) = currentLevel
         enteredSyms = tree.symbol :: enteredSyms
       case _ =>
     }
 
-    /** If reference is to a locally defined symbol, check that its staging level
-     *  matches the current level.
+    /** If `tree` refers to a locally defined symbol (either directly, or in a pickled type),
+     *  check that its staging level matches the current level. References to types
+     *  that are phase-incorrect can still be healed as follows.
+     *
+     *  If `T` is a reference to a type at the wrong level, and there is an implicit value `tag`
+     *  of type `quoted.Type[T]`, transform `tag` yielding `tag1` and add the binding `T -> tag1`
+     *   to the `typeTagOfRef` map of the current `Splices` structure. These entries will be turned
+     *  info additional type definitions in method `addTags`.
      */
-    def checkLevel(tree: Tree)(implicit ctx: Context): Unit = {
-
-      def check(sym: Symbol, show: Symbol => String): Unit =
-        if (!sym.isStaticOwner &&
-            !ctx.owner.ownersIterator.exists(_.isInlineMethod) &&
-            levelOf.getOrElse(sym, currentLevel) != currentLevel)
-          ctx.error(em"""access to ${show(sym)} from wrong staging level:
-                        | - the definition is at level ${levelOf(sym)},
-                        | - but the access is at level $currentLevel.""", tree.pos)
-
-      def showThis(sym: Symbol) =
-        if (sym.is(ModuleClass)) sym.sourceModule.show
-        else i"${sym.name}.this"
-
-      val sym = tree.symbol
-      if (sym.exists)
-        if (tree.isInstanceOf[This]) check(sym, showThis)
-        else if (sym.owner.isType) check(sym.owner, showThis)
-        else check(sym, _.show)
+    private def checkLevel(tree: Tree)(implicit ctx: Context): Tree = {
+
+      /** Try to heal phase-inconsistent reference to type `T` using a local type definition.
+       *  @return None      if successful
+       *  @return Some(msg) if unsuccessful where `msg` is a potentially empty error message
+       *                    to be added to the "inconsistent phase" message.
+       */
+      def heal(tp: Type): Option[String] = tp match {
+        case tp: TypeRef =>
+          val reqType = defn.QuotedTypeType.appliedTo(tp)
+          val tag = ctx.typer.inferImplicitArg(reqType, tree.pos)
+          tag.tpe match {
+            case fail: SearchFailureType =>
+              Some(i"""
+                      |
+                      | The access would be accepted with the right type tag, but
+                      | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
+            case _ =>
+              splicesAtLevel(currentLevel).typeTagOfRef(tp) = {
+                currentLevel -= 1
+                try transform(tag) finally currentLevel += 1
+              }
+              None
+          }
+        case _ =>
+          Some("")
+      }
+
+      /** Check reference to `sym` for phase consistency, where `tp` is the underlying type
+       *  by which we refer to `sym`.
+       */
+      def check(sym: Symbol, tp: Type): Unit = {
+        val isThis = tp.isInstanceOf[ThisType]
+        def symStr =
+          if (!isThis) sym.show
+          else if (sym.is(ModuleClass)) sym.sourceModule.show
+          else i"${sym.name}.this"
+        if (!isThis && sym.maybeOwner.isType)
+          check(sym.owner, sym.owner.thisType)
+        else if (sym.exists && !sym.isStaticOwner &&
+                 !ctx.owner.ownersIterator.exists(_.isInlineMethod) &&
+                 levelOf.getOrElse(sym, currentLevel) != currentLevel)
+          heal(tp) match {
+            case Some(errMsg) =>
+              ctx.error(em"""access to $symStr from wrong staging level:
+                            | - the definition is at level ${levelOf(sym)},
+                            | - but the access is at level $currentLevel.$errMsg""", tree.pos)
+            case None =>
+          }
+      }
+
+      /** Check all named types and this types in a given type for phase consistency */
+      object checkType extends TypeAccumulator[Unit] {
+        /** Check that all NamedType and ThisType parts of `tp` are level-correct.
+         *  If they are not, try to heal with a local binding to a typetag splice
+         */
+        def apply(tp: Type): Unit = apply((), tp)
+        def apply(acc: Unit, tp: Type): Unit = reporting.trace(i"check type level $tp at $currentLevel") {
+          tp match {
+            case tp: NamedType if isSplice(tp.symbol) =>
+              currentLevel -= 1
+              try foldOver(acc, tp) finally currentLevel += 1
+            case tp: NamedType =>
+              check(tp.symbol, tp)
+              foldOver(acc, tp)
+            case tp: ThisType =>
+              check(tp.cls, tp)
+              foldOver(acc, tp)
+            case _ =>
+              foldOver(acc, tp)
+          }
+        }
+      }
+
+      tree match {
+        case (_: Ident) | (_: This) =>
+          check(tree.symbol, tree.tpe)
+        case (_: UnApply)  | (_: TypeTree) =>
+          checkType(tree.tpe)
+        case Select(qual, OuterSelectName(_, levels)) =>
+          checkType(tree.tpe.widen)
+        case _: Bind =>
+          checkType(tree.symbol.info)
+        case _: Template =>
+          checkType(tree.symbol.owner.asClass.givenSelfType)
+        case _ =>
+      }
+      tree
     }
 
     /** Turn `body` of quote into a call of `scala.quoted.Unpickler.unpickleType` or
@@ -91,66 +215,64 @@ class ReifyQuotes extends MacroTransform {
      *    - the serialized `body`, as returned from `pickleTree`
      *    - all splices found in `body`
      */
-    private def reifyCall(body: Tree, isType: Boolean)(implicit ctx: Context) =
-      ref(if (isType) defn.Unpickler_unpickleType else defn.Unpickler_unpickleExpr)
-        .appliedToType(if (isType) body.tpe else body.tpe.widen)
-        .appliedTo(
-          Literal(Constant(pickleTree(body, isType))),
-          SeqLiteral(splicesAtLevel(currentLevel).toList, TypeTree(defn.QuotedType)))
-
-    /** Perform operation `op` in quoted context */
-    private def inQuote(op: => Tree)(implicit ctx: Context) = {
+    private def reify(body: Tree, isType: Boolean)(implicit ctx: Context) = {
       currentLevel += 1
       if (currentLevel == splicesAtLevel.length) splicesAtLevel += null
+      val splices = new Splices
       val savedSplices = splicesAtLevel(currentLevel)
-      splicesAtLevel(currentLevel) = new mutable.ListBuffer[Tree]
-      try op
+      splicesAtLevel(currentLevel) = splices
+      try {
+        val body1 = splices.addTags(transform(body))
+        ref(if (isType) defn.Unpickler_unpickleType else defn.Unpickler_unpickleExpr)
+          .appliedToType(if (isType) body1.tpe else body1.tpe.widen)
+          .appliedTo(
+            Literal(Constant(pickleTree(body1, isType))),
+            SeqLiteral(splices.buf.toList, TypeTree(defn.QuotedType)))
+      }
       finally {
         splicesAtLevel(currentLevel) = savedSplices
         currentLevel -= 1
       }
     }
 
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
-      case Apply(fn, arg :: Nil) if fn.symbol == defn.quoteMethod =>
-        inQuote(reifyCall(transform(arg), isType = false))
-      case TypeApply(fn, arg :: Nil) if fn.symbol == defn.typeQuoteMethod =>
-        inQuote(reifyCall(transform(arg), isType = true))
-      case tree @ Select(body, name) if isSplice(tree) =>
-        currentLevel -= 1
-        val body1 = try transform(body) finally currentLevel += 1
-        if (currentLevel > 0) {
-          splicesAtLevel(currentLevel) += body1
-          tree
-        }
-        else {
-          if (currentLevel < 0)
-            ctx.error(i"splice ~ not allowed under toplevel splice", tree.pos)
-          cpy.Select(tree)(body1, name)
+    override def transform(tree: Tree)(implicit ctx: Context): Tree =
+      reporting.trace(i"reify $tree at $currentLevel", show = true) {
+        tree match {
+          case Apply(fn, arg :: Nil) if fn.symbol == defn.quoteMethod =>
+            reify(arg, isType = false)
+          case TypeApply(fn, arg :: Nil) if fn.symbol == defn.typeQuoteMethod =>
+            reify(arg, isType = true)
+          case tree @ Select(body, name) if isSplice(tree.symbol) =>
+            currentLevel -= 1
+            val body1 = try transform(body) finally currentLevel += 1
+            if (currentLevel > 0) {
+              splicesAtLevel(currentLevel).buf += body1
+              tree
+            }
+            else {
+              if (currentLevel < 0)
+                ctx.error(i"splice ~ not allowed under toplevel splice", tree.pos)
+              cpy.Select(tree)(body1, name)
+            }
+          case Block(stats, _) =>
+            val last = enteredSyms
+            stats.foreach(markDef)
+            try super.transform(tree)
+            finally
+              while (enteredSyms ne last) {
+                levelOf -= enteredSyms.head
+                enteredSyms = enteredSyms.tail
+              }
+          case Inlined(call, bindings, expansion @ Select(body, name)) if isSplice(expansion.symbol) =>
+            // To maintain phase consistency, convert inlined expressions of the form
+            // `{ bindings; ~expansion }` to `~{ bindings; expansion }`
+            cpy.Select(expansion)(cpy.Inlined(tree)(call, bindings, body), name)
+          case _: Import =>
+            tree
+          case _ =>
+            markDef(tree)
+            checkLevel(super.transform(tree))
         }
-      case (_: Ident) | (_: This) =>
-        checkLevel(tree)
-        super.transform(tree)
-      case _: MemberDef =>
-        markDef(tree)
-        super.transform(tree)
-      case Block(stats, _) =>
-        val last = enteredSyms
-        stats.foreach(markDef)
-        try super.transform(tree)
-        finally
-          while (enteredSyms ne last) {
-            levelOf -= enteredSyms.head
-            enteredSyms = enteredSyms.tail
-          }
-      case Inlined(call, bindings, expansion @ Select(body, name)) if isSplice(expansion) =>
-        // To maintain phase consistency, convert inlined expressions of the form
-        // `{ bindings; ~expansion }` to `~{ bindings; expansion }`
-        cpy.Select(expansion)(cpy.Inlined(tree)(call, bindings, body), name)
-      case _: Import =>
-        tree
-      case _ =>
-        super.transform(tree)
-    }
+      }
   }
 }
diff --git a/tests/neg/quoteTest.scala b/tests/neg/quoteTest.scala
@@ -13,4 +13,9 @@ class Test {
   '(x + 1)  // error: wrong staging level
 
   '((y: Expr[Int]) => ~y )  // error: wrong staging level
+
+  def f[T](t: Type[T], x: Expr[T]) = '{
+    val z2 = ~x   // error: wrong staging level for type T
+  }
+
 }
diff --git a/tests/pos/quoteTest.scala b/tests/pos/quoteTest.scala
@@ -2,14 +2,23 @@ import scala.quoted._
 
 object Test {
 
-  def f[T](t: Type[T], x: Expr[T]) = '{
+  def f[T](x: Expr[T])(t0: Type[T]) = {
+    implicit val t: Type[T] = t0
+    '{
+      val y: t.unary_~ = x.unary_~
+      val z = ~x
+    }
+  }
+
+  def f2[T](x: Expr[T])(implicit t: Type[T]) = '{
     val y: t.unary_~ = x.unary_~
-    val z: ~t = ~x
+    val z = ~x
   }
 
-  f('[Int], '(2))
-  f('[Boolean], '{ true })
+  f('(2))('[Int])
+   f('{ true })('[Boolean])
 
   def g(es: Expr[String], t: Type[String]) =
-    f('[List[~t]], '{ (~es + "!") :: Nil })
+    f('{ (~es + "!") :: Nil })('[List[~t]])
 }
+

Original file line number	Diff line number	Diff line change
`@@ -13,4 +13,9 @@ class Test {`
`13`	`13`	`'(x + 1) // error: wrong staging level`
`14`	`14`
`15`	`15`	`'((y: Expr[Int]) => ~y ) // error: wrong staging level`
	`16`	`+`
	`17`	`+ def f[T](t: Type[T], x: Expr[T]) = '{`
	`18`	`+ val z2 = ~x // error: wrong staging level for type T`
	`19`	`+ }`
	`20`	`+`
`16`	`21`	`}`