remove dead code

Author: nicolasstucki

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

@@ -412,7 +412,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         else if (body.symbol == defn.DoubleClass) tag("DoubleTag")
         else pickleAsTasty()
       }
-      else Staging.toValue(body) match {
+      else toValue(body) match {
         case Some(value) => pickleAsValue(value)
         case _ => pickleAsTasty()
       }

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

@@ -93,7 +93,7 @@ class Staging extends MacroTransformWithImplicits {
     if (ctx.compilationUnit.needsStaging) super.run
 
   protected def newTransformer(implicit ctx: Context): Transformer =
-    new Reifier(inQuote = false, null, 0, new LevelInfo, new Embedded, ctx)
+    new Reifier(inQuote = false, null, 0, new LevelInfo, ctx)
 
   private class LevelInfo {
     /** A map from locally defined symbols to the staging levels of their definitions */
@@ -110,15 +110,14 @@ class Staging extends MacroTransformWithImplicits {
    *  @param  embedded   a list of embedded quotes (if `inSplice = true`) or splices (if `inQuote = true`
    *  @param  rctx       the contex in the destination lifted lambda
    */
-  private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo,
-                        val embedded: Embedded, val rctx: Context) extends ImplicitsTransformer {
+  private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo, val rctx: Context)
+      extends ImplicitsTransformer {
     import levels._
     assert(level >= -1)
 
     /** A nested reifier for a quote (if `isQuote = true`) or a splice (if not) */
     def nested(isQuote: Boolean)(implicit ctx: Context): Reifier = {
-      val nestedEmbedded = if (level > 1 || (level == 1 && isQuote)) embedded else new Embedded
-      new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, nestedEmbedded, ctx)
+      new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, ctx)
     }
 
     /** A map from type ref T to expressions of type `quoted.Type[T]`".
@@ -130,106 +129,6 @@ class Staging extends MacroTransformWithImplicits {
     /** A stack of entered symbols, to be unwound after scope exit */
     var enteredSyms: List[Symbol] = Nil
 
-    /** Assuming importedTags = `Type1 -> tag1, ..., TypeN -> tagN`, the expression
-     *
-     *      { type <Type1> = <tag1>.unary_~
-     *        ...
-     *        type <TypeN> = <tagN>.unary_~
-     *        <expr>
-     *      }
-     *
-     *  references to `TypeI` in `expr` are rewired to point to the locally
-     *  defined versions. As a side effect, prepend the expressions `tag1, ..., `tagN`
-     *  as splices to `embedded`.
-     */
-    private def addTags(expr: Tree)(implicit ctx: Context): Tree = {
-
-      if (importedTags.isEmpty) expr
-      else {
-        val itags = importedTags.toList
-        // The tree of the tag for each tag comes from implicit search in `tryHeal`
-        val healedTypes = for ((tref, tag) <- itags) yield {
-          tag.select(tpnme.UNARY_~)
-        }
-        importedTags.clear()
-
-        // Maps type splices to type references of tags e.g., ~t -> some type T$1
-        val map: Map[Type, Tree] = {
-          (itags.map(_._1) zip healedTypes)
-        }.toMap
-        val tpMap = new TypeMap() {
-          override def apply(tp: Type): Type = map.get(tp).fold(mapOver(tp))(_.tpe)
-        }
-
-        def trMap(tree: Tree): Tree =
-          if (tree.isType) map.getOrElse(tree.tpe, tree)
-          else tree
-
-
-        /** 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.isSplice).unzip // TODO Syntetic is probably not enugh to distinguish added types
-
-              new TreeTypeMap(
-                oldOwners = oldOwners, newOwners = newOwners,
-                substFrom = sFrom, substTo = sTo
-              ).transform(tree)
-            }
-            else
-            if (tree.symbol.isSplice) {
-              level -= 1
-              try {
-                val tr = super.transform(tree)
-                if (tr.isType) tr
-                else {
-                  // Make sure that the tags are not used inside the splice
-                  // and that the non aliased type does not escape the splice
-                  val tp = tpMap(tr.tpe.widenTermRefExpr)
-                  tr.withType(tree.tpe) // FIXME tp may need tranfomation. Revert diff in tests/run/gestalt-optional-staging/Macro_1.scala
-                }
-              }
-              //
-              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
-            }
-          }
-        }
-
-        new QuoteTreeTypeMap(
-            treeMap = trMap,
-            typeMap = tpMap,
-            substFrom = itags.map(_._1.symbol),
-            substTo = healedTypes.map(_.symbol)
-        ).apply(expr)
-      }
-    }
-
     /** Enter staging level of symbol defined by `tree`, if applicable. */
     def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
       case tree: DefTree =>
@@ -401,7 +300,7 @@ class Staging extends MacroTransformWithImplicits {
         if (isType) ref(defn.QuotedType_apply).appliedToType(body1.tpe.widen)
         else ref(defn.QuotedExpr_apply).appliedToType(body1.tpe.widen).appliedTo(body1)
       } else {
-        val body1 = nested(isQuote = true).transformAndAddTags(body)
+        val body1 = nested(isQuote = true).transform(body)
         if (level == 0 && !ctx.inInlineMethod) {
           quote match {
             case quote: Apply => cpy.Apply(quote)(quote.fun, body1 :: Nil)
@@ -445,13 +344,6 @@ class Staging extends MacroTransformWithImplicits {
       }
     }
 
-    /** Transform `tree` followed by `addTags` transform. */
-    private def transformAndAddTags(tree: Tree)(implicit ctx: Context): Tree = {
-      assert(inQuote)
-//      addTags(transform(tree))
-      transform(tree)
-    }
-
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       reporting.trace(i"reify $tree at $level", show = true) {
         def mapOverTree(lastEntered: List[Symbol]) =
@@ -547,40 +439,5 @@ class Staging extends MacroTransformWithImplicits {
 }
 
 object Staging {
-  import tpd._
-
   val name: String = "staging"
-
-  def toValue(tree: tpd.Tree): Option[Any] = tree match {
-    case Literal(Constant(c)) => Some(c)
-    case Block(Nil, e) => toValue(e)
-    case Inlined(_, Nil, e) => toValue(e)
-    case _ => None
-  }
-
-  class Embedded(trees: mutable.ListBuffer[tpd.Tree] = mutable.ListBuffer.empty, map: mutable.Map[Symbol, tpd.Tree] = mutable.Map.empty) {
-    /** Adds the tree and returns it's index */
-    def addTree(tree: tpd.Tree, liftedSym: Symbol): Int = {
-      trees += tree
-      if (liftedSym ne NoSymbol)
-        map.put(liftedSym, tree)
-      trees.length - 1
-    }
-
-    /** Type used for the hole that will replace this splice */
-    def getHoleType(splice: tpd.Select)(implicit ctx: Context): Type = {
-      // For most expressions the splice.tpe but there are some types that are lost by lifting
-      // that can be recoverd from the original tree. Currently the cases are:
-      //  * Method types: the splice represents a method reference
-      map.get(splice.qualifier.symbol).map(_.tpe.widen).getOrElse(splice.tpe)
-    }
-
-    def isLiftedSymbol(sym: Symbol)(implicit ctx: Context): Boolean = map.contains(sym)
-
-    /** Get the list of embedded trees */
-    def getTrees: List[tpd.Tree] = trees.toList
-
-    override def toString: String = s"Embedded($trees, $map)"
-
-  }
 }