Delete propagateType and RetypingTreeMap

Their functionality is now rolled into TypedTreeCopier.

Author: odersky

src/dotty/tools/dotc/ast/tpd.scala

@@ -508,68 +508,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def tpes: List[Type] = xs map (_.tpe)
   }
 
-  /** RetypingTreeMap is a TreeMap that is able to propagate type changes.
-   *
-   *   This is required when types can change during transformation,
-   *   for example if `Block(stats, expr)` is being transformed
-   *   and type of `expr` changes from `TypeRef(prefix, name)` to  `TypeRef(newPrefix, name)` with different prefix, t
-   *   type of enclosing Block should also change, otherwise the whole tree would not be type-correct anymore.
-   *   see `propagateType` methods for propagation rulles.
-   *
-   *   TreeMap does not include such logic as it assumes that types of threes do not change during transformation.
-   */
-  class RetypingTreeMap extends TreeMap {
-
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
-      case tree@Select(qualifier, name) =>
-        val tree1 = cpy.Select(tree)(transform(qualifier), name)
-        propagateType(tree, tree1)
-      case tree@Pair(left, right) =>
-        val left1 = transform(left)
-        val right1 = transform(right)
-        val tree1 = cpy.Pair(tree)(left1, right1)
-        propagateType(tree, tree1)
-      case tree@Block(stats, expr) =>
-        val stats1 = transform(stats)
-        val expr1 = transform(expr)
-        val tree1 = cpy.Block(tree)(stats1, expr1)
-        propagateType(tree, tree1)
-      case tree@If(cond, thenp, elsep) =>
-        val cond1 = transform(cond)
-        val thenp1 = transform(thenp)
-        val elsep1 = transform(elsep)
-        val tree1 = cpy.If(tree)(cond1, thenp1, elsep1)
-        propagateType(tree, tree1)
-      case tree@Match(selector, cases) =>
-        val selector1 = transform(selector)
-        val cases1 = transformSub(cases)
-        val tree1 = cpy.Match(tree)(selector1, cases1)
-        propagateType(tree, tree1)
-      case tree@CaseDef(pat, guard, body) =>
-        val pat1 = transform(pat)
-        val guard1 = transform(guard)
-        val body1 = transform(body)
-        val tree1 = cpy.CaseDef(tree)(pat1, guard1, body1)
-        propagateType(tree, tree1)
-      case tree@Try(block, handler, finalizer) =>
-        val expr1 = transform(block)
-        val handler1 = transform(handler)
-        val finalizer1 = transform(finalizer)
-        val tree1 = cpy.Try(tree)(expr1, handler1, finalizer1)
-        propagateType(tree, tree1)
-      case tree@SeqLiteral(elems) =>
-        val elems1 = transform(elems)
-        val tree1 = cpy.SeqLiteral(tree)(elems1)
-        propagateType(tree, tree1)
-      case tree@Annotated(annot, arg) =>
-        val annot1 = transform(annot)
-        val arg1 = transform(arg)
-        val tree1 = cpy.Annotated(tree)(annot1, arg1)
-        propagateType(tree, tree1)
-      case _ => super.transform(tree)
-    }
-  }
-
   /** A map that applies three functions together to a tree and makes sure
    *  they are coordinated so that the result is well-typed. The functions are
    *  @param  typeMap  A function from Type to type that gets applied to the
@@ -582,7 +520,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   final class TreeTypeMap(
       val typeMap: Type => Type = IdentityTypeMap,
       val ownerMap: Symbol => Symbol = identity _,
-      val treeMap: Tree => Tree = identity _)(implicit ctx: Context) extends RetypingTreeMap {
+      val treeMap: Tree => Tree = identity _)(implicit ctx: Context) extends TreeMap {
 
     override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
       val tree1 = treeMap(tree)
@@ -594,15 +532,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         case blk @ Block(stats, expr) =>
           val (tmap1, stats1) = transformDefs(stats)
           val expr1 = tmap1.transform(expr)
-          val tree1 = cpy.Block(blk)(stats1, expr1)
-          propagateType(blk, tree1)
+          cpy.Block(blk)(stats1, expr1)
         case cdef @ CaseDef(pat, guard, rhs) =>
           val tmap = withMappedSyms(patVars(pat))
           val pat1 = tmap.transform(pat)
           val guard1 = tmap.transform(guard)
           val rhs1 = tmap.transform(rhs)
-          val tree1 = cpy.CaseDef(tree)(pat1, guard1, rhs1)
-          propagateType(cdef, tree1)
+          cpy.CaseDef(tree)(pat1, guard1, rhs1)
         case tree1 =>
           super.transform(tree1)
       }
@@ -664,56 +600,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     acc(Nil, tree)
   }
 
-  def propagateType(origTree: Pair, newTree: Pair)(implicit ctx: Context) = {
-    if ((newTree eq origTree) ||
-      ((newTree.left.tpe eq origTree.left.tpe) && (newTree.right.tpe eq origTree.right.tpe))) newTree
-    else ta.assignType(newTree, newTree.left, newTree.right)
-  }
-
-  def propagateType(origTree: Block, newTree: Block)(implicit ctx: Context) = {
-    if ((newTree eq origTree) || (newTree.expr.tpe eq origTree.expr.tpe)) newTree
-    else ta.assignType(newTree, newTree.stats, newTree.expr)
-  }
-
-  def propagateType(origTree: If, newTree: If)(implicit ctx: Context) = {
-    if ((newTree eq origTree) ||
-      ((newTree.thenp.tpe eq origTree.thenp.tpe) && (newTree.elsep.tpe eq origTree.elsep.tpe))) newTree
-    else ta.assignType(newTree, newTree.thenp, newTree.elsep)
-  }
-
-  def propagateType(origTree: Match, newTree: Match)(implicit ctx: Context) = {
-    if ((newTree eq origTree) || sameTypes(newTree.cases, origTree.cases)) newTree
-    else ta.assignType(newTree, newTree.cases)
-  }
-
-  def propagateType(origTree: CaseDef, newTree: CaseDef)(implicit ctx: Context) = {
-    if ((newTree eq newTree) || (newTree.body.tpe eq origTree.body.tpe)) newTree
-    else ta.assignType(newTree, newTree.body)
-  }
-
-  def propagateType(origTree: Try, newTree: Try)(implicit ctx: Context) = {
-    if ((newTree eq origTree) ||
-      ((newTree.expr.tpe eq origTree.expr.tpe) && (newTree.handler.tpe eq origTree.handler.tpe))) newTree
-    else ta.assignType(newTree, newTree.expr, newTree.handler)
-  }
-
-  def propagateType(origTree: SeqLiteral, newTree: SeqLiteral)(implicit ctx: Context) = {
-    if ((newTree eq origTree) || sameTypes(newTree.elems, origTree.elems)) newTree
-    else ta.assignType(newTree, newTree.elems)
-  }
-
-  def propagateType(origTree: Annotated, newTree: Annotated)(implicit ctx: Context) = {
-    if ((newTree eq origTree) || ((newTree.arg.tpe eq origTree.arg.tpe) && (newTree.annot eq origTree.annot))) newTree
-    else ta.assignType(newTree, newTree.annot, newTree.arg)
-  }
-
-  def propagateType(origTree: Select, newTree: Select)(implicit ctx: Context) = {
-    if ((origTree eq newTree) || (origTree.qualifier.tpe eq newTree.qualifier.tpe)) newTree
-    else newTree.tpe match {
-      case tpe: NamedType => newTree.withType(tpe.derivedSelect(newTree.qualifier.tpe))
-      case _ => newTree
-    }
-  }
   // convert a numeric with a toXXX method
   def primitiveConversion(tree: Tree, numericCls: Symbol)(implicit ctx: Context): Tree = {
     val mname      = ("to" + numericCls.name).toTermName

src/dotty/tools/dotc/transform/TailRec.scala

@@ -126,7 +126,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
 
   }
 
-  class TailRecElimination(method: Symbol, enclosingClass: Symbol, thisType: Type, isMandatory: Boolean, label: Symbol) extends tpd.RetypingTreeMap {
+  class TailRecElimination(method: Symbol, enclosingClass: Symbol, thisType: Type, isMandatory: Boolean, label: Symbol) extends tpd.TreeMap {
 
     import dotty.tools.dotc.ast.tpd._
 
@@ -257,34 +257,29 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
       val res: Tree = tree match {
 
         case tree@Block(stats, expr) =>
-          val tree1 = tpd.cpy.Block(tree)(
+          tpd.cpy.Block(tree)(
             noTailTransforms(stats),
             transform(expr)
           )
-          propagateType(tree, tree1)
 
         case tree@CaseDef(_, _, body) =>
-          val tree1 = cpy.CaseDef(tree)(body = transform(body))
-          propagateType(tree, tree1)
+          cpy.CaseDef(tree)(body = transform(body))
 
         case tree@If(cond, thenp, elsep) =>
-          val tree1 = tpd.cpy.If(tree)(
+          tpd.cpy.If(tree)(
             noTailTransform(cond),
             transform(thenp),
             transform(elsep)
           )
-          propagateType(tree, tree1)
 
         case tree@Match(selector, cases) =>
-          val tree1 = tpd.cpy.Match(tree)(
+          tpd.cpy.Match(tree)(
             noTailTransform(selector),
             transformSub(cases)
           )
-          propagateType(tree, tree1)
 
         case tree: Try =>
-          val tree1 = rewriteTry(tree)
-          propagateType(tree, tree1)
+          rewriteTry(tree)
 
         case Apply(fun, args) if fun.symbol == defn.Boolean_|| || fun.symbol == defn.Boolean_&& =>
           tpd.cpy.Apply(tree)(fun, transform(args))
@@ -299,7 +294,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
         case tree: Select =>
           val sym = tree.symbol
           if (sym == method && ctx.tailPos) rewriteApply(tree, sym)
-          else propagateType(tree, tpd.cpy.Select(tree)(noTailTransform(tree.qualifier), tree.name))
+          else tpd.cpy.Select(tree)(noTailTransform(tree.qualifier), tree.name)
 
         case ValDef(_, _, _, _) | EmptyTree | Super(_, _) | This(_) |
              Literal(_) | TypeTree(_) | DefDef(_, _, _, _, _, _) | TypeDef(_, _, _) =>