Changes to tree copying

1) Add copiers with default arguments, to avoid boilerplate
2) All copiers are now curried wrt first argument (which is
   the original tree).

We already make use of the new features in cpy.DefDef, but not yet elsewhere.

1 files changed, 38 insertions, 38 deletions

diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index 44f340932..edade1420 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -29,7 +29,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class ModuleDef(mods: Modifiers, name: TermName, impl: Template)
     extends MemberDef {
     type ThisTree[-T >: Untyped] <: Trees.NameTree[T] with Trees.MemberDef[T] with ModuleDef
-    def withName(name: Name)(implicit ctx: Context) = cpy.ModuleDef(this, mods, name.toTermName, impl)
+    def withName(name: Name)(implicit ctx: Context) = cpy.ModuleDef(this)(mods, name.toTermName, impl)
   }
 
   case class SymbolLit(str: String) extends TermTree
@@ -59,7 +59,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   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)
+    override def withName(name: Name)(implicit ctx: Context) = cpy.PolyTypeDef(this)(mods, name.toTypeName, tparams, rhs)
   }
 
   // ----- TypeTrees that refer to other tree's symbols -------------------
@@ -253,75 +253,75 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def postProcess(tree: Tree, copied: Tree): copied.ThisTree[Untyped] =
       copied.asInstanceOf[copied.ThisTree[Untyped]]
 
-    def ModuleDef(tree: Tree, mods: Modifiers, name: TermName, impl: Template) = tree match {
+    def ModuleDef(tree: Tree)(mods: Modifiers, name: TermName, impl: Template) = tree match {
       case tree: ModuleDef if (mods eq tree.mods) && (name eq tree.name) && (impl eq tree.impl) => tree
       case _ => untpd.ModuleDef(mods, name, impl).withPos(tree.pos)
     }
-    def PolyTypeDef(tree: Tree, mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree) = tree match {
+    def PolyTypeDef(tree: Tree)(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree) = tree match {
       case tree: PolyTypeDef if (mods eq tree.mods) && (name eq tree.name) && (tparams eq tree.tparams) && (rhs eq tree.rhs) => tree
       case _ => new PolyTypeDef(mods, name, tparams, rhs).withPos(tree.pos)
     }
-    def SymbolLit(tree: Tree, str: String) = tree match {
+    def SymbolLit(tree: Tree)(str: String) = tree match {
       case tree: SymbolLit if (str == tree.str) => tree
       case _ => untpd.SymbolLit(str).withPos(tree.pos)
     }
-    def InterpolatedString(tree: Tree, id: TermName, strings: List[Literal], elems: List[Tree]) = tree match {
+    def InterpolatedString(tree: Tree)(id: TermName, strings: List[Literal], elems: List[Tree]) = tree match {
       case tree: InterpolatedString if (id eq tree.id) && (strings eq tree.strings) && (elems eq tree.elems) => tree
       case _ => untpd.InterpolatedString(id, strings, elems).withPos(tree.pos)
     }
-    def Function(tree: Tree, args: List[Tree], body: Tree) = tree match {
+    def Function(tree: Tree)(args: List[Tree], body: Tree) = tree match {
       case tree: Function if (args eq tree.args) && (body eq tree.body) => tree
       case _ => untpd.Function(args, body).withPos(tree.pos)
     }
-    def InfixOp(tree: Tree, left: Tree, op: Name, right: Tree) = tree match {
+    def InfixOp(tree: Tree)(left: Tree, op: Name, right: Tree) = tree match {
       case tree: InfixOp if (left eq tree.left) && (op eq tree.op) && (right eq tree.right) => tree
       case _ => untpd.InfixOp(left, op, right).withPos(tree.pos)
     }
-    def PostfixOp(tree: Tree, od: Tree, op: Name) = tree match {
+    def PostfixOp(tree: Tree)(od: Tree, op: Name) = tree match {
       case tree: PostfixOp if (od eq tree.od) && (op eq tree.op) => tree
       case _ => untpd.PostfixOp(od, op).withPos(tree.pos)
     }
-    def PrefixOp(tree: Tree, op: Name, od: Tree) = tree match {
+    def PrefixOp(tree: Tree)(op: Name, od: Tree) = tree match {
       case tree: PrefixOp if (op eq tree.op) && (od eq tree.od) => tree
       case _ => untpd.PrefixOp(op, od).withPos(tree.pos)
     }
-    def Parens(tree: Tree, t: Tree) = tree match {
+    def Parens(tree: Tree)(t: Tree) = tree match {
       case tree: Parens if (t eq tree.t) => tree
       case _ => untpd.Parens(t).withPos(tree.pos)
     }
-    def Tuple(tree: Tree, trees: List[Tree]) = tree match {
+    def Tuple(tree: Tree)(trees: List[Tree]) = tree match {
       case tree: Tuple if (trees eq tree.trees) => tree
       case _ => untpd.Tuple(trees).withPos(tree.pos)
     }
-    def WhileDo(tree: Tree, cond: Tree, body: Tree) = tree match {
+    def WhileDo(tree: Tree)(cond: Tree, body: Tree) = tree match {
       case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
       case _ => untpd.WhileDo(cond, body).withPos(tree.pos)
     }
-    def DoWhile(tree: Tree, body: Tree, cond: Tree) = tree match {
+    def DoWhile(tree: Tree)(body: Tree, cond: Tree) = tree match {
       case tree: DoWhile if (body eq tree.body) && (cond eq tree.cond) => tree
       case _ => untpd.DoWhile(body, cond).withPos(tree.pos)
     }
-    def ForYield(tree: Tree, enums: List[Tree], expr: Tree) = tree match {
+    def ForYield(tree: Tree)(enums: List[Tree], expr: Tree) = tree match {
       case tree: ForYield if (enums eq tree.enums) && (expr eq tree.expr) => tree
       case _ => untpd.ForYield(enums, expr).withPos(tree.pos)
     }
-    def ForDo(tree: Tree, enums: List[Tree], body: Tree) = tree match {
+    def ForDo(tree: Tree)(enums: List[Tree], body: Tree) = tree match {
       case tree: ForDo if (enums eq tree.enums) && (body eq tree.body) => tree
       case _ => untpd.ForDo(enums, body).withPos(tree.pos)
     }
-    def GenFrom(tree: Tree, pat: Tree, expr: Tree) = tree match {
+    def GenFrom(tree: Tree)(pat: Tree, expr: Tree) = tree match {
       case tree: GenFrom if (pat eq tree.pat) && (expr eq tree.expr) => tree
       case _ => untpd.GenFrom(pat, expr).withPos(tree.pos)
     }
-    def GenAlias(tree: Tree, pat: Tree, expr: Tree) = tree match {
+    def GenAlias(tree: Tree)(pat: Tree, expr: Tree) = tree match {
       case tree: GenAlias if (pat eq tree.pat) && (expr eq tree.expr) => tree
       case _ => untpd.GenAlias(pat, expr).withPos(tree.pos)
     }
-    def ContextBounds(tree: Tree, bounds: TypeBoundsTree, cxBounds: List[Tree]) = tree match {
+    def ContextBounds(tree: Tree)(bounds: TypeBoundsTree, cxBounds: List[Tree]) = tree match {
       case tree: ContextBounds if (bounds eq tree.bounds) && (cxBounds eq tree.cxBounds) => tree
       case _ => untpd.ContextBounds(bounds, cxBounds).withPos(tree.pos)
     }
-    def PatDef(tree: Tree, mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree) = tree match {
+    def PatDef(tree: Tree)(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree) = tree match {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => untpd.PatDef(mods, pats, tpt, rhs).withPos(tree.pos)
     }
@@ -330,41 +330,41 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   abstract class UntypedTreeMap(cpy: UntypedTreeCopier = untpd.cpy) extends TreeMap(cpy) {
     override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case ModuleDef(mods, name, impl) =>
-        cpy.ModuleDef(tree, mods, name, transformSub(impl))
+        cpy.ModuleDef(tree)(mods, name, transformSub(impl))
       case SymbolLit(str) =>
-        cpy.SymbolLit(tree, str)
+        cpy.SymbolLit(tree)(str)
       case InterpolatedString(id, strings, elems) =>
-        cpy.InterpolatedString(tree, id, transformSub(strings), transform(elems))
+        cpy.InterpolatedString(tree)(id, transformSub(strings), transform(elems))
       case Function(args, body) =>
-        cpy.Function(tree, transform(args), transform(body))
+        cpy.Function(tree)(transform(args), transform(body))
       case InfixOp(left, op, right) =>
-        cpy.InfixOp(tree, transform(left), op, transform(right))
+        cpy.InfixOp(tree)(transform(left), op, transform(right))
       case PostfixOp(od, op) =>
-        cpy.PostfixOp(tree, transform(od), op)
+        cpy.PostfixOp(tree)(transform(od), op)
       case PrefixOp(op, od) =>
-        cpy.PrefixOp(tree, op, transform(od))
+        cpy.PrefixOp(tree)(op, transform(od))
       case Parens(t) =>
-        cpy.Parens(tree, transform(t))
+        cpy.Parens(tree)(transform(t))
       case Tuple(trees) =>
-        cpy.Tuple(tree, transform(trees))
+        cpy.Tuple(tree)(transform(trees))
       case WhileDo(cond, body) =>
-        cpy.WhileDo(tree, transform(cond), transform(body))
+        cpy.WhileDo(tree)(transform(cond), transform(body))
       case DoWhile(body, cond) =>
-        cpy.DoWhile(tree, transform(body), transform(cond))
+        cpy.DoWhile(tree)(transform(body), transform(cond))
       case ForYield(enums, expr) =>
-        cpy.ForYield(tree, transform(enums), transform(expr))
+        cpy.ForYield(tree)(transform(enums), transform(expr))
       case ForDo(enums, body) =>
-        cpy.ForDo(tree, transform(enums), transform(body))
+        cpy.ForDo(tree)(transform(enums), transform(body))
       case GenFrom(pat, expr) =>
-        cpy.GenFrom(tree, transform(pat), transform(expr))
+        cpy.GenFrom(tree)(transform(pat), transform(expr))
       case GenAlias(pat, expr) =>
-        cpy.GenAlias(tree, transform(pat), transform(expr))
+        cpy.GenAlias(tree)(transform(pat), transform(expr))
       case ContextBounds(bounds, cxBounds) =>
-        cpy.ContextBounds(tree, transformSub(bounds), transform(cxBounds))
+        cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
-        cpy.PatDef(tree, mods, transform(pats), transform(tpt), transform(rhs))
+        cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
       case tree: PolyTypeDef =>
-        cpy.PolyTypeDef(tree, tree.mods, tree.name, transformSub(tree.tparams), transform(tree.rhs))
+        cpy.PolyTypeDef(tree)(tree.mods, tree.name, transformSub(tree.tparams), transform(tree.rhs))
       case _ =>
         super.transform(tree)
     }