Switched to new cpy scheme.

Avoid mentioning arguments that are unchanged.

10 files changed, 45 insertions, 44 deletions

diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 5e947fc07..fcaef9730 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -72,11 +72,13 @@ object desugar {
 
   /** A type definition copied from `tdef` with a rhs typetree derived from it */
   def derivedTypeParam(tdef: TypeDef) =
-    cpy.TypeDef(tdef)(rhs = new DerivedFromParamTree() withPos tdef.rhs.pos watching tdef)
+    cpy.TypeDef(tdef)(
+      rhs = new DerivedFromParamTree() withPos tdef.rhs.pos watching tdef)
 
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
   def derivedTermParam(vdef: ValDef) =
-    cpy.ValDef(vdef)(tpt = new DerivedFromParamTree() withPos vdef.tpt.pos watching vdef)
+    cpy.ValDef(vdef)(
+      tpt = new DerivedFromParamTree() withPos vdef.tpt.pos watching vdef)
 
 // ----- Desugar methods -------------------------------------------------
 
@@ -157,7 +159,7 @@ object desugar {
     }
 
     def normalizedVparamss = vparamss map (_ map (vparam =>
-      cpy.ValDef(vparam)(vparam.mods, vparam.name, vparam.tpt, EmptyTree)))
+      cpy.ValDef(vparam)(rhs = EmptyTree)))
 
     def defaultGetters(vparamss: List[List[ValDef]], n: Int): List[DefDef] = vparamss match {
       case (vparam :: vparams) :: vparamss1 =>
@@ -194,18 +196,17 @@ object desugar {
    *     class C { type v C$T; type v T = C$T }
    */
   def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
-    val TypeDef(mods, name, rhs) = tdef
-    if (mods is PrivateLocalParam) {
+    if (tdef.mods is PrivateLocalParam) {
       val tparam = cpy.TypeDef(tdef)(
-        mods = mods &~ PrivateLocal | ExpandedName,
-        name = name.expandedName(ctx.owner))
+        mods = tdef.mods &~ PrivateLocal | ExpandedName,
+        name = tdef.name.expandedName(ctx.owner))
       val alias = cpy.TypeDef(tdef)(
-        mods = Modifiers(PrivateLocalParamAccessor | Synthetic | mods.flags & VarianceFlags),
+        mods = Modifiers(PrivateLocalParamAccessor | Synthetic | tdef.mods.flags & VarianceFlags),
         rhs = refOfDef(tparam),
         tparams = Nil)
       Thicket(tparam, alias)
     }
-    else cpy.TypeDef(tdef)(mods, name, rhs, tdef.tparams) // TODO: why copy?
+    else tdef
   }
 
   private val synthetic = Modifiers(Synthetic)
@@ -214,7 +215,7 @@ object desugar {
     cpy.TypeDef(tparam)(mods = Modifiers(Param))
 
   private def toDefParam(vparam: ValDef) =
-    cpy.ValDef(vparam)(Modifiers(Param | vparam.mods.flags & Implicit), vparam.name, vparam.tpt, vparam.rhs)
+    cpy.ValDef(vparam)(mods = Modifiers(Param | vparam.mods.flags & Implicit))
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -296,9 +297,9 @@ object desugar {
             def copyDefault(vparam: ValDef) =
               makeAnnotated(defn.UncheckedVarianceAnnot, refOfDef(vparam))
             val copyFirstParams = derivedVparamss.head.map(vparam =>
-              cpy.ValDef(vparam)(vparam.mods, vparam.name, vparam.tpt, copyDefault(vparam)))
+              cpy.ValDef(vparam)(rhs = copyDefault(vparam)))
             val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
-              cpy.ValDef(vparam)(vparam.mods, vparam.name, vparam.tpt, EmptyTree))
+              cpy.ValDef(vparam)(rhs = EmptyTree))
             DefDef(synthetic, nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr) :: Nil
           }
         copyMeths ::: isDefinedMeth :: productArityMeth :: productElemMeths.toList
@@ -378,22 +379,23 @@ object desugar {
     val self1 = {
       val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt
       if (self.isEmpty) self
-      else cpy.ValDef(self)(self.mods | SelfName, self.name, selfType, self.rhs)
+      else cpy.ValDef(self)(mods = self.mods | SelfName, tpt = selfType)
     }
 
     val cdef1 = {
       val originalTparams = constr1.tparams.toIterator
       val originalVparams = constr1.vparamss.toIterator.flatten
       val tparamAccessors = derivedTparams map { tdef =>
-        cpy.TypeDef(tdef)(originalTparams.next.mods, tdef.name, tdef.rhs, tdef.tparams)
+        cpy.TypeDef(tdef)(mods = originalTparams.next.mods)
       }
       val caseAccessor = if (mods is Case) CaseAccessor else EmptyFlags
       val vparamAccessors = derivedVparamss.flatten map { vdef =>
-        cpy.ValDef(vdef)(originalVparams.next.mods | caseAccessor, vdef.name, vdef.tpt, vdef.rhs)
+        cpy.ValDef(vdef)(mods = originalVparams.next.mods | caseAccessor)
       }
-      cpy.TypeDef(cdef)(mods, name,
-        cpy.Template(impl)(constr, parents1, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths), Nil)
+      cpy.TypeDef(cdef)(
+        rhs = cpy.Template(impl)(constr, parents1, self1,
+          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths),
+        tparams = Nil)
     }
 
     // install the watch on classTycon
@@ -414,18 +416,18 @@ object desugar {
    *    <module> final class name$ extends parents { self: name.type => body }
    */
   def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = {
-    val ModuleDef(mods, name, tmpl @ Template(constr, parents, self, body)) = mdef
+    val ModuleDef(mods, name, tmpl) = mdef
     if (mods is Package)
       PackageDef(Ident(name), cpy.ModuleDef(mdef)(mods &~ Package, nme.PACKAGE, tmpl) :: Nil)
     else {
       val clsName = name.moduleClassName
       val clsRef = Ident(clsName)
       val modul = ValDef(mods | ModuleCreationFlags, name, clsRef, New(clsRef, Nil)) withPos mdef.pos
-      val ValDef(selfMods, selfName, selfTpt, selfRhs) = self
-      if (!selfTpt.isEmpty) ctx.error("object definition may not have a self type", self.pos)
+      val ValDef(selfMods, selfName, selfTpt, selfRhs) = tmpl.self
+      if (!selfTpt.isEmpty) ctx.error("object definition may not have a self type", tmpl.self.pos)
       val clsSelf = ValDef(selfMods, selfName, SingletonTypeTree(Ident(name)), selfRhs)
-        .withPos(self.pos orElse tmpl.pos.startPos)
-      val clsTmpl = cpy.Template(tmpl)(constr, parents, clsSelf, body)
+        .withPos(tmpl.self.pos orElse tmpl.pos.startPos)
+      val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body)
       val cls = TypeDef(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags, clsName, clsTmpl)
       Thicket(modul, classDef(cls))
     }
@@ -502,8 +504,8 @@ object desugar {
    */
   def block(tree: Block)(implicit ctx: Context): Block = tree.expr match {
     case EmptyTree =>
-      cpy.Block(tree)(tree.stats,
-        unitLiteral withPos (if (tree.stats.isEmpty) tree.pos else tree.pos.endPos))
+      cpy.Block(tree)(
+        expr = unitLiteral withPos (if (tree.stats.isEmpty) tree.pos else tree.pos.endPos))
     case _ =>
       tree
   }
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 41ef88b54..3ff600f44 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -433,7 +433,7 @@ 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)
+    def withName(name: Name)(implicit ctx: Context): untpd.Select = untpd.cpy.Select(this)(name = name)
   }
 
   class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -620,7 +620,7 @@ 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)
+    def withName(name: Name)(implicit ctx: Context): untpd.SelectFromTypeTree = untpd.cpy.SelectFromTypeTree(this)(name = name)
   }
 
   /** left & right */
@@ -666,7 +666,7 @@ 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)
+    def withName(name: Name)(implicit ctx: Context): untpd.Bind = untpd.cpy.Bind(this)(name = name)
   }
 
   /** tree_1 | ... | tree_n */
@@ -697,7 +697,7 @@ 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)(mods, name.toTermName, tpt, rhs)
+    def withName(name: Name)(implicit ctx: Context): untpd.ValDef = untpd.cpy.ValDef(this)(name = name.toTermName)
     assert(isEmpty || tpt != genericEmptyTree)
   }
 
@@ -717,7 +717,7 @@ 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)(mods, name.toTypeName, rhs, tparams)
+    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[_]]
diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index 522d94243..e6de5bb5d 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -963,7 +963,7 @@ object Parsers {
           val tpt = typeDependingOn(location)
           if (isWildcard(t) && location != Location.InPattern) {
             val vd :: rest = placeholderParams
-            placeholderParams = cpy.ValDef(vd)(vd.mods, vd.name, tpt, vd.rhs) :: rest
+            placeholderParams = cpy.ValDef(vd)(tpt = tpt) :: rest
           }
           Typed(t, tpt)
       }
diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index e05852dc2..42e10b126 100644
--- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -162,10 +162,10 @@ class ExtensionMethods extends MacroTransform with DenotTransformer with FullPar
             paramAccessors.foreach(_.makeNotPrivateAfter(ctx.owner, thisTransformer))
             super.transform(tree)
           } else if (ctx.owner.isStaticOwner) {
-            val tree1 @ Template(constr, parents, selfType, body) = super.transform(tree)
+            val tree1 @ Template(_, _, _, body) = super.transform(tree)
             extensionDefs remove tree1.symbol.owner match {
               case Some(defns) if defns.nonEmpty =>
-                cpy.Template(tree1)(constr, parents, selfType, body ++ defns)
+                cpy.Template(tree1)(body = body ++ defns)
               case _ =>
                 tree1
             }
diff --git a/src/dotty/tools/dotc/transform/MacroTransform.scala b/src/dotty/tools/dotc/transform/MacroTransform.scala
index 6f38c98a9..734380661 100644
--- a/src/dotty/tools/dotc/transform/MacroTransform.scala
+++ b/src/dotty/tools/dotc/transform/MacroTransform.scala
@@ -71,6 +71,6 @@ abstract class MacroTransform extends Phase {
     }
 
     def transformSelf(vd: ValDef)(implicit ctx: Context) =
-      cpy.ValDef(vd)(vd.mods, vd.name, transform(vd.tpt), vd.rhs)
+      cpy.ValDef(vd)(tpt = transform(vd.tpt))
   }
 }
diff --git a/src/dotty/tools/dotc/transform/Nullarify.scala b/src/dotty/tools/dotc/transform/Nullarify.scala
index 6ecb095b4..7cca19e5a 100644
--- a/src/dotty/tools/dotc/transform/Nullarify.scala
+++ b/src/dotty/tools/dotc/transform/Nullarify.scala
@@ -72,7 +72,7 @@ class Nullarify extends MiniPhaseTransform with InfoTransformer {
     val MethodType(_, formals) = methType(funType, tree.fun)
 
     val args1 = tree.args.zipWithConserve(formals)(transformArg)
-    cpy.Apply(tree)(tree.fun, args1) withType nullarify(tree.tpe)
+    cpy.Apply(tree)(args = args1) withType nullarify(tree.tpe)
   }
 
   /** Insert () or .apply() if the term refers to something that was converted to a
@@ -144,4 +144,4 @@ class Nullarify extends MiniPhaseTransform with InfoTransformer {
     if (defn.typeTestsOrCasts contains sym) tp
     else if (sym is Param) nullarifyParam(tp)
     else nullarify(tp)
-}
\ No newline at end of file
+}
diff --git a/src/dotty/tools/dotc/transform/SuperAccessors.scala b/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 62dd7f0c0..f0d25d9c2 100644
--- a/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -295,7 +295,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
             val body1 = forwardParamAccessors(transformStats(impl.body, tree.symbol))
             accDefs -= currentClass
             ownStats ++= body1
-            cpy.Template(tree)(impl.constr, impl.parents, impl.self, body1)
+            cpy.Template(impl)(body = body1)
           }
           transformTemplate
 
diff --git a/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala b/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala
index b8a9e8dfe..c713a7d30 100644
--- a/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala
@@ -23,7 +23,7 @@ class UncurryTreeTransform extends MiniPhaseTransform with InfoTransformer {
         showType
         ctx.atNextPhase(showType(_))
         showType
-        cpy.Apply(tree)(fn, args ++ tree.args)
+        cpy.Apply(tree)(args = args ++ tree.args)
       case _ => tree
     }}
 
diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 638caba5b..20a5a1204 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -366,9 +366,8 @@ class Namer { typer: Typer =>
             val Thicket(vdef :: (mcls @ TypeDef(_, _, impl: Template)) :: Nil) = mdef.attachment(ExpandedTree)
             cdef.attachmentOrElse(ExpandedTree, cdef) match {
               case Thicket(cls :: mval :: TypeDef(_, _, compimpl: Template) :: crest) =>
-                val mcls1 = cpy.TypeDef(mcls)(mcls.mods, mcls.name,
-                    cpy.Template(impl)(impl.constr, impl.parents, impl.self,
-                        compimpl.body ++ impl.body), Nil)
+                val mcls1 = cpy.TypeDef(mcls)(
+                    rhs = cpy.Template(impl)(body = compimpl.body ++ impl.body))
                 mdef.putAttachment(ExpandedTree, Thicket(vdef :: mcls1 :: Nil))
                 cdef.putAttachment(ExpandedTree, Thicket(cls :: crest))
               case _ =>
diff --git a/src/dotty/tools/dotc/typer/ReTyper.scala b/src/dotty/tools/dotc/typer/ReTyper.scala
index dbf353f9e..42128f67f 100644
--- a/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -32,13 +32,13 @@ class ReTyper extends Typer {
   override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
     assert(tree.hasType)
     val qual1 = typed(tree.qualifier, AnySelectionProto)
-    untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
+    untpd.cpy.Select(tree)(qualifier = qual1).withType(tree.typeOpt)
   }
 
   override def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): SelectFromTypeTree = {
     assert(tree.hasType)
     val qual1 = typed(tree.qualifier, AnySelectionProto)
-    untpd.cpy.SelectFromTypeTree(tree)(qual1, tree.name).withType(tree.typeOpt)
+    untpd.cpy.SelectFromTypeTree(tree)(qualifier = qual1).withType(tree.typeOpt)
   }
 
   override def typedLiteral(tree: untpd.Literal)(implicit ctc: Context): Literal =
@@ -50,7 +50,7 @@ class ReTyper extends Typer {
   override def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = {
     assert(tree.hasType)
     val body1 = typed(tree.body, pt)
-    untpd.cpy.Bind(tree)(tree.name, body1).withType(tree.typeOpt)
+    untpd.cpy.Bind(tree)(body = body1).withType(tree.typeOpt)
   }
 
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context) = impl.symbol