Replace tree.withName with {tpd|untpd}.rename.tree

Advantage: Can rename typed as well as untyped trees.

5 files changed, 28 insertions, 18 deletions

diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index b63f0ad8c..19f52b08f 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -408,7 +408,6 @@ object Trees {
   abstract class NameTree[-T >: Untyped] extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] <: NameTree[T]
     def name: Name
-    def withName(name1: Name)(implicit ctx: Context): untpd.NameTree
   }
 
   /** Tree refers by name to a denotation */
@@ -449,7 +448,6 @@ object Trees {
   case class Ident[-T >: Untyped] private[ast] (name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Ident[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.Ident = untpd.cpy.Ident(this)(name)
     def qualifier: Tree[T] = genericEmptyTree
   }
 
@@ -460,7 +458,6 @@ object Trees {
   case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Select[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.Select = untpd.cpy.Select(this)(qualifier, name)
   }
 
   class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -656,7 +653,6 @@ object Trees {
   case class SelectFromTypeTree[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = SelectFromTypeTree[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.SelectFromTypeTree = untpd.cpy.SelectFromTypeTree(this)(qualifier, name)
   }
 
   /** left & right */
@@ -702,7 +698,6 @@ object Trees {
     extends NameTree[T] with DefTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = Bind[T]
     override def envelope: Position = pos union initialPos
-    def withName(name: Name)(implicit ctx: Context): untpd.Bind = untpd.cpy.Bind(this)(name, body)
   }
 
   /** tree_1 | ... | tree_n */
@@ -734,7 +729,6 @@ object Trees {
   case class ValDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TermName, tpt: Tree[T], rhs: Tree[T])
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = ValDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.ValDef = untpd.cpy.ValDef(this)(name = name.toTermName)
     assert(isEmpty || tpt != genericEmptyTree)
   }
 
@@ -742,7 +736,6 @@ object Trees {
   case class DefDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TermName, tparams: List[TypeDef[T]], vparamss: List[List[ValDef[T]]], tpt: Tree[T], rhs: Tree[T])
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.DefDef = untpd.cpy.DefDef(this)(name = name.toTermName)
     assert(tpt != genericEmptyTree)
   }
 
@@ -754,7 +747,6 @@ object Trees {
   case class TypeDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TypeName, rhs: Tree[T])
     extends MemberDef[T] {
     type ThisTree[-T >: Untyped] = TypeDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.TypeDef = untpd.cpy.TypeDef(this)(name = name.toTypeName)
 
     /** Is this a definition of a class? */
     def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -1361,6 +1353,19 @@ object Trees {
         else foldOver(x1, tree)
       }
     }
+
+    def rename(tree: NameTree, newName: Name)(implicit ctx: Context): tree.ThisTree[T] = {
+      tree match {
+        case tree: Ident => cpy.Ident(tree)(newName)
+        case tree: Select => cpy.Select(tree)(tree.qualifier, newName)
+        case tree: Bind => cpy.Bind(tree)(newName, tree.body)
+        case tree: ValDef => cpy.ValDef(tree)(name = newName.asTermName)
+        case tree: DefDef => cpy.DefDef(tree)(name = newName.asTermName)
+        case tree: TypeDef => cpy.TypeDef(tree)(name = newName.asTypeName)
+        case tree: SelectFromTypeTree => cpy.SelectFromTypeTree(tree)(tree.qualifier, newName)
+        case tree: untpd.PolyTypeDef => untpd.cpy.PolyTypeDef(tree)(tree.mods, newName.asTypeName, tree.tparams, tree.rhs)
+      }
+    }.asInstanceOf[tree.ThisTree[T]]
   }
 }
   // ----- Helper functions and classes ---------------------------------------
diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index 9ac01df9c..731917c42 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -58,9 +58,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree) extends DefTree
 
   class PolyTypeDef(mods: Modifiers, name: TypeName, override val tparams: List[TypeDef], rhs: Tree)
-    extends TypeDef(mods, name, rhs) {
-    override def withName(name: Name)(implicit ctx: Context) = cpy.PolyTypeDef(this)(mods, name.toTypeName, tparams, rhs)
-  }
+    extends TypeDef(mods, name, rhs)
 
   // ----- TypeTrees that refer to other tree's symbols -------------------
 
@@ -414,4 +412,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         super.foldOver(x, tree)
     }
   }
+
+  override def rename(tree: NameTree, newName: Name)(implicit ctx: Context): tree.ThisTree[Untyped] = tree match {
+    case t: PolyTypeDef =>
+      cpy.PolyTypeDef(t)(t.mods, newName.asTypeName, t.tparams, t.rhs).asInstanceOf[tree.ThisTree[Untyped]]
+    case _ => super.rename(tree, newName)
+  }
 }
diff --git a/src/dotty/tools/dotc/transform/CapturedVars.scala b/src/dotty/tools/dotc/transform/CapturedVars.scala
index f13cd5690..59a766819 100644
--- a/src/dotty/tools/dotc/transform/CapturedVars.scala
+++ b/src/dotty/tools/dotc/transform/CapturedVars.scala
@@ -17,13 +17,13 @@ import SymUtils._
 import collection.{ mutable, immutable }
 import collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
 
-class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransform =>
   import ast.tpd._
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "capturedVars"
 
-  override def treeTransformPhase = thisTransformer.next
+  override def treeTransformPhase = thisTransform.next
 
   private var captured: mutable.HashSet[Symbol] = _
 
@@ -64,7 +64,7 @@ class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransfor
   }
 
   def capturedType(vble: Symbol)(implicit ctx: Context): Type = {
-    val oldInfo = vble.denot(ctx.withPhase(thisTransformer)).info
+    val oldInfo = vble.denot(ctx.withPhase(thisTransform)).info
     refCls(oldInfo.classSymbol, vble.isVolatile).typeRef
   }
 
@@ -86,7 +86,7 @@ class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransfor
   override def transformIdent(id: Ident)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val vble = id.symbol
     if (captured(vble))
-      (id select nme.elem).ensureConforms(vble.denot(ctx.withPhase(thisTransformer)).info)
+      (id select nme.elem).ensureConforms(vble.denot(ctx.withPhase(thisTransform)).info)
     else id
   }
 
diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 2ff116f46..77298e610 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -594,7 +594,7 @@ trait Applications extends Compatibility { self: Typer =>
     def followTypeAlias(tree: untpd.Tree): untpd.Tree = {
       tree match {
         case tree: untpd.RefTree =>
-          val ttree = typedType(tree.withName(tree.name.toTypeName))
+          val ttree = typedType(untpd.rename(tree, tree.name.toTypeName))
           ttree.tpe match {
             case alias: TypeRef if alias.info.isAlias =>
               companionRef(alias) match {
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 9066012f0..9c1110dd1 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -390,7 +390,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
                   case lhsCore: RefTree if setter.exists =>
                     val setterTypeRaw = pre select (setterName, setter)
                     val setterType = ensureAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.pos)
-                    val lhs2 = lhsCore.withName(setterName).withType(setterType)
+                    val lhs2 = untpd.rename(lhsCore, setterName).withType(setterType)
                     typed(cpy.Apply(tree)(untpd.TypedSplice(lhs2), tree.rhs :: Nil))
                   case _ =>
                     reassignmentToVal
@@ -1009,7 +1009,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
-  protected def encodeName(tree: untpd.NameTree)(implicit ctx: Context) = tree withName tree.name.encode
+  protected def encodeName(tree: untpd.NameTree)(implicit ctx: Context): untpd.NameTree =
+    untpd.rename(tree, tree.name.encode)
 
   def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = /*>|>*/ ctx.traceIndented (i"typing $tree", typr, show = true) /*<|<*/ {
     assertPositioned(tree)