Change reify for types

We now keep the (type-) trees and proceed as with normal reification. This
saves us the trouble of having to define a separate pickler for types with splices
in them.

Author: odersky

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

@@ -93,4 +93,7 @@ object Mode {
 
   /** We are in the IDE */
   val Interactive = newMode(20, "Interactive")
+
+  /** We are in a quoted type during the ReifyQuotes phase */
+  val InQuotedType = newMode(21, "InQuotedType")
 }

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -188,19 +188,20 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
     ast.Trees.flatten(reorderAndComplete(trees)(ctx.withPhase(thisPhase.next)))
 
+  private def toTypeTree(tree: Tree)(implicit ctx: Context) =
+    if (ctx.mode.is(Mode.InQuotedType)) tree else TypeTree(tree.tpe).withPos(tree.pos)
+    
   override def transformOther(tree: Tree)(implicit ctx: Context) = tree match {
     case tree: Import => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree => if (tree.isType) TypeTree(tree.tpe).withPos(tree.pos) else tree
+    case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
   override def transformIdent(tree: Ident)(implicit ctx: Context) =
-    if (tree.isType) TypeTree(tree.tpe).withPos(tree.pos)
-    else constToLiteral(tree)
+    if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
 
   override def transformSelect(tree: Select)(implicit ctx: Context) =
-    if (tree.isType) TypeTree(tree.tpe).withPos(tree.pos)
-    else constToLiteral(tree)
+    if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
 
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context) =
     constToLiteral(tree)

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -9,59 +9,60 @@ import MegaPhase.MiniPhase
 import scala.collection.mutable
 
 /** Translates quoted terms and types to reify method calls.
+ *  The mini phase needs to run in the same group as FirstTransform. So far we lack
+ *  the machinery to express this constraint in code.
  */
 class ReifyQuotes extends MiniPhase {
   import ast.tpd._
 
   override def phaseName: String = "reifyQuotes"
 
-  def reifyTree(tree: Tree)(implicit ctx: Context): String = i"($tree)" // TODO: replace with TASTY
-  def reifyType(tpe: Type)(implicit ctx: Context): String = i"[$tpe]"   // TODO: replace with TASTY
+  /** Serialize `tree`. Embedded splices are represented as nodes of the form
+   *
+   *      Select(qual, sym)
+   *
+   *  where `sym` is either `defn.MetaExpr_~` or `defn.MetaType_~`. For any splice,
+   *  the `qual` part will be of the form `Typed(EmptyTree, TypeTree(<underlying type>))`,
+   *  but that knowledge is not needed to uniquely identify a splice node.
+   */
+  def reifyTree(tree: Tree)(implicit ctx: Context): String = tree.show // TODO: replace with TASTY
 
-  private def reifyCall(meth: Symbol, typeArg: Type, reified: String, splices: List[Tree])(implicit ctx: Context) =
-    ref(meth)
-      .appliedToType(typeArg)
-      .appliedTo(
-        Literal(Constant(reified)),
-        SeqLiteral(splices, TypeTree(defn.MetaExprType.appliedTo(TypeBounds.empty))))
+  private def reifyCall(body: Tree, isType: Boolean)(implicit ctx: Context) = {
 
-  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
     object liftSplices extends TreeMap {
       val splices = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
-        case tree @ Select(qual, name) if tree.symbol == defn.MetaExpr_~ =>
+        case tree @ Select(qual, name)
+        if tree.symbol == defn.MetaExpr_~ || tree.symbol == defn.MetaType_~ =>
           splices += qual
           val placeHolder = Typed(EmptyTree, TypeTree(qual.tpe.widen))
           cpy.Select(tree)(placeHolder, name)
         case _ =>
           super.transform(tree)
       }
     }
-    if (tree.fun.symbol == defn.quoteMethod) {
-      val body = tree.args.head
-      val reified = reifyTree(liftSplices.transform(body))
-      reifyCall(defn.Reifier_reifyExpr, body.tpe.widen, reified, liftSplices.splices.toList)
-    }
-    else tree
+
+    val reified = reifyTree(liftSplices.transform(body))
+    var splices = liftSplices.splices.toList
+    if (isType) // transform splices again because embedded type trees were not rewritten before
+      splices = splices.map(transformAllDeep(_)(ctx.retractMode(Mode.InQuotedType)))
+    val spliceType = if (isType) defn.MetaTypeType else defn.MetaExprType
+
+    ref(if (isType) defn.Reifier_reifyType else defn.Reifier_reifyExpr)
+      .appliedToType(if (isType) body.tpe else body.tpe.widen)
+      .appliedTo(
+        Literal(Constant(reified)),
+        SeqLiteral(splices, TypeTree(spliceType.appliedTo(TypeBounds.empty))))
   }
 
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = {
-    object liftSplices extends TypeMap {
-      val splices = new mutable.ListBuffer[Tree]
-      override def apply(t: Type) = t match {
-        case t @ TypeRef(pre: TermRef, _) if t.symbol == defn.MetaType_~ =>
-          splices += ref(pre).withPos(tree.args.head.pos)
-          val placeHolder = SkolemType(pre.widen)
-          t.withPrefix(placeHolder)
-        case _ =>
-          mapOver(t)
-      }
-    }
-    if (tree.fun.symbol == defn.typeQuoteMethod) {
-      val body = tree.args.head.tpe
-      val reified = reifyType(liftSplices(body))
-      reifyCall(defn.Reifier_reifyType, body, reified, liftSplices.splices.toList)
-    }
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
+    if (tree.fun.symbol == defn.quoteMethod) reifyCall(tree.args.head, isType = false)
     else tree
-  }
-}
+
+  override def prepareForTypeApply(tree: TypeApply)(implicit ctx: Context): Context =
+    if (tree.symbol == defn.typeQuoteMethod) ctx.addMode(Mode.InQuotedType) else ctx
+
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
+    if (tree.fun.symbol == defn.typeQuoteMethod) reifyCall(tree.args.head, isType = true)
+    else tree
+}

library/src/scala/meta/Reifier.scala

@@ -4,6 +4,6 @@ object Reifier {
 
   def reifyExpr[T](repr: String, args: Seq[Expr[_]]): Expr[T] = ???
 
-  def reifyType[T](repr: String, args: Seq[Expr[_]]): Type[T] = ???
+  def reifyType[T](repr: String, args: Seq[Type[_]]): Type[T] = ???
 
 }