Rename reify -> unpickle

Also, add test

Author: odersky

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

@@ -602,8 +602,8 @@ class Definitions {
     def MetaType_~(implicit ctx: Context) =
       MetaTypeClass.info.member(tpnme.UNARY_~).symbol.asType
 
-  def Reifier_reifyExpr = ctx.requiredMethod("scala.meta.Reifier.reifyExpr")
-  def Reifier_reifyType = ctx.requiredMethod("scala.meta.Reifier.reifyType")
+  def Unpickler_unpickleExpr = ctx.requiredMethod("scala.meta.Unpickler.unpickleExpr")
+  def Unpickler_unpickleType = ctx.requiredMethod("scala.meta.Unpickler.unpickleType")
 
   lazy val EqType = ctx.requiredClassRef("scala.Eq")
   def EqClass(implicit ctx: Context) = EqType.symbol.asClass

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

@@ -25,7 +25,8 @@ class ReifyQuotes extends MiniPhase {
    *  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
+  def pickleTree(tree: Tree, isType: Boolean)(implicit ctx: Context): String =
+    tree.show // TODO: replace with TASTY
 
   private def reifyCall(body: Tree, isType: Boolean)(implicit ctx: Context) = {
 
@@ -34,21 +35,23 @@ class ReifyQuotes extends MiniPhase {
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
         case tree @ Select(qual, name)
         if tree.symbol == defn.MetaExpr_~ || tree.symbol == defn.MetaType_~ =>
-          splices += qual
+          splices += {
+            if (isType) // transform splice again because embedded type trees were not rewritten before
+              transformAllDeep(qual)(ctx.retractMode(Mode.InQuotedType))
+            else qual
+          }
           val placeHolder = Typed(EmptyTree, TypeTree(qual.tpe.widen))
           cpy.Select(tree)(placeHolder, name)
         case _ =>
           super.transform(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 reified = pickleTree(liftSplices.transform(body), isType)
+    val splices = liftSplices.splices.toList
     val spliceType = if (isType) defn.MetaTypeType else defn.MetaExprType
 
-    ref(if (isType) defn.Reifier_reifyType else defn.Reifier_reifyExpr)
+    ref(if (isType) defn.Unpickler_unpickleType else defn.Unpickler_unpickleExpr)
       .appliedToType(if (isType) body.tpe else body.tpe.widen)
       .appliedTo(
         Literal(Constant(reified)),

library/src/scala/meta/Reifier.scala

@@ -0,0 +1,20 @@
+package scala.meta
+
+/** Provides methods to unpickle `Expr` and `Type` trees. */
+object Unpickler {
+
+  /** Representation of pickled trees. For now it's String, but it
+   *  should be changed to some kind of TASTY bundle.
+   */
+  type Pickled = String
+
+  /** Unpickle `repr` which represents a pickled `Expr` tree,
+   *  replacing splice nodes with `args`
+   */
+  def unpickleExpr[T](repr: Pickled, args: Seq[Expr[_]]): Expr[T] = ???
+
+  /** Unpickle `repr` which represents a pickled `Type` tree,
+   *  replacing splice nodes with `args`
+   */
+  def unpickleType[T](repr: Pickled, args: Seq[Type[_]]): Type[T] = ???
+}

library/src/scala/meta/Unpickler.scala

@@ -0,0 +1,15 @@
+import scala.meta._
+
+object Test {
+
+  def f[T](t: Type[T], x: Expr[T]) = {
+    val y: t.unary_~ = x.unary_~
+    val z: ~t = ~x
+  }
+
+  f('[Int], '(2))
+  f('[Boolean], '{ true })
+
+  def g(es: Expr[String], t: Type[String]) =
+    f('[List[~t]], '{ (~es + "!") :: Nil })
+}