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.

24 files changed, 398 insertions, 344 deletions

diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 705d14f03..5e947fc07 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -72,13 +72,11 @@ object desugar {
 
   /** A type definition copied from `tdef` with a rhs typetree derived from it */
   def derivedTypeParam(tdef: TypeDef) =
-    cpy.TypeDef(tdef, tdef.mods, tdef.name,
-      new DerivedFromParamTree() withPos tdef.rhs.pos watching tdef, tdef.tparams) // todo: copy type params
+    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, vdef.mods, vdef.name,
-      new DerivedFromParamTree() withPos vdef.tpt.pos watching vdef, vdef.rhs)
+    cpy.ValDef(vdef)(tpt = new DerivedFromParamTree() withPos vdef.tpt.pos watching vdef)
 
 // ----- Desugar methods -------------------------------------------------
 
@@ -98,7 +96,7 @@ object desugar {
       // I don't see a problem with that but if there is one we can avoid it by making a copy here.
       val setterParam = makeSyntheticParameter(tpt = (new SetterParamTree).watching(vdef))
       val setterRhs = if (vdef.rhs.isEmpty) EmptyTree else unitLiteral
-      val setter = cpy.DefDef(vdef,
+      val setter = cpy.DefDef(vdef)(
         mods | Accessor, name.setterName, Nil, (setterParam :: Nil) :: Nil,
         TypeTree(defn.UnitType), setterRhs) // rhs gets filled in later, when field is generated and getter has parameters
       Thicket(vdef, setter)
@@ -124,14 +122,14 @@ object desugar {
     val DefDef(mods, name, tparams, vparamss, tpt, rhs) = meth
     val epbuf = new ListBuffer[ValDef]
     val tparams1 = tparams mapConserve {
-      case tparam @ TypeDef(mods, name, ContextBounds(tbounds, cxbounds)) =>
+      case tparam @ TypeDef(_, _, ContextBounds(tbounds, cxbounds)) =>
         for (cxbound <- cxbounds) {
           val paramFlags: FlagSet = if (isPrimaryConstructor) PrivateLocalParamAccessor else Param
           val epname = (nme.EVIDENCE_PARAM_PREFIX.toString + epbuf.length).toTermName
           epbuf +=
             ValDef(Modifiers(paramFlags | Implicit), epname, cxbound, EmptyTree)
         }
-        cpy.TypeDef(tparam, mods, name, tbounds, tparam.tparams)
+        cpy.TypeDef(tparam)(rhs = tbounds)
       case tparam =>
         tparam
     }
@@ -146,7 +144,7 @@ object desugar {
           case _ =>
             vparamss :+ evidenceParams
         }
-        cpy.DefDef(meth, mods, name, tparams1, vparamss1, tpt, rhs)
+        cpy.DefDef(meth)(tparams = tparams1, vparamss = vparamss1)
     }
 
     /** The longest prefix of parameter lists in vparamss whose total length does not exceed `n` */
@@ -159,7 +157,7 @@ object desugar {
     }
 
     def normalizedVparamss = vparamss map (_ map (vparam =>
-      cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt, EmptyTree)))
+      cpy.ValDef(vparam)(vparam.mods, vparam.name, vparam.tpt, EmptyTree)))
 
     def defaultGetters(vparamss: List[List[ValDef]], n: Int): List[DefDef] = vparamss match {
       case (vparam :: vparams) :: vparamss1 =>
@@ -182,9 +180,9 @@ object desugar {
     val defGetters = defaultGetters(vparamss, 0)
     if (defGetters.isEmpty) meth1
     else {
-      val mods1 = meth1.mods | DefaultParameterized
-      val meth2 = cpy.DefDef(meth1, meth1.mods | DefaultParameterized,
-          meth1.name, meth1.tparams, normalizedVparamss, meth1.tpt, meth1.rhs)
+      val meth2 = cpy.DefDef(meth1)(
+          mods = meth1.mods | DefaultParameterized,
+          vparamss = normalizedVparamss)
       Thicket(meth2 :: defGetters)
     }
   }
@@ -198,23 +196,25 @@ object desugar {
   def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
     val TypeDef(mods, name, rhs) = tdef
     if (mods is PrivateLocalParam) {
-      val tparam = cpy.TypeDef(tdef,
-        mods &~ PrivateLocal | ExpandedName, name.expandedName(ctx.owner), rhs, tdef.tparams)
-      val alias = cpy.TypeDef(tdef,
-        Modifiers(PrivateLocalParamAccessor | Synthetic | mods.flags & VarianceFlags),
-                  name, refOfDef(tparam))
+      val tparam = cpy.TypeDef(tdef)(
+        mods = mods &~ PrivateLocal | ExpandedName,
+        name = name.expandedName(ctx.owner))
+      val alias = cpy.TypeDef(tdef)(
+        mods = Modifiers(PrivateLocalParamAccessor | Synthetic | mods.flags & VarianceFlags),
+        rhs = refOfDef(tparam),
+        tparams = Nil)
       Thicket(tparam, alias)
     }
-    else cpy.TypeDef(tdef, mods, name, rhs, tdef.tparams)
+    else cpy.TypeDef(tdef)(mods, name, rhs, tdef.tparams) // TODO: why copy?
   }
 
   private val synthetic = Modifiers(Synthetic)
 
   private def toDefParam(tparam: TypeDef) =
-    cpy.TypeDef(tparam, Modifiers(Param), tparam.name, tparam.rhs, tparam.tparams)
+    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)(Modifiers(Param | vparam.mods.flags & Implicit), vparam.name, vparam.tpt, vparam.rhs)
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -239,13 +239,12 @@ object desugar {
         ListOfNil
       }
       else constr1.vparamss.nestedMap(toDefParam)
-    val constr = cpy.DefDef(constr1,
-      constr1.mods, constr1.name, constrTparams, constrVparamss, constr1.tpt, constr1.rhs)
+    val constr = cpy.DefDef(constr1)(tparams = constrTparams, vparamss = constrVparamss)
 
     // Add constructor type parameters to auxiliary constructors
     val normalizedBody = body map {
       case ddef: DefDef if ddef.name.isConstructorName =>
-        cpy.DefDef(ddef, ddef.mods, ddef.name, constrTparams, ddef.vparamss, ddef.tpt, ddef.rhs)
+        cpy.DefDef(ddef)(tparams = constrTparams)
       case stat =>
         stat
     }
@@ -297,9 +296,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)(vparam.mods, vparam.name, vparam.tpt, copyDefault(vparam)))
             val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
-              cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt, EmptyTree))
+              cpy.ValDef(vparam)(vparam.mods, vparam.name, vparam.tpt, EmptyTree))
             DefDef(synthetic, nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr) :: Nil
           }
         copyMeths ::: isDefinedMeth :: productArityMeth :: productElemMeths.toList
@@ -379,22 +378,22 @@ 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)(self.mods | SelfName, self.name, selfType, self.rhs)
     }
 
     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)(originalTparams.next.mods, tdef.name, tdef.rhs, tdef.tparams)
       }
       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)(originalVparams.next.mods | caseAccessor, vdef.name, vdef.tpt, vdef.rhs)
       }
-      cpy.TypeDef(cdef, mods, name,
-        cpy.Template(impl, constr, parents1, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths))
+      cpy.TypeDef(cdef)(mods, name,
+        cpy.Template(impl)(constr, parents1, self1,
+          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths), Nil)
     }
 
     // install the watch on classTycon
@@ -417,7 +416,7 @@ object desugar {
   def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = {
     val ModuleDef(mods, name, tmpl @ Template(constr, parents, self, body)) = mdef
     if (mods is Package)
-      PackageDef(Ident(name), cpy.ModuleDef(mdef, mods &~ Package, nme.PACKAGE, tmpl) :: Nil)
+      PackageDef(Ident(name), cpy.ModuleDef(mdef)(mods &~ Package, nme.PACKAGE, tmpl) :: Nil)
     else {
       val clsName = name.moduleClassName
       val clsRef = Ident(clsName)
@@ -426,7 +425,7 @@ object desugar {
       if (!selfTpt.isEmpty) ctx.error("object definition may not have a self type", 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)
+      val clsTmpl = cpy.Template(tmpl)(constr, parents, clsSelf, body)
       val cls = TypeDef(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags, clsName, clsTmpl)
       Thicket(modul, classDef(cls))
     }
@@ -503,7 +502,7 @@ object desugar {
    */
   def block(tree: Block)(implicit ctx: Context): Block = tree.expr match {
     case EmptyTree =>
-      cpy.Block(tree, tree.stats,
+      cpy.Block(tree)(tree.stats,
         unitLiteral withPos (if (tree.stats.isEmpty) tree.pos else tree.pos.endPos))
     case _ =>
       tree
@@ -516,7 +515,7 @@ object desugar {
     val TypeBoundsTree(lo, hi) = tree
     val lo1 = if (lo.isEmpty) untpd.TypeTree(defn.NothingType) else lo
     val hi1 = if (hi.isEmpty) untpd.TypeTree(defn.AnyType) else hi
-    cpy.TypeBoundsTree(tree, lo1, hi1)
+    cpy.TypeBoundsTree(tree)(lo1, hi1)
   }
 
   /** Make closure corresponding to function.
@@ -563,7 +562,7 @@ object desugar {
      */
     def makeBinop(left: Tree, op: Name, right: Tree): Tree = {
       def assignToNamedArg(arg: Tree) = arg match {
-        case Assign(Ident(name), rhs) => cpy.NamedArg(arg, name, rhs)
+        case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
         case _ => arg
       }
       if (isLeftAssoc(op)) {
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index e19221841..41ef88b54 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -422,7 +422,7 @@ 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 withName(name: Name)(implicit ctx: Context): untpd.Ident = untpd.cpy.Ident(this)(name)
     def qualifier: Tree[T] = genericEmptyTree
   }
 
@@ -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)(qualifier, 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)(qualifier, 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, body)
   }
 
   /** 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)(mods, name.toTermName, tpt, rhs)
     assert(isEmpty || tpt != genericEmptyTree)
   }
 
@@ -705,7 +705,7 @@ 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, mods, name.toTermName, tparams, vparamss, tpt, rhs)
+    def withName(name: Name)(implicit ctx: Context): untpd.DefDef = untpd.cpy.DefDef(this)(name = name.toTermName)
     assert(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)(mods, name.toTypeName, rhs, tparams)
 
     /** Is this a definition of a class? */
     def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -919,179 +919,237 @@ object Trees {
       def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
         postProcess(tree, copied withPos tree.pos)
 
-      def Ident(tree: Tree, name: Name): Ident = tree match {
+      def Ident(tree: Tree)(name: Name): Ident = tree match {
         case tree: BackquotedIdent =>
           if (name == tree.name) tree
           else finalize(tree, new BackquotedIdent(name))
         case tree: Ident if (name == tree.name) => tree
         case _ => finalize(tree, untpd.Ident(name))
       }
-      def Select(tree: Tree, qualifier: Tree, name: Name): Select = tree match {
+      def Select(tree: Tree)(qualifier: Tree, name: Name): Select = tree match {
         case tree: SelectWithSig =>
           if ((qualifier eq tree.qualifier) && (name == tree.name)) tree
           else finalize(tree, new SelectWithSig(qualifier, name, tree.sig))
         case tree: Select if (qualifier eq tree.qualifier) && (name == tree.name) => tree
         case _ => finalize(tree, untpd.Select(qualifier, name))
       }
-      def This(tree: Tree, qual: TypeName): This = tree match {
+      def This(tree: Tree)(qual: TypeName): This = tree match {
         case tree: This if (qual == tree.qual) => tree
         case _ => finalize(tree, untpd.This(qual))
       }
-      def Super(tree: Tree, qual: Tree, mix: TypeName): Super = tree match {
+      def Super(tree: Tree)(qual: Tree, mix: TypeName): Super = tree match {
         case tree: Super if (qual eq tree.qual) && (mix == tree.mix) => tree
         case _ => finalize(tree, untpd.Super(qual, mix))
       }
-      def Apply(tree: Tree, fun: Tree, args: List[Tree]): Apply = tree match {
+      def Apply(tree: Tree)(fun: Tree, args: List[Tree]): Apply = tree match {
         case tree: Apply if (fun eq tree.fun) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.Apply(fun, args))
       }
-      def TypeApply(tree: Tree, fun: Tree, args: List[Tree]): TypeApply = tree match {
+      def TypeApply(tree: Tree)(fun: Tree, args: List[Tree]): TypeApply = tree match {
         case tree: TypeApply if (fun eq tree.fun) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.TypeApply(fun, args))
       }
-      def Literal(tree: Tree, const: Constant): Literal = tree match {
+      def Literal(tree: Tree)(const: Constant): Literal = tree match {
         case tree: Literal if (const == tree.const) => tree
         case _ => finalize(tree, untpd.Literal(const))
       }
-      def New(tree: Tree, tpt: Tree): New = tree match {
+      def New(tree: Tree)(tpt: Tree): New = tree match {
         case tree: New if (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.New(tpt))
       }
-      def Pair(tree: Tree, left: Tree, right: Tree): Pair = tree match {
+      def Pair(tree: Tree)(left: Tree, right: Tree): Pair = tree match {
         case tree: Pair if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.Pair(left, right))
       }
-      def Typed(tree: Tree, expr: Tree, tpt: Tree): Typed = tree match {
+      def Typed(tree: Tree)(expr: Tree, tpt: Tree): Typed = tree match {
         case tree: Typed if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.Typed(expr, tpt))
       }
-      def NamedArg(tree: Tree, name: Name, arg: Tree): NamedArg = tree match {
+      def NamedArg(tree: Tree)(name: Name, arg: Tree): NamedArg = tree match {
         case tree: NamedArg if (name == tree.name) && (arg eq tree.arg) => tree
         case _ => finalize(tree, untpd.NamedArg(name, arg))
       }
-      def Assign(tree: Tree, lhs: Tree, rhs: Tree): Assign = tree match {
+      def Assign(tree: Tree)(lhs: Tree, rhs: Tree): Assign = tree match {
         case tree: Assign if (lhs eq tree.lhs) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.Assign(lhs, rhs))
       }
-      def Block(tree: Tree, stats: List[Tree], expr: Tree): Block = tree match {
+      def Block(tree: Tree)(stats: List[Tree], expr: Tree): Block = tree match {
         case tree: Block if (stats eq tree.stats) && (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Block(stats, expr))
       }
-      def If(tree: Tree, cond: Tree, thenp: Tree, elsep: Tree): If = tree match {
+      def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree): If = tree match {
         case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
         case _ => finalize(tree, untpd.If(cond, thenp, elsep))
       }
-      def Closure(tree: Tree, env: List[Tree], meth: Tree, tpt: Tree): Closure = tree match {
+      def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree): Closure = tree match {
         case tree: Closure if (env eq tree.env) && (meth eq tree.meth) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.Closure(env, meth, tpt))
       }
-      def Match(tree: Tree, selector: Tree, cases: List[CaseDef]): Match = tree match {
+      def Match(tree: Tree)(selector: Tree, cases: List[CaseDef]): Match = tree match {
         case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
         case _ => finalize(tree, untpd.Match(selector, cases))
       }
-      def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree): CaseDef = tree match {
+      def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree): CaseDef = tree match {
         case tree: CaseDef if (pat eq tree.pat) && (guard eq tree.guard) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.CaseDef(pat, guard, body))
       }
-      def Return(tree: Tree, expr: Tree, from: Tree): Return = tree match {
+      def Return(tree: Tree)(expr: Tree, from: Tree): Return = tree match {
         case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
         case _ => finalize(tree, untpd.Return(expr, from))
       }
-      def Try(tree: Tree, expr: Tree, handler: Tree, finalizer: Tree): Try = tree match {
+      def Try(tree: Tree)(expr: Tree, handler: Tree, finalizer: Tree): Try = tree match {
         case tree: Try if (expr eq tree.expr) && (handler eq tree.handler) && (finalizer eq tree.finalizer) => tree
         case _ => finalize(tree, untpd.Try(expr, handler, finalizer))
       }
-      def Throw(tree: Tree, expr: Tree): Throw = tree match {
+      def Throw(tree: Tree)(expr: Tree): Throw = tree match {
         case tree: Throw if (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Throw(expr))
       }
-      def SeqLiteral(tree: Tree, elems: List[Tree]): SeqLiteral = tree match {
+      def SeqLiteral(tree: Tree)(elems: List[Tree]): SeqLiteral = tree match {
         case tree: JavaSeqLiteral =>
           if (elems eq tree.elems) tree
           else finalize(tree, new JavaSeqLiteral(elems))
         case tree: SeqLiteral if (elems eq tree.elems) => tree
         case _ => finalize(tree, untpd.SeqLiteral(elems))
       }
-      def TypeTree(tree: Tree, original: Tree): TypeTree = tree match {
+      def TypeTree(tree: Tree)(original: Tree): TypeTree = tree match {
         case tree: TypeTree if original eq tree.original => tree
         case _ => finalize(tree, untpd.TypeTree(original))
       }
-      def SingletonTypeTree(tree: Tree, ref: Tree): SingletonTypeTree = tree match {
+      def SingletonTypeTree(tree: Tree)(ref: Tree): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
         case _ => finalize(tree, untpd.SingletonTypeTree(ref))
       }
-      def SelectFromTypeTree(tree: Tree, qualifier: Tree, name: Name): SelectFromTypeTree = tree match {
+      def SelectFromTypeTree(tree: Tree)(qualifier: Tree, name: Name): SelectFromTypeTree = tree match {
         case tree: SelectFromTypeTree if (qualifier eq tree.qualifier) && (name == tree.name) => tree
         case _ => finalize(tree, untpd.SelectFromTypeTree(qualifier, name))
       }
-      def AndTypeTree(tree: Tree, left: Tree, right: Tree): AndTypeTree = tree match {
+      def AndTypeTree(tree: Tree)(left: Tree, right: Tree): AndTypeTree = tree match {
         case tree: AndTypeTree if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.AndTypeTree(left, right))
       }
-      def OrTypeTree(tree: Tree, left: Tree, right: Tree): OrTypeTree = tree match {
+      def OrTypeTree(tree: Tree)(left: Tree, right: Tree): OrTypeTree = tree match {
         case tree: OrTypeTree if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.OrTypeTree(left, right))
       }
-      def RefinedTypeTree(tree: Tree, tpt: Tree, refinements: List[Tree]): RefinedTypeTree = tree match {
+      def RefinedTypeTree(tree: Tree)(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = tree match {
         case tree: RefinedTypeTree if (tpt eq tree.tpt) && (refinements eq tree.refinements) => tree
         case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements))
       }
-      def AppliedTypeTree(tree: Tree, tpt: Tree, args: List[Tree]): AppliedTypeTree = tree match {
+      def AppliedTypeTree(tree: Tree)(tpt: Tree, args: List[Tree]): AppliedTypeTree = tree match {
         case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
       }
-      def ByNameTypeTree(tree: Tree, result: Tree): ByNameTypeTree = tree match {
+      def ByNameTypeTree(tree: Tree)(result: Tree): ByNameTypeTree = tree match {
         case tree: ByNameTypeTree if (result eq tree.result) => tree
         case _ => finalize(tree, untpd.ByNameTypeTree(result))
       }
-      def TypeBoundsTree(tree: Tree, lo: Tree, hi: Tree): TypeBoundsTree = tree match {
+      def TypeBoundsTree(tree: Tree)(lo: Tree, hi: Tree): TypeBoundsTree = tree match {
         case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) => tree
         case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi))
       }
-      def Bind(tree: Tree, name: Name, body: Tree): Bind = tree match {
+      def Bind(tree: Tree)(name: Name, body: Tree): Bind = tree match {
         case tree: Bind if (name eq tree.name) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.Bind(name, body))
       }
-      def Alternative(tree: Tree, trees: List[Tree]): Alternative = tree match {
+      def Alternative(tree: Tree)(trees: List[Tree]): Alternative = tree match {
         case tree: Alternative if (trees eq tree.trees) => tree
         case _ => finalize(tree, untpd.Alternative(trees))
       }
-      def UnApply(tree: Tree, fun: Tree, implicits: List[Tree], patterns: List[Tree]): UnApply = tree match {
+      def UnApply(tree: Tree)(fun: Tree, implicits: List[Tree], patterns: List[Tree]): UnApply = tree match {
         case tree: UnApply if (fun eq tree.fun) && (implicits eq tree.implicits) && (patterns eq tree.patterns) => tree
         case _ => finalize(tree, untpd.UnApply(fun, implicits, patterns))
       }
-      def ValDef(tree: Tree, mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef = tree match {
+      def ValDef(tree: Tree)(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef = tree match {
         case tree: ValDef if (mods == tree.mods) && (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.ValDef(mods, name, tpt, rhs))
       }
-      def DefDef(tree: Tree, mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = tree match {
+      def DefDef(tree: Tree)(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = tree match {
         case tree: DefDef if (mods == tree.mods) && (name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.DefDef(mods, name, tparams, vparamss, tpt, rhs))
       }
-      def TypeDef(tree: Tree, mods: Modifiers, name: TypeName, rhs: Tree, tparams: List[untpd.TypeDef] = Nil): TypeDef = tree match {
+      def TypeDef(tree: Tree)(mods: Modifiers, name: TypeName, rhs: Tree, tparams: List[untpd.TypeDef]): TypeDef = tree match {
         case tree: TypeDef if (mods == tree.mods) && (name == tree.name) && (rhs eq tree.rhs) && (tparams eq tree.tparams) => tree
         case _ => finalize(tree, untpd.TypeDef(mods, name, tparams, rhs))
       }
-      def Template(tree: Tree, constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree]): Template = tree match {
+      def Template(tree: Tree)(constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree]): Template = tree match {
         case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (self eq tree.self) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.Template(constr, parents, self, body))
       }
-      def Import(tree: Tree, expr: Tree, selectors: List[untpd.Tree]): Import = tree match {
+      def Import(tree: Tree)(expr: Tree, selectors: List[untpd.Tree]): Import = tree match {
         case tree: Import if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
         case _ => finalize(tree, untpd.Import(expr, selectors))
       }
-      def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree]): PackageDef = tree match {
+      def PackageDef(tree: Tree)(pid: RefTree, stats: List[Tree]): PackageDef = tree match {
         case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
         case _ => finalize(tree, untpd.PackageDef(pid, stats))
       }
-      def Annotated(tree: Tree, annot: Tree, arg: Tree): Annotated = tree match {
+      def Annotated(tree: Tree)(annot: Tree, arg: Tree): Annotated = tree match {
         case tree: Annotated if (annot eq tree.annot) && (arg eq tree.arg) => tree
         case _ => finalize(tree, untpd.Annotated(annot, arg))
       }
-      def Thicket(tree: Tree, trees: List[Tree]): Thicket = tree match {
+      def Thicket(tree: Tree)(trees: List[Tree]): Thicket = tree match {
         case tree: Thicket if (trees eq tree.trees) => tree
         case _ => finalize(tree, untpd.Thicket(trees))
       }
+
+      // Copier methods with default arguments; these demand that the original tree
+      // is of the same class as the copy
+
+      def Select(tree: Select)(qualifier: Tree = tree.qualifier, name: Name = tree.name): Select =
+        Select(tree: Tree)(qualifier, name)
+      def Super(tree: Super)(qual: Tree = tree.qual, mix: TypeName = tree.mix): Super =
+        Super(tree: Tree)(qual, mix)
+      def Apply(tree: Apply)(fun: Tree = tree.fun, args: List[Tree] = tree.args): Apply =
+        Apply(tree: Tree)(fun, args)
+      def TypeApply(tree: TypeApply)(fun: Tree = tree.fun, args: List[Tree] = tree.args): TypeApply =
+        TypeApply(tree: Tree)(fun, args)
+      def Typed(tree: Typed)(expr: Tree = tree.expr, tpt: Tree = tree.tpt): Typed =
+        Typed(tree: Tree)(expr, tpt)
+      def NamedArg(tree: NamedArg)(name: Name = tree.name, arg: Tree = tree.arg): NamedArg =
+        NamedArg(tree: Tree)(name, arg)
+      def Assign(tree: Assign)(lhs: Tree = tree.lhs, rhs: Tree = tree.rhs): Assign =
+        Assign(tree: Tree)(lhs, rhs)
+      def Block(tree: Block)(stats: List[Tree] = tree.stats, expr: Tree = tree.expr): Block =
+        Block(tree: Tree)(stats, expr)
+      def If(tree: If)(cond: Tree = tree.cond, thenp: Tree = tree.thenp, elsep: Tree = tree.elsep): If =
+        If(tree: Tree)(cond, thenp, elsep)
+      def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt): Closure =
+        Closure(tree: Tree)(env, meth, tpt)
+      def Match(tree: Match)(selector: Tree = tree.selector, cases: List[CaseDef] = tree.cases): Match =
+        Match(tree: Tree)(selector, cases)
+      def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body): CaseDef =
+        CaseDef(tree: Tree)(pat, guard, body)
+      def Return(tree: Return)(expr: Tree = tree.expr, from: Tree = tree.from): Return =
+        Return(tree: Tree)(expr, from)
+      def Try(tree: Try)(expr: Tree = tree.expr, handler: Tree = tree.handler, finalizer: Tree = tree.finalizer): Try =
+        Try(tree: Tree)(expr, handler, finalizer)
+      def SelectFromTypeTree(tree: SelectFromTypeTree)(qualifier: Tree = tree.qualifier, name: Name = tree.name):
+        SelectFromTypeTree = SelectFromTypeTree(tree: Tree)(qualifier, name)
+      def RefinedTypeTree(tree: RefinedTypeTree)(tpt: Tree = tree.tpt, refinements: List[Tree] = tree.refinements):
+        RefinedTypeTree = RefinedTypeTree(tree: Tree)(tpt, refinements)
+      def AppliedTypeTree(tree: AppliedTypeTree)(tpt: Tree = tree.tpt, args: List[Tree] = tree.args): AppliedTypeTree =
+        AppliedTypeTree(tree: Tree)(tpt, args)
+      def TypeBoundsTree(tree: TypeBoundsTree)(lo: Tree = tree.lo, hi: Tree = tree.hi): TypeBoundsTree =
+        TypeBoundsTree(tree: Tree)(lo, hi)
+      def Bind(tree: Bind)(name: Name = tree.name, body: Tree = tree.body): Bind =
+        Bind(tree: Tree)(name, body)
+      def UnApply(tree: UnApply)(fun: Tree = tree.fun, implicits: List[Tree] = tree.implicits, patterns: List[Tree] = tree.patterns): UnApply =
+        UnApply(tree: Tree)(fun, implicits, patterns)
+      def ValDef(tree: ValDef)(mods: Modifiers = tree.mods, name: TermName = tree.name, tpt: Tree = tree.tpt, rhs: Tree = tree.rhs): ValDef =
+        ValDef(tree: Tree)(mods, name, tpt, rhs)
+      def DefDef(tree: DefDef)(mods: Modifiers = tree.mods, name: TermName = tree.name, tparams: List[TypeDef] = tree.tparams, vparamss: List[List[ValDef]] = tree.vparamss, tpt: Tree = tree.tpt, rhs: Tree = tree.rhs): DefDef =
+        DefDef(tree: Tree)(mods, name, tparams, vparamss, tpt, rhs)
+      def TypeDef(tree: TypeDef)(mods: Modifiers = tree.mods, name: TypeName = tree.name, rhs: Tree = tree.rhs, tparams: List[untpd.TypeDef] = tree.tparams): TypeDef =
+        TypeDef(tree: Tree)(mods, name, rhs, tparams)
+      def Template(tree: Template)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, self: ValDef = tree.self, body: List[Tree] = tree.body): Template =
+        Template(tree: Tree)(constr, parents, self, body)
+      def Import(tree: Import)(expr: Tree = tree.expr, selectors: List[untpd.Tree] = tree.selectors): Import =
+        Import(tree: Tree)(expr, selectors)
+      def PackageDef(tree: PackageDef)(pid: RefTree = tree.pid, stats: List[Tree] = tree.stats): PackageDef =
+        PackageDef(tree: Tree)(pid, stats)
+      def Annotated(tree: Annotated)(annot: Tree = tree.annot, arg: Tree = tree.arg): Annotated =
+        Annotated(tree: Tree)(annot, arg)
     }
 
     abstract class TreeMap(val cpy: TreeCopier = inst.cpy) {
@@ -1100,88 +1158,88 @@ object Trees {
         case Ident(name) =>
           tree
         case Select(qualifier, name) =>
-          cpy.Select(tree, transform(qualifier), name)
+          cpy.Select(tree)(transform(qualifier), name)
         case This(qual) =>
           tree
         case Super(qual, mix) =>
-          cpy.Super(tree, transform(qual), mix)
+          cpy.Super(tree)(transform(qual), mix)
         case Apply(fun, args) =>
-          cpy.Apply(tree, transform(fun), transform(args))
+          cpy.Apply(tree)(transform(fun), transform(args))
         case TypeApply(fun, args) =>
-          cpy.TypeApply(tree, transform(fun), transform(args))
+          cpy.TypeApply(tree)(transform(fun), transform(args))
+        case Literal(const) =>
+          tree
         case New(tpt) =>
-          cpy.New(tree, transform(tpt))
+          cpy.New(tree)(transform(tpt))
+        case Pair(left, right) =>
+          cpy.Pair(tree)(transform(left), transform(right))
         case Typed(expr, tpt) =>
-          cpy.Typed(tree, transform(expr), transform(tpt))
+          cpy.Typed(tree)(transform(expr), transform(tpt))
         case NamedArg(name, arg) =>
-          cpy.NamedArg(tree, name, transform(arg))
+          cpy.NamedArg(tree)(name, transform(arg))
         case Assign(lhs, rhs) =>
-          cpy.Assign(tree, transform(lhs), transform(rhs))
+          cpy.Assign(tree)(transform(lhs), transform(rhs))
+        case Block(stats, expr) =>
+          cpy.Block(tree)(transformStats(stats), transform(expr))
+        case If(cond, thenp, elsep) =>
+          cpy.If(tree)(transform(cond), transform(thenp), transform(elsep))
         case Closure(env, meth, tpt) =>
-          cpy.Closure(tree, transform(env), transform(meth), transform(tpt))
+          cpy.Closure(tree)(transform(env), transform(meth), transform(tpt))
+        case Match(selector, cases) =>
+          cpy.Match(tree)(transform(selector), transformSub(cases))
+        case CaseDef(pat, guard, body) =>
+          cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body))
         case Return(expr, from) =>
-          cpy.Return(tree, transform(expr), transformSub(from))
+          cpy.Return(tree)(transform(expr), transformSub(from))
+        case Try(block, handler, finalizer) =>
+          cpy.Try(tree)(transform(block), transform(handler), transform(finalizer))
         case Throw(expr) =>
-          cpy.Throw(tree, transform(expr))
+          cpy.Throw(tree)(transform(expr))
+        case SeqLiteral(elems) =>
+          cpy.SeqLiteral(tree)(transform(elems))
         case TypeTree(original) =>
           tree
         case SingletonTypeTree(ref) =>
-          cpy.SingletonTypeTree(tree, transform(ref))
+          cpy.SingletonTypeTree(tree)(transform(ref))
         case SelectFromTypeTree(qualifier, name) =>
-          cpy.SelectFromTypeTree(tree, transform(qualifier), name)
+          cpy.SelectFromTypeTree(tree)(transform(qualifier), name)
         case AndTypeTree(left, right) =>
-          cpy.AndTypeTree(tree, transform(left), transform(right))
+          cpy.AndTypeTree(tree)(transform(left), transform(right))
         case OrTypeTree(left, right) =>
-          cpy.OrTypeTree(tree, transform(left), transform(right))
+          cpy.OrTypeTree(tree)(transform(left), transform(right))
         case RefinedTypeTree(tpt, refinements) =>
-          cpy.RefinedTypeTree(tree, transform(tpt), transformSub(refinements))
+          cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
         case AppliedTypeTree(tpt, args) =>
-          cpy.AppliedTypeTree(tree, transform(tpt), transform(args))
+          cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
         case ByNameTypeTree(result) =>
-          cpy.ByNameTypeTree(tree, transform(result))
+          cpy.ByNameTypeTree(tree)(transform(result))
         case TypeBoundsTree(lo, hi) =>
-          cpy.TypeBoundsTree(tree, transform(lo), transform(hi))
+          cpy.TypeBoundsTree(tree)(transform(lo), transform(hi))
         case Bind(name, body) =>
-          cpy.Bind(tree, name, transform(body))
+          cpy.Bind(tree)(name, transform(body))
         case Alternative(trees) =>
-          cpy.Alternative(tree, transform(trees))
+          cpy.Alternative(tree)(transform(trees))
         case UnApply(fun, implicits, patterns) =>
-          cpy.UnApply(tree, transform(fun), transform(implicits), transform(patterns))
+          cpy.UnApply(tree)(transform(fun), transform(implicits), transform(patterns))
         case EmptyValDef =>
           tree
         case ValDef(mods, name, tpt, rhs) =>
-          cpy.ValDef(tree, mods, name, transform(tpt), transform(rhs))
+          cpy.ValDef(tree)(mods, name, transform(tpt), transform(rhs))
         case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          cpy.DefDef(tree, mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(rhs))
+          cpy.DefDef(tree)(mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(rhs))
         case tree @ TypeDef(mods, name, rhs) =>
-          cpy.TypeDef(tree, mods, name, transform(rhs), tree.tparams)
+          cpy.TypeDef(tree)(mods, name, transform(rhs), tree.tparams)
         case Template(constr, parents, self, body) =>
-          cpy.Template(tree, transformSub(constr), transform(parents), transformSub(self), transformStats(body))
+          cpy.Template(tree)(transformSub(constr), transform(parents), transformSub(self), transformStats(body))
         case Import(expr, selectors) =>
-          cpy.Import(tree, transform(expr), selectors)
+          cpy.Import(tree)(transform(expr), selectors)
         case PackageDef(pid, stats) =>
-          cpy.PackageDef(tree, transformSub(pid), transformStats(stats))
+          cpy.PackageDef(tree)(transformSub(pid), transformStats(stats))
+        case Annotated(annot, arg) =>
+          cpy.Annotated(tree)(transform(annot), transform(arg))
         case Thicket(trees) =>
           val trees1 = transform(trees)
           if (trees1 eq trees) tree else Thicket(trees1)
-        case Literal(const) =>
-          tree
-        case Pair(left, right) =>
-          cpy.Pair(tree, transform(left), transform(right))
-        case Block(stats, expr) =>
-          cpy.Block(tree, transformStats(stats), transform(expr))
-        case If(cond, thenp, elsep) =>
-          cpy.If(tree, transform(cond), transform(thenp), transform(elsep))
-        case Match(selector, cases) =>
-          cpy.Match(tree, transform(selector), transformSub(cases))
-        case CaseDef(pat, guard, body) =>
-          cpy.CaseDef(tree, transform(pat), transform(guard), transform(body))
-        case Try(block, handler, finalizer) =>
-          cpy.Try(tree, transform(block), transform(handler), transform(finalizer))
-        case SeqLiteral(elems) =>
-          cpy.SeqLiteral(tree, transform(elems))
-        case Annotated(annot, arg) =>
-          cpy.Annotated(tree, transform(annot), transform(arg))
       }
 
       def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 81f48cd37..1ba3f223a 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -440,49 +440,49 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case tree@Select(qualifier, name) =>
-        val tree1 = cpy.Select(tree, transform(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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        val tree1 = cpy.Annotated(tree)(annot1, arg1)
         propagateType(tree, tree1)
       case _ => super.transform(tree)
     }
@@ -508,18 +508,18 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         case ddef @ DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
           val (tmap1, tparams1) = transformDefs(ddef.tparams)
           val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)
-          cpy.DefDef(ddef, mods, name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(rhs))
+          cpy.DefDef(ddef)(mods, name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(rhs))
         case blk @ Block(stats, expr) =>
           val (tmap1, stats1) = transformDefs(stats)
           val expr1 = tmap1.transform(expr)
-          val tree1 = cpy.Block(blk, stats1, expr1)
+          val tree1 = cpy.Block(blk)(stats1, expr1)
           propagateType(blk, tree1)
         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)
+          val tree1 = cpy.CaseDef(tree)(pat1, guard1, rhs1)
           propagateType(cdef, tree1)
         case tree1 =>
           super.transform(tree1)
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)
     }
diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index 0ad33a96c..522d94243 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -274,9 +274,9 @@ object Parsers {
      */
     def convertToTypeId(tree: Tree): Tree = tree match {
       case id @ Ident(name) =>
-        cpy.Ident(id, name.toTypeName)
+        cpy.Ident(id)(name.toTypeName)
       case id @ Select(qual, name) =>
-        cpy.Select(id, qual, name.toTypeName)
+        cpy.Select(id)(qual, name.toTypeName)
       case _ =>
         syntaxError("identifier expected", tree.pos)
         tree
@@ -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)(vd.mods, vd.name, tpt, vd.rhs) :: rest
           }
           Typed(t, tpt)
       }
@@ -1096,7 +1096,7 @@ object Parsers {
       if (in.token == LBRACE) blockExpr() :: Nil else parArgumentExprs()
 
     val argumentExpr = () => exprInParens() match {
-      case a @ Assign(Ident(id), rhs) => cpy.NamedArg(a, id, rhs)
+      case a @ Assign(Ident(id), rhs) => cpy.NamedArg(a)(id, rhs)
       case e => e
     }
 
@@ -1409,8 +1409,8 @@ object Parsers {
     /** Adjust start of annotation or constructor to position of preceding @ or new */
     def adjustStart(start: Offset)(tree: Tree): Tree = {
       val tree1 = tree match {
-        case Apply(fn, args) => cpy.Apply(tree, adjustStart(start)(fn), args)
-        case Select(qual, name) => cpy.Select(tree, adjustStart(start)(qual), name)
+        case Apply(fn, args) => cpy.Apply(tree)(adjustStart(start)(fn), args)
+        case Select(qual, name) => cpy.Select(tree)(adjustStart(start)(qual), name)
         case _ => tree
       }
       if (start < tree1.pos.start) tree1.withPos(tree1.pos.withStart(start))
@@ -1605,7 +1605,7 @@ object Parsers {
         imp
       case sel @ Select(qual, name) =>
         val selector = atPos(sel.pos.point) { Ident(name) }
-        cpy.Import(sel, qual, selector :: Nil)
+        cpy.Import(sel)(qual, selector :: Nil)
       case t =>
         accept(DOT)
         Import(t, Ident(nme.WILDCARD) :: Nil)
@@ -1687,7 +1687,7 @@ object Parsers {
           }
         } else EmptyTree
       lhs match {
-        case (id @ Ident(name: TermName)) :: Nil => cpy.ValDef(id, mods, name, tpt, rhs)
+        case (id @ Ident(name: TermName)) :: Nil => cpy.ValDef(id)(mods, name, tpt, rhs)
         case _ => PatDef(mods, lhs, tpt, rhs)
       }
     }
diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index 33d742a17..890948715 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/src/dotty/tools/dotc/transform/Constructors.scala
@@ -16,12 +16,11 @@ class Constructors extends MiniPhaseTransform {
     if(tree.symbol.isClassConstructor) {
       val claz = tree.symbol.enclosingClass.asClass
       val zuper = claz.info.parents.head.typeSymbol
-      cpy.DefDef(tree, tree.mods, tree.name, tree.tparams, tree.vparamss, tree.tpt, rhs = {
+      cpy.DefDef(tree)(rhs = {
         val parentCall =
           Super(This(claz), tpnme.EMPTY, true).select(zuper.primaryConstructor).appliedToNone
         if(tree.rhs.isEmpty) parentCall
         else Block(List(parentCall), tree.rhs)
-
       })
     } else tree
   }
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index 06e3506df..6b2a5a676 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -225,7 +225,7 @@ object Erasure {
       assert(sym.exists, tree.show)
 
       def select(qual: Tree, sym: Symbol): Tree =
-        untpd.cpy.Select(tree, qual, sym.name) withType qual.tpe.select(sym)
+        untpd.cpy.Select(tree)(qual, sym.name) withType qual.tpe.select(sym)
 
       def selectArrayMember(qual: Tree, erasedPre: Type) =
         if (erasedPre isRef defn.ObjectClass) runtimeCall(tree.name.genericArrayOp, qual :: Nil)
@@ -257,7 +257,7 @@ object Erasure {
       fun1.tpe.widen match {
         case funTpe: PolyType =>
           val args1 = args.mapconserve(typedType(_))
-          untpd.cpy.TypeApply(tree, fun1, args1).withType(funTpe.instantiate(args1.tpes))
+          untpd.cpy.TypeApply(tree)(fun1, args1).withType(funTpe.instantiate(args1.tpes))
         case _ => fun1
       }
     }
@@ -268,7 +268,7 @@ object Erasure {
       fun1.tpe.widen match {
         case mt: MethodType =>
           val args1 = args.zipWithConserve(mt.paramTypes)(typedExpr)
-          untpd.cpy.Apply(tree, fun1, args1) withType mt.resultType
+          untpd.cpy.Apply(tree)(fun1, args1) withType mt.resultType
         case _ =>
           throw new MatchError(i"tree $tree has uxpected type of function ${fun1.tpe.widen}, was ${fun.typeOpt.widen}")
       }
@@ -284,7 +284,7 @@ object Erasure {
       val tpt1 = // keep UnitTypes intact in result position
         if (ddef.tpt.typeOpt isRef defn.UnitClass) untpd.TypeTree(defn.UnitType) withPos ddef.tpt.pos
         else ddef.tpt
-      val ddef1 = untpd.cpy.DefDef(ddef, ddef.mods, ddef.name, Nil, ddef.vparamss, tpt1, ddef.rhs)
+      val ddef1 = untpd.cpy.DefDef(ddef)(tparams = Nil, tpt = tpt1)
       super.typedDefDef(ddef1, sym)
     }
 
diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index ba5b9fab6..e05852dc2 100644
--- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -165,7 +165,7 @@ class ExtensionMethods extends MacroTransform with DenotTransformer with FullPar
             val tree1 @ Template(constr, parents, selfType, 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)(constr, parents, selfType, body ++ defns)
               case _ =>
                 tree1
             }
@@ -178,7 +178,7 @@ class ExtensionMethods extends MacroTransform with DenotTransformer with FullPar
           val extensionMeth = extensionMethod(origMeth)
           ctx.log(s"Value class $origClass spawns extension method.\n  Old: ${origMeth.showDcl}\n  New: ${extensionMeth.showDcl}")
           extensionDefs(staticClass) += fullyParameterizedDef(extensionMeth, ddef)
-          cpy.DefDef(tree, ddef.mods, ddef.name, ddef.tparams, ddef.vparamss, ddef.tpt,
+          cpy.DefDef(tree)(ddef.mods, ddef.name, ddef.tparams, ddef.vparamss, ddef.tpt,
               forwarder(extensionMeth, ddef))
         case _ =>
           super.transform(tree)
diff --git a/src/dotty/tools/dotc/transform/MacroTransform.scala b/src/dotty/tools/dotc/transform/MacroTransform.scala
index 0ee92bccd..6f38c98a9 100644
--- a/src/dotty/tools/dotc/transform/MacroTransform.scala
+++ b/src/dotty/tools/dotc/transform/MacroTransform.scala
@@ -47,7 +47,7 @@ abstract class MacroTransform extends Phase {
       val exprCtx = ctx.withOwner(exprOwner)
       def transformStat(stat: Tree): Tree = stat match {
         case _: Import | _: DefTree => transform(stat)
-        case Thicket(stats) => cpy.Thicket(stat, stats mapConserve transformStat)
+        case Thicket(stats) => cpy.Thicket(stat)(stats mapConserve transformStat)
         case _ => transform(stat)(exprCtx)
       }
       flatten(trees.mapconserve(transformStat(_)))
@@ -60,7 +60,7 @@ abstract class MacroTransform extends Phase {
         case _: PackageDef | _: MemberDef =>
           super.transform(tree)(localCtx(tree))
         case Template(constr, parents, self, body) =>
-          cpy.Template(tree,
+          cpy.Template(tree)(
             transformSub(constr),
             transform(parents),
             transformSelf(self),
@@ -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)(vd.mods, vd.name, transform(vd.tpt), vd.rhs)
   }
 }
diff --git a/src/dotty/tools/dotc/transform/Nullarify.scala b/src/dotty/tools/dotc/transform/Nullarify.scala
index 5756d848a..6ecb095b4 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)(tree.fun, args1) withType nullarify(tree.tpe)
   }
 
   /** Insert () or .apply() if the term refers to something that was converted to a
@@ -108,16 +108,15 @@ class Nullarify extends MiniPhaseTransform with InfoTransformer {
     insertParens(tree)
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    val DefDef(mods, name, tparams, vparamss, tpt, rhs) = tree
     val vparamss1 =
-      if (vparamss.isEmpty) Nil :: Nil
-      else vparamss nestedMap { vparam =>
+      if (tree.vparamss.isEmpty) Nil :: Nil
+      else tree.vparamss nestedMap { vparam =>
         val tp = vparam.tpt.tpe
         val tp1 = nullarifyParam(tp)
         if (tp eq tp1) vparam
-        else cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt.withType(tp1), vparam.rhs)
+        else cpy.ValDef(vparam)(tpt = vparam.tpt.withType(tp1))
       }
-    cpy.DefDef(tree, mods, name, tparams, vparamss1, tpt, rhs)
+    cpy.DefDef(tree)(vparamss = vparamss1)
   }
 
   def nullarify(tp: Type)(implicit ctx: Context): Type = tp match {
diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 373fae12f..fdda670b1 100644
--- a/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -22,5 +22,5 @@ class PatternMatcher extends MiniPhaseTransform {
   override def name: String = "patternMatcher"
 
   override def transformCaseDef(tree: CaseDef)(implicit ctx: Context, info: TransformerInfo): Tree =
-    cpy.CaseDef(tree, Literal(Constant("<eliminated pattern>")), tree.guard, tree.body)
+    cpy.CaseDef(tree)(Literal(Constant("<eliminated pattern>")), tree.guard, tree.body)
 }
\ 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 2496cf5a9..62dd7f0c0 100644
--- a/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -222,7 +222,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
         // Don't transform patterns or strange trees will reach the matcher (ticket #4062)
         // TODO Query `ctx.mode is Pattern` instead.
         case CaseDef(pat, guard, body) =>
-          cpy.CaseDef(tree, pat, transform(guard), transform(body))
+          cpy.CaseDef(tree)(pat, transform(guard), transform(body))
 
         case TypeDef(_, _, impl: Template) =>
           val cls = sym.asClass
@@ -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(tree)(impl.constr, impl.parents, impl.self, body1)
           }
           transformTemplate
 
@@ -368,9 +368,9 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
           }
           transformSelect
 
-        case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          val rhs1 = if (isMethodWithExtension(sym)) withInvalidOwner(transform(rhs)) else transform(rhs)
-          cpy.DefDef(tree, mods, name, tparams, vparamss, tpt, rhs1)
+        case tree@DefDef(_, _, _, _, _, rhs) =>
+          cpy.DefDef(tree)(
+            rhs = if (isMethodWithExtension(sym)) withInvalidOwner(transform(rhs)) else transform(rhs))
 
         case TypeApply(sel @ Select(qual, name), args) =>
           mayNeedProtectedAccessor(sel, args, goToSuper = true)
@@ -391,7 +391,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
 
         case Apply(fn, args) =>
           val MethodType(_, formals) = fn.tpe.widen
-          cpy.Apply(tree, transform(fn), transformArgs(formals, args))
+          cpy.Apply(tree)(transform(fn), transformArgs(formals, args))
 
         case _ =>
           super.transform(tree)
diff --git a/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
index 4f9b2c9fa..383abc186 100644
--- a/src/dotty/tools/dotc/transform/SyntheticMethods.scala
+++ b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
@@ -167,8 +167,8 @@ class SyntheticMethods extends MiniPhaseTransform with IdentityDenotTransformer
 
   override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) =
     if (ctx.owner.is(Case) || isDerivedValueClass(ctx.owner))
-      cpy.Template(impl, impl.constr, impl.parents, impl.self,
-          impl.body ++ syntheticMethods(ctx.owner.asClass)(ctx.withPhase(thisTransformer.next)))
+      cpy.Template(impl)(
+        body = impl.body ++ syntheticMethods(ctx.owner.asClass)(ctx.withPhase(thisTransformer.next)))
     else
       impl
 }
diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala
index fd414a225..359859cec 100644
--- a/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/src/dotty/tools/dotc/transform/TailRec.scala
@@ -84,7 +84,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
       case dd@DefDef(mods, name, tparams, vparamss0, tpt, rhs0)
         if (dd.symbol.isEffectivelyFinal) && !((dd.symbol is Flags.Accessor) || (rhs0 eq EmptyTree) || (dd.symbol is Flags.Label)) =>
         val mandatory = dd.symbol.hasAnnotation(defn.TailrecAnnotationClass)
-        cpy.DefDef(tree, mods, name, tparams, vparamss0, tpt, rhs = {
+        cpy.DefDef(dd)(rhs = {
 
             val origMeth = tree.symbol
             val label = mkLabel(dd.symbol)
@@ -105,8 +105,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
             }
 
             if (rewrote) {
-              val dummyDefDef = cpy.DefDef(tree, dd.mods, dd.name, dd.tparams, dd.vparamss, dd.tpt,
-                rhsSemiTransformed)
+              val dummyDefDef = cpy.DefDef(tree)(rhs = rhsSemiTransformed)
               val res = fullyParameterizedDef(label, dummyDefDef)
               val call = forwarder(label, dd)
               Block(List(res), call)
@@ -233,21 +232,21 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
         def transformHandlers(t: Tree): Tree = {
           t match {
             case Block(List((d: DefDef)), cl@Closure(Nil, _, EmptyTree)) =>
-              val newDef = cpy.DefDef(d, d.mods, d.name, d.tparams, d.vparamss, d.tpt, transform(d.rhs))
+              val newDef = cpy.DefDef(d)(rhs = transform(d.rhs))
               Block(List(newDef), cl)
             case _ => assert(false, s"failed to deconstruct try handler ${t.show}"); ???
           }
         }
         if (tree.finalizer eq EmptyTree) {
           // SI-1672 Catches are in tail position when there is no finalizer
-          tpd.cpy.Try(tree,
+          tpd.cpy.Try(tree)(
             noTailTransform(tree.expr),
             transformHandlers(tree.handler),
             EmptyTree
           )
         }
         else {
-          tpd.cpy.Try(tree,
+          tpd.cpy.Try(tree)(
             noTailTransform(tree.expr),
             noTailTransform(tree.handler),
             noTailTransform(tree.finalizer)
@@ -258,18 +257,18 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
       val res: Tree = tree match {
 
         case tree@Block(stats, expr) =>
-          val tree1 = tpd.cpy.Block(tree,
+          val tree1 = tpd.cpy.Block(tree)(
             noTailTransforms(stats),
             transform(expr)
           )
           propagateType(tree, tree1)
 
-        case tree@CaseDef(pat, guard, body) =>
-          val tree1 = cpy.CaseDef(tree, pat, guard, transform(body))
+        case tree@CaseDef(_, _, body) =>
+          val tree1 = cpy.CaseDef(tree)(body = transform(body))
           propagateType(tree, tree1)
 
         case tree@If(cond, thenp, elsep) =>
-          val tree1 = tpd.cpy.If(tree,
+          val tree1 = tpd.cpy.If(tree)(
             noTailTransform(cond),
             transform(thenp),
             transform(elsep)
@@ -277,7 +276,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
           propagateType(tree, tree1)
 
         case tree@Match(selector, cases) =>
-          val tree1 = tpd.cpy.Match(tree,
+          val tree1 = tpd.cpy.Match(tree)(
             noTailTransform(selector),
             transformSub(cases)
           )
@@ -288,7 +287,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
           propagateType(tree, tree1)
 
         case Apply(fun, args) if fun.symbol == defn.Boolean_|| || fun.symbol == defn.Boolean_&& =>
-          tpd.cpy.Apply(tree, fun, transform(args))
+          tpd.cpy.Apply(tree)(fun, transform(args))
 
         case Apply(fun, args) =>
           rewriteApply(tree, fun.symbol)
@@ -300,7 +299,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 propagateType(tree, tpd.cpy.Select(tree)(noTailTransform(tree.qualifier), tree.name))
 
         case ValDef(_, _, _, _) | EmptyTree | Super(_, _) | This(_) |
              Literal(_) | TypeTree(_) | DefDef(_, _, _, _, _, _) | TypeDef(_, _, _) =>
diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index 129553264..4ac6d9aad 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -898,7 +898,7 @@ object TreeTransforms {
         case tree: UnApply => goUnApply(tree, info.nx.nxTransUnApply(cur))
         case tree: Template => goTemplate(tree, info.nx.nxTransTemplate(cur))
         case tree: PackageDef => goPackageDef(tree, info.nx.nxTransPackageDef(cur))
-        case Thicket(trees) => cpy.Thicket(tree, transformTrees(trees, info, cur))
+        case Thicket(trees) => cpy.Thicket(tree)(transformTrees(trees, info, cur))
         case tree => goOther(tree, info.nx.nxTransOther(cur))
       }
 
@@ -930,21 +930,21 @@ object TreeTransforms {
           if (mutatedInfo eq null) tree
           else {
             val qual = transform(tree.qualifier, mutatedInfo, cur)
-            goSelect(cpy.Select(tree, qual, tree.name), mutatedInfo.nx.nxTransSelect(cur))
+            goSelect(cpy.Select(tree)(qual, tree.name), mutatedInfo.nx.nxTransSelect(cur))
           }
         case tree: SelectFromTypeTree =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSelectFromTypeTree, info.nx.nxPrepSelectFromTypeTree, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val qual = transform(tree.qualifier, mutatedInfo, cur)
-            goSelectFromTypeTree(cpy.SelectFromTypeTree(tree, qual, tree.name), mutatedInfo.nx.nxTransSelectFromTypeTree(cur))
+            goSelectFromTypeTree(cpy.SelectFromTypeTree(tree)(qual, tree.name), mutatedInfo.nx.nxTransSelectFromTypeTree(cur))
           }
         case tree: Bind =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBind, info.nx.nxPrepBind, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val body = transform(tree.body, mutatedInfo, mutatedInfo.nx.nxTransBind(cur))
-            goBind(cpy.Bind(tree, tree.name, body), cur)
+            goBind(cpy.Bind(tree)(tree.name, body), cur)
           }
         case tree: ValDef if !tree.isEmpty => // As a result of discussing with Martin: emptyValDefs shouldn't be copied // NAME
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForValDef, info.nx.nxPrepValDef, tree, cur)
@@ -953,7 +953,7 @@ object TreeTransforms {
             val nestedCtx = if (tree.symbol.exists) localContext(tree.symbol) else ctx
             val tpt = transform(tree.tpt, mutatedInfo, cur)(nestedCtx)
             val rhs = transform(tree.rhs, mutatedInfo, cur)(nestedCtx)
-            goValDef(cpy.ValDef(tree, tree.mods, tree.name, tpt, rhs), mutatedInfo.nx.nxTransValDef(cur))
+            goValDef(cpy.ValDef(tree)(tree.mods, tree.name, tpt, rhs), mutatedInfo.nx.nxTransValDef(cur))
           }
         case tree: DefDef =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForDefDef, info.nx.nxPrepDefDef, tree, cur)
@@ -964,14 +964,14 @@ object TreeTransforms {
             val vparams = tree.vparamss.mapConserve(x => transformSubTrees(x, mutatedInfo, cur)(nestedCtx))
             val tpt = transform(tree.tpt, mutatedInfo, cur)(nestedCtx)
             val rhs = transform(tree.rhs, mutatedInfo, cur)(nestedCtx)
-            goDefDef(cpy.DefDef(tree, tree.mods, tree.name, tparams, vparams, tpt, rhs), mutatedInfo.nx.nxTransDefDef(cur))
+            goDefDef(cpy.DefDef(tree)(tree.mods, tree.name, tparams, vparams, tpt, rhs), mutatedInfo.nx.nxTransDefDef(cur))
           }
         case tree: TypeDef =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeDef, info.nx.nxPrepTypeDef, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val rhs = transform(tree.rhs, mutatedInfo, cur)(localContext(tree.symbol))
-            goTypeDef(cpy.TypeDef(tree, tree.mods, tree.name, rhs, tree.tparams), mutatedInfo.nx.nxTransTypeDef(cur))
+            goTypeDef(cpy.TypeDef(tree)(tree.mods, tree.name, rhs, tree.tparams), mutatedInfo.nx.nxTransTypeDef(cur))
           }
         case _ =>
           tree
@@ -988,7 +988,7 @@ object TreeTransforms {
           if (mutatedInfo eq null) tree
           else {
             val qual = transform(tree.qual, mutatedInfo, cur)
-            goSuper(cpy.Super(tree, qual, tree.mix), mutatedInfo.nx.nxTransSuper(cur))
+            goSuper(cpy.Super(tree)(qual, tree.mix), mutatedInfo.nx.nxTransSuper(cur))
           }
         case tree: Apply =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForApply, info.nx.nxPrepApply, tree, cur)
@@ -996,7 +996,7 @@ object TreeTransforms {
           else {
             val fun = transform(tree.fun, mutatedInfo, cur)
             val args = transformSubTrees(tree.args, mutatedInfo, cur)
-            goApply(cpy.Apply(tree, fun, args), mutatedInfo.nx.nxTransApply(cur))
+            goApply(cpy.Apply(tree)(fun, args), mutatedInfo.nx.nxTransApply(cur))
           }
         case tree: TypeApply =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeApply, info.nx.nxPrepTypeApply, tree, cur)
@@ -1004,7 +1004,7 @@ object TreeTransforms {
           else {
             val fun = transform(tree.fun, mutatedInfo, cur)
             val args = transformTrees(tree.args, mutatedInfo, cur)
-            goTypeApply(cpy.TypeApply(tree, fun, args), mutatedInfo.nx.nxTransTypeApply(cur))
+            goTypeApply(cpy.TypeApply(tree)(fun, args), mutatedInfo.nx.nxTransTypeApply(cur))
           }
         case tree: Literal =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForLiteral, info.nx.nxPrepLiteral, tree, cur)
@@ -1015,7 +1015,7 @@ object TreeTransforms {
           if (mutatedInfo eq null) tree
           else {
             val tpt = transform(tree.tpt, mutatedInfo, cur)
-            goNew(cpy.New(tree, tpt), mutatedInfo.nx.nxTransNew(cur))
+            goNew(cpy.New(tree)(tpt), mutatedInfo.nx.nxTransNew(cur))
           }
         case tree: Pair =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForPair, info.nx.nxPrepPair, tree, cur)
@@ -1023,7 +1023,7 @@ object TreeTransforms {
           else {
             val left = transform(tree.left, mutatedInfo, cur)
             val right = transform(tree.right, mutatedInfo, cur)
-            goPair(cpy.Pair(tree, left, right), mutatedInfo.nx.nxTransPair(cur))
+            goPair(cpy.Pair(tree)(left, right), mutatedInfo.nx.nxTransPair(cur))
           }
         case tree: Typed =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTyped, info.nx.nxPrepTyped, tree, cur)
@@ -1031,7 +1031,7 @@ object TreeTransforms {
           else {
             val expr = transform(tree.expr, mutatedInfo, cur)
             val tpt = transform(tree.tpt, mutatedInfo, cur)
-            goTyped(cpy.Typed(tree, expr, tpt), mutatedInfo.nx.nxTransTyped(cur))
+            goTyped(cpy.Typed(tree)(expr, tpt), mutatedInfo.nx.nxTransTyped(cur))
           }
         case tree: Assign =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForAssign, info.nx.nxPrepAssign, tree, cur)
@@ -1039,7 +1039,7 @@ object TreeTransforms {
           else {
             val lhs = transform(tree.lhs, mutatedInfo, cur)
             val rhs = transform(tree.rhs, mutatedInfo, cur)
-            goAssign(cpy.Assign(tree, lhs, rhs), mutatedInfo.nx.nxTransAssign(cur))
+            goAssign(cpy.Assign(tree)(lhs, rhs), mutatedInfo.nx.nxTransAssign(cur))
           }
         case tree: Block =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBlock, info.nx.nxPrepBlock, tree, cur)
@@ -1047,7 +1047,7 @@ object TreeTransforms {
           else {
             val stats = transformStats(tree.stats, ctx.owner, mutatedInfo, cur)
             val expr = transform(tree.expr, mutatedInfo, cur)
-            goBlock(cpy.Block(tree, stats, expr), mutatedInfo.nx.nxTransBlock(cur))
+            goBlock(cpy.Block(tree)(stats, expr), mutatedInfo.nx.nxTransBlock(cur))
           }
         case tree: If =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForIf, info.nx.nxPrepIf, tree, cur)
@@ -1056,7 +1056,7 @@ object TreeTransforms {
             val cond = transform(tree.cond, mutatedInfo, cur)
             val thenp = transform(tree.thenp, mutatedInfo, cur)
             val elsep = transform(tree.elsep, mutatedInfo, cur)
-            goIf(cpy.If(tree, cond, thenp, elsep), mutatedInfo.nx.nxTransIf(cur))
+            goIf(cpy.If(tree)(cond, thenp, elsep), mutatedInfo.nx.nxTransIf(cur))
           }
         case tree: Closure =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForClosure, info.nx.nxPrepClosure, tree, cur)
@@ -1065,7 +1065,7 @@ object TreeTransforms {
             val env = transformTrees(tree.env, mutatedInfo, cur)
             val meth = transform(tree.meth, mutatedInfo, cur)
             val tpt = transform(tree.tpt, mutatedInfo, cur)
-            goClosure(cpy.Closure(tree, env, meth, tpt), mutatedInfo.nx.nxTransClosure(cur))
+            goClosure(cpy.Closure(tree)(env, meth, tpt), mutatedInfo.nx.nxTransClosure(cur))
           }
         case tree: Match =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForMatch, info.nx.nxPrepMatch, tree, cur)
@@ -1073,7 +1073,7 @@ object TreeTransforms {
           else {
             val selector = transform(tree.selector, mutatedInfo, cur)
             val cases = transformSubTrees(tree.cases, mutatedInfo, cur)
-            goMatch(cpy.Match(tree, selector, cases), mutatedInfo.nx.nxTransMatch(cur))
+            goMatch(cpy.Match(tree)(selector, cases), mutatedInfo.nx.nxTransMatch(cur))
           }
         case tree: CaseDef =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForCaseDef, info.nx.nxPrepCaseDef, tree, cur)
@@ -1082,7 +1082,7 @@ object TreeTransforms {
             val pat = transform(tree.pat, mutatedInfo, cur)(ctx.withMode(Mode.Pattern))
             val guard = transform(tree.guard, mutatedInfo, cur)
             val body = transform(tree.body, mutatedInfo, cur)
-            goCaseDef(cpy.CaseDef(tree, pat, guard, body), mutatedInfo.nx.nxTransCaseDef(cur))
+            goCaseDef(cpy.CaseDef(tree)(pat, guard, body), mutatedInfo.nx.nxTransCaseDef(cur))
           }
         case tree: Return =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForReturn, info.nx.nxPrepReturn, tree, cur)
@@ -1090,7 +1090,7 @@ object TreeTransforms {
           else {
             val expr = transform(tree.expr, mutatedInfo, cur)
             val from = transform(tree.from, mutatedInfo, cur)
-            goReturn(cpy.Return(tree, expr, from), mutatedInfo.nx.nxTransReturn(cur))
+            goReturn(cpy.Return(tree)(expr, from), mutatedInfo.nx.nxTransReturn(cur))
           }
         case tree: Try =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTry, info.nx.nxPrepTry, tree, cur)
@@ -1099,35 +1099,35 @@ object TreeTransforms {
             val block = transform(tree.expr, mutatedInfo, cur)
             val handler = transform(tree.handler, mutatedInfo, cur)
             val finalizer = transform(tree.finalizer, mutatedInfo, cur)
-            goTry(cpy.Try(tree, block, handler, finalizer), mutatedInfo.nx.nxTransTry(cur))
+            goTry(cpy.Try(tree)(block, handler, finalizer), mutatedInfo.nx.nxTransTry(cur))
           }
         case tree: Throw =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForThrow, info.nx.nxPrepThrow, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val expr = transform(tree.expr, mutatedInfo, cur)
-            goThrow(cpy.Throw(tree, expr), mutatedInfo.nx.nxTransThrow(cur))
+            goThrow(cpy.Throw(tree)(expr), mutatedInfo.nx.nxTransThrow(cur))
           }
         case tree: SeqLiteral =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSeqLiteral, info.nx.nxPrepSeqLiteral, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val elems = transformTrees(tree.elems, mutatedInfo, cur)
-            goSeqLiteral(cpy.SeqLiteral(tree, elems), mutatedInfo.nx.nxTransLiteral(cur))
+            goSeqLiteral(cpy.SeqLiteral(tree)(elems), mutatedInfo.nx.nxTransLiteral(cur))
           }
         case tree: TypeTree =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeTree, info.nx.nxPrepTypeTree, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val original = transform(tree.original, mutatedInfo, cur)
-            goTypeTree(cpy.TypeTree(tree, original), mutatedInfo.nx.nxTransTypeTree(cur))
+            goTypeTree(cpy.TypeTree(tree)(original), mutatedInfo.nx.nxTransTypeTree(cur))
           }
         case tree: Alternative =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForAlternative, info.nx.nxPrepAlternative, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val trees = transformTrees(tree.trees, mutatedInfo, cur)
-            goAlternative(cpy.Alternative(tree, trees), mutatedInfo.nx.nxTransAlternative(cur))
+            goAlternative(cpy.Alternative(tree)(trees), mutatedInfo.nx.nxTransAlternative(cur))
           }
         case tree: UnApply =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForUnApply, info.nx.nxPrepUnApply, tree, cur)
@@ -1136,7 +1136,7 @@ object TreeTransforms {
             val fun = transform(tree.fun, mutatedInfo, cur)
             val implicits = transformTrees(tree.implicits, mutatedInfo, cur)
             val patterns = transformTrees(tree.patterns, mutatedInfo, cur)
-            goUnApply(cpy.UnApply(tree, fun, implicits, patterns), mutatedInfo.nx.nxTransUnApply(cur))
+            goUnApply(cpy.UnApply(tree)(fun, implicits, patterns), mutatedInfo.nx.nxTransUnApply(cur))
           }
         case tree: Template =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTemplate, info.nx.nxPrepTemplate, tree, cur)
@@ -1146,7 +1146,7 @@ object TreeTransforms {
             val parents = transformTrees(tree.parents, mutatedInfo, cur)
             val self = transformSub(tree.self, mutatedInfo, cur)
             val body = transformStats(tree.body, tree.symbol, mutatedInfo, cur)
-            goTemplate(cpy.Template(tree, constr, parents, self, body), mutatedInfo.nx.nxTransTemplate(cur))
+            goTemplate(cpy.Template(tree)(constr, parents, self, body), mutatedInfo.nx.nxTransTemplate(cur))
           }
         case tree: PackageDef =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForPackageDef, info.nx.nxPrepPackageDef, tree, cur)
@@ -1155,9 +1155,9 @@ object TreeTransforms {
             val nestedCtx = localContext(tree.symbol)
             val pid = transformSub(tree.pid, mutatedInfo, cur)
             val stats = transformStats(tree.stats, tree.symbol, mutatedInfo, cur)(nestedCtx)
-            goPackageDef(cpy.PackageDef(tree, pid, stats), mutatedInfo.nx.nxTransPackageDef(cur))
+            goPackageDef(cpy.PackageDef(tree)(pid, stats), mutatedInfo.nx.nxTransPackageDef(cur))
           }
-        case Thicket(trees) => cpy.Thicket(tree, transformTrees(trees, info, cur))
+        case Thicket(trees) => cpy.Thicket(tree)(transformTrees(trees, info, cur))
         case tree =>
           implicit val originalInfo: TransformerInfo = info
           goOther(tree, info.nx.nxTransOther(cur))
@@ -1190,7 +1190,7 @@ object TreeTransforms {
       val exprCtx = ctx.withOwner(exprOwner)
       def transformStat(stat: Tree): Tree = stat match {
         case _: Import | _: DefTree => transform(stat, newInfo, current)
-        case Thicket(stats) => cpy.Thicket(stat, stats mapConserve transformStat)
+        case Thicket(stats) => cpy.Thicket(stat)(stats mapConserve transformStat)
         case _ => transform(stat, newInfo, current)(exprCtx)
       }
       val newTrees = flatten(trees.mapconserve(transformStat))
diff --git a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index ef0359136..93acc8e86 100644
--- a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -34,7 +34,7 @@ class TypeTestsCasts extends MiniPhaseTransform {
         def isPrimitive(tp: Type) = tp.classSymbol.isPrimitiveValueClass
 
         def derivedTree(qual1: Tree, sym: Symbol, tp: Type) =
-          cpy.TypeApply(tree, qual1.select(sym).withPos(qual.pos), List(TypeTree(tp)))
+          cpy.TypeApply(tree)(qual1.select(sym).withPos(qual.pos), List(TypeTree(tp)))
 
         def qualCls = qual.tpe.classSymbol
 
diff --git a/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala b/src/dotty/tools/dotc/transform/UncurryTreeTransform.scala
index f2d8d4d4a..b8a9e8dfe 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)(fn, args ++ tree.args)
       case _ => tree
     }}
 
diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 0991bf4a8..86327d2fc 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -404,7 +404,7 @@ trait Applications extends Compatibility { self: Typer =>
 
     val result = {
       var typedArgs = typedArgBuf.toList
-      val app0 = cpy.Apply(app, normalizedFun, typedArgs)
+      val app0 = cpy.Apply(app)(normalizedFun, typedArgs)
       val app1 =
         if (!success) app0.withType(ErrorType)
         else {
@@ -470,7 +470,7 @@ trait Applications extends Compatibility { self: Typer =>
               failedState.commit()
               failedVal
             } else typedApply(
-              cpy.Apply(tree, untpd.TypedSplice(fun2), proto.typedArgs map untpd.TypedSplice), pt)
+              cpy.Apply(tree)(untpd.TypedSplice(fun2), proto.typedArgs map untpd.TypedSplice), pt)
           }
         case _ =>
           fun1.tpe match {
@@ -527,7 +527,7 @@ trait Applications extends Compatibility { self: Typer =>
         checkBounds(typedArgs, pt, tree.pos)
       case _ =>
     }
-    assignType(cpy.TypeApply(tree, typedFn, typedArgs), typedFn, typedArgs)
+    assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
   }
 
   def typedUnApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = track("typedUnApply") {
@@ -712,14 +712,14 @@ trait Applications extends Compatibility { self: Typer =>
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = (bunchedArgs, argTypes).zipped map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree, unapplyFn, unapplyImplicits, unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits, unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq pt) || ownType.isError) result
         else Typed(result, TypeTree(ownType))
       case tp =>
         val unapplyErr = if (tp.isError) unapplyFn else notAnExtractor(unapplyFn)
         val typedArgsErr = args mapconserve (typed(_, defn.AnyType))
-        cpy.UnApply(tree, unapplyErr, Nil, typedArgsErr) withType ErrorType
+        cpy.UnApply(tree)(unapplyErr, Nil, typedArgsErr) withType ErrorType
     }
   }
 
@@ -881,7 +881,7 @@ trait Applications extends Compatibility { self: Typer =>
     def treeShape(tree: untpd.Tree): Tree = tree match {
       case NamedArg(name, arg) =>
         val argShape = treeShape(arg)
-        cpy.NamedArg(tree, name, argShape).withType(argShape.tpe)
+        cpy.NamedArg(tree)(name, argShape).withType(argShape.tpe)
       case _ =>
         dummyTreeOfType(typeShape(tree))
     }
diff --git a/src/dotty/tools/dotc/typer/EtaExpansion.scala b/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 69b512416..790a848a7 100644
--- a/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -35,9 +35,9 @@ object EtaExpansion {
    */
   def liftAssigned(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = tree match {
     case Apply(fn @ Select(pre, name), args) =>
-      cpy.Apply(tree, cpy.Select(fn, lift(defs, pre), name), liftArgs(defs, fn.tpe, args))
+      cpy.Apply(tree)(cpy.Select(fn)(lift(defs, pre), name), liftArgs(defs, fn.tpe, args))
     case Select(pre, name) =>
-      cpy.Select(tree, lift(defs, pre), name)
+      cpy.Select(tree)(lift(defs, pre), name)
     case _ =>
       tree
   }
@@ -80,11 +80,11 @@ object EtaExpansion {
    */
   def liftApp(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = tree match {
     case Apply(fn, args) =>
-      cpy.Apply(tree, liftApp(defs, fn), liftArgs(defs, fn.tpe, args))
+      cpy.Apply(tree)(liftApp(defs, fn), liftArgs(defs, fn.tpe, args))
     case TypeApply(fn, targs) =>
-      cpy.TypeApply(tree, liftApp(defs, fn), targs)
+      cpy.TypeApply(tree)(liftApp(defs, fn), targs)
     case Select(pre, name) if isPureRef(tree) =>
-      cpy.Select(tree, liftApp(defs, pre), name)
+      cpy.Select(tree)(liftApp(defs, pre), name)
     case Block(stats, expr) =>
       liftApp(defs ++= stats, expr)
     case New(tpt) =>
diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 1002abe4d..638caba5b 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -366,9 +366,9 @@ 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))
+                val mcls1 = cpy.TypeDef(mcls)(mcls.mods, mcls.name,
+                    cpy.Template(impl)(impl.constr, impl.parents, impl.self,
+                        compimpl.body ++ impl.body), Nil)
                 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 392b8dca1..dbf353f9e 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)(qual1, tree.name).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)(qual1, tree.name).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)(tree.name, body1).withType(tree.typeOpt)
   }
 
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context) = impl.symbol
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 2024a993e..cd9ddb0bd 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -272,13 +272,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
     val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
     if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
-    checkValue(assignType(cpy.Select(tree, qual1, tree.name), qual1), pt)
+    checkValue(assignType(cpy.Select(tree)(qual1, tree.name), qual1), pt)
   }
 
   def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): SelectFromTypeTree = track("typedSelectFromTypeTree") {
     val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
     checkLegalPrefix(qual1.tpe, tree.name, qual1.pos)
-    assignType(cpy.SelectFromTypeTree(tree, qual1, tree.name), qual1)
+    assignType(cpy.SelectFromTypeTree(tree)(qual1, tree.name), qual1)
   }
 
   def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = track("typedThis") {
@@ -291,7 +291,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case pt: SelectionProto if pt.name == nme.CONSTRUCTOR => true
       case _ => false
     }
-    assignType(cpy.Super(tree, qual1, tree.mix), qual1, inConstrCall)
+    assignType(cpy.Super(tree)(qual1, tree.mix), qual1, inConstrCall)
   }
 
   def typedLiteral(tree: untpd.Literal)(implicit ctx: Context) = track("typedLiteral") {
@@ -304,11 +304,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         import untpd._
         val x = tpnme.ANON_CLASS
         val clsDef = TypeDef(Modifiers(Final), x, templ)
-        typed(cpy.Block(tree, clsDef :: Nil, New(Ident(x), Nil)), pt)
+        typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
       case _ =>
 	      val tpt1 = typedType(tree.tpt)
 	      checkClassTypeWithStablePrefix(tpt1.tpe, tpt1.pos, traitReq = false)
-        assignType(cpy.New(tree, tpt1), tpt1)
+        assignType(cpy.New(tree)(tpt1), tpt1)
         // todo in a later phase: checkInstantiatable(cls, tpt1.pos)
     }
   }
@@ -320,7 +320,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     val left1 = typed(tree.left, leftProto)
     val right1 = typed(tree.right, rightProto)
-    assignType(cpy.Pair(tree, left1, right1), left1, right1)
+    assignType(cpy.Pair(tree)(left1, right1), left1, right1)
   }
 
   def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = track("typedTyped") {
@@ -329,7 +329,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       val expr1 =
         if (isWildcard) tree.expr withType tpt1.tpe
         else typed(tree.expr, tpt1.tpe)
-      assignType(cpy.Typed(tree, expr1, tpt1), tpt1)
+      assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
     }
     tree.expr match {
       case id: untpd.Ident if (ctx.mode is Mode.Pattern) && isVarPattern(id) =>
@@ -348,15 +348,15 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context) = track("typedNamedArg") {
     val arg1 = typed(tree.arg, pt)
-    assignType(cpy.NamedArg(tree, tree.name, arg1), arg1)
+    assignType(cpy.NamedArg(tree)(tree.name, arg1), arg1)
   }
 
   def typedAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context) = track("typedAssign") {
     tree.lhs match {
       case lhs @ Apply(fn, args) =>
-        typed(cpy.Apply(lhs, untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
+        typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
       case untpd.TypedSplice(Apply(Select(fn, app), args)) if app == nme.apply =>
-        typed(cpy.Apply(fn,
+        typed(cpy.Apply(fn)(
             untpd.Select(untpd.TypedSplice(fn), nme.update),
             (args map untpd.TypedSplice) :+ tree.rhs), pt)
       case lhs =>
@@ -364,10 +364,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         def lhs1 = typed(untpd.TypedSplice(lhsCore))
         lhsCore.tpe match {
           case ref: TermRef if ref.symbol is (Mutable, butNot = Accessor) =>
-            assignType(cpy.Assign(tree, lhs1, typed(tree.rhs, ref.info)))
+            assignType(cpy.Assign(tree)(lhs1, typed(tree.rhs, ref.info)))
           case _ =>
             def reassignmentToVal =
-              errorTree(cpy.Assign(tree, lhsCore, typed(tree.rhs, lhs1.tpe.widen)),
+              errorTree(cpy.Assign(tree)(lhsCore, typed(tree.rhs, lhs1.tpe.widen)),
                   "reassignment to val")
             lhsCore.tpe match {
               case ref: TermRef => // todo: further conditions to impose on getter?
@@ -379,7 +379,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
                     val setterTypeRaw = pre select (setterName, setter)
                     val setterType = ensureAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.pos)
                     val lhs2 = lhsCore.withName(setterName).withType(setterType)
-                    typed(cpy.Apply(tree, untpd.TypedSplice(lhs2), tree.rhs :: Nil))
+                    typed(cpy.Apply(tree)(untpd.TypedSplice(lhs2), tree.rhs :: Nil))
                   case _ =>
                     reassignmentToVal
                 }
@@ -394,7 +394,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val exprCtx = index(tree.stats)
     val stats1 = typedStats(tree.stats, ctx.owner)
     val expr1 = typedExpr(tree.expr, pt)(exprCtx)
-    ensureNoLocalRefs(assignType(cpy.Block(tree, stats1, expr1), stats1, expr1), pt)
+    ensureNoLocalRefs(assignType(cpy.Block(tree)(stats1, expr1), stats1, expr1), pt)
   }
 
   def escapingRefs(block: Block)(implicit ctx: Context): collection.Set[NamedType] = {
@@ -432,11 +432,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     if (leaks.isEmpty) block
     else if (isFullyDefined(pt, ForceDegree.all)) {
       val expr1 = Typed(expr, TypeTree(pt))
-      cpy.Block(block, stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant
+      cpy.Block(block)(stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant
     } else if (!forcedDefined) {
       fullyDefinedType(block.tpe, "block", block.pos)
       val expr1 = Typed(expr, TypeTree(avoid(block.tpe, localSyms(stats))))
-      val block1 = cpy.Block(block, stats, expr1) withType expr1.tpe // no assignType here because avoid is already done
+      val block1 = cpy.Block(block)(stats, expr1) withType expr1.tpe // no assignType here because avoid is already done
       ensureNoLocalRefs(block1, pt, forcedDefined = true)
     } else
       errorTree(block,
@@ -447,13 +447,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val cond1 = typed(tree.cond, defn.BooleanType)
     val thenp1 = typed(tree.thenp, pt)
     val elsep1 = typed(tree.elsep orElse untpd.unitLiteral withPos tree.pos, pt)
-    assignType(cpy.If(tree, cond1, thenp1, elsep1), thenp1, elsep1)
+    assignType(cpy.If(tree)(cond1, thenp1, elsep1), thenp1, elsep1)
   }
 
   def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") {
     val untpd.Function(args, body) = tree
     if (ctx.mode is Mode.Type)
-      typed(cpy.AppliedTypeTree(tree,
+      typed(cpy.AppliedTypeTree(tree)(
         untpd.TypeTree(defn.FunctionClass(args.length).typeRef), args :+ body), pt)
     else {
       val params = args.asInstanceOf[List[untpd.ValDef]]
@@ -491,7 +491,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               val protoArgs = args map (_ withType WildcardType)
               val callProto = FunProto(protoArgs, WildcardType, this)
               val expr1 = typedExpr(expr, callProto)
-              fnBody = cpy.Apply(fnBody, untpd.TypedSplice(expr1), args)
+              fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
               expr1.tpe
           }
         case _ =>
@@ -533,7 +533,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           if (!param.tpt.isEmpty) param
           else {
             val paramTpt = untpd.TypeTree(inferredParamType(param, protoFormal(i)))
-            cpy.ValDef(param, param.mods, param.name, paramTpt, param.rhs)
+            cpy.ValDef(param)(param.mods, param.name, paramTpt, param.rhs)
           }
 
       // Define result type of closure as the expected type, thereby pushing
@@ -569,7 +569,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case tp =>
         throw new Error(i"internal error: closing over non-method $tp, pos = ${tree.pos}")
     }
-    assignType(cpy.Closure(tree, env1, meth1, target), meth1, target)
+    assignType(cpy.Closure(tree)(env1, meth1, target), meth1, target)
   }
 
   def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context) = track("typedMatch") {
@@ -612,7 +612,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             }
             val guard1 = typedExpr(tree.guard, defn.BooleanType)
             val body1 = typedExpr(tree.body, pt)
-            assignType(cpy.CaseDef(tree, pat, guard1, body1), body1)
+            assignType(cpy.CaseDef(tree)(pat, guard1, body1), body1)
           }
           val doCase: () => CaseDef =
             () => caseRest(typedPattern(tree.pat, selType))(ctx.fresh.setNewScope)
@@ -620,7 +620,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         }
 
         val cases1 = tree.cases mapconserve typedCase
-        assignType(cpy.Match(tree, sel1, cases1), cases1)
+        assignType(cpy.Match(tree)(sel1, cases1), cases1)
     }
   }
 
@@ -642,25 +642,25 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     val (from, proto) = enclMethInfo(ctx)
     val expr1 = typedExpr(tree.expr orElse untpd.unitLiteral.withPos(tree.pos), proto)
-    assignType(cpy.Return(tree, expr1, from))
+    assignType(cpy.Return(tree)(expr1, from))
   }
 
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") {
     val expr1 = typed(tree.expr, pt)
     val handler1 = typed(tree.handler, defn.FunctionType(defn.ThrowableType :: Nil, pt))
     val finalizer1 = typed(tree.finalizer, defn.UnitType)
-    assignType(cpy.Try(tree, expr1, handler1, finalizer1), expr1, handler1)
+    assignType(cpy.Try(tree)(expr1, handler1, finalizer1), expr1, handler1)
   }
 
   def typedThrow(tree: untpd.Throw)(implicit ctx: Context): Throw = track("typedThrow") {
     val expr1 = typed(tree.expr, defn.ThrowableType)
-    assignType(cpy.Throw(tree, expr1))
+    assignType(cpy.Throw(tree)(expr1))
   }
 
   def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context): SeqLiteral = track("typedSeqLiteral") {
     val proto1 = pt.elemType orElse WildcardType
     val elems1 = tree.elems mapconserve (typed(_, proto1))
-    assignType(cpy.SeqLiteral(tree, elems1), elems1)
+    assignType(cpy.SeqLiteral(tree)(elems1), elems1)
   }
 
   def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = track("typedTypeTree") {
@@ -685,26 +685,26 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
     else {
       val original1 = typed(tree.original)
-      cpy.TypeTree(tree, original1).withType(original1.tpe)
+      cpy.TypeTree(tree)(original1).withType(original1.tpe)
     }
   }
 
   def typedSingletonTypeTree(tree: untpd.SingletonTypeTree)(implicit ctx: Context): SingletonTypeTree = track("typedSingletonTypeTree") {
     val ref1 = typedExpr(tree.ref)
     checkStable(ref1.tpe, tree.pos)
-    assignType(cpy.SingletonTypeTree(tree, ref1), ref1)
+    assignType(cpy.SingletonTypeTree(tree)(ref1), ref1)
   }
 
   def typedAndTypeTree(tree: untpd.AndTypeTree)(implicit ctx: Context): AndTypeTree = track("typedAndTypeTree") {
     val left1 = typed(tree.left)
     val right1 = typed(tree.right)
-    assignType(cpy.AndTypeTree(tree, left1, right1), left1, right1)
+    assignType(cpy.AndTypeTree(tree)(left1, right1), left1, right1)
   }
 
   def typedOrTypeTree(tree: untpd.OrTypeTree)(implicit ctx: Context): OrTypeTree = track("typedOrTypeTree") {
     val left1 = typed(tree.left)
     val right1 = typed(tree.right)
-    assignType(cpy.OrTypeTree(tree, left1, right1), left1, right1)
+    assignType(cpy.OrTypeTree(tree)(left1, right1), left1, right1)
   }
 
   def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(implicit ctx: Context): RefinedTypeTree = track("typedRefinedTypeTree") {
@@ -726,7 +726,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       RefinedType(parent, rsym.name, rt => rinfo.substThis(refineCls, RefinedThis(rt)))
       // todo later: check that refinement is within bounds
     }
-    val res = cpy.RefinedTypeTree(tree, tpt1, refinements1) withType
+    val res = cpy.RefinedTypeTree(tree)(tpt1, refinements1) withType
       (tpt1.tpe /: refinements1)(addRefinement)
     typr.println(i"typed refinement: ${res.tpe}")
     res
@@ -736,12 +736,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val tpt1 = typed(tree.tpt)
     val args1 = tree.args mapconserve (typed(_))
     // check that arguments conform to bounds is done in phase FirstTransform
-    assignType(cpy.AppliedTypeTree(tree, tpt1, args1), tpt1, args1)
+    assignType(cpy.AppliedTypeTree(tree)(tpt1, args1), tpt1, args1)
   }
 
   def typedByNameTypeTree(tree: untpd.ByNameTypeTree)(implicit ctx: Context): ByNameTypeTree = track("typedByNameTypeTree") {
     val result1 = typed(tree.result)
-    assignType(cpy.ByNameTypeTree(tree, result1), result1)
+    assignType(cpy.ByNameTypeTree(tree)(result1), result1)
   }
 
   def typedTypeBoundsTree(tree: untpd.TypeBoundsTree)(implicit ctx: Context): TypeBoundsTree = track("typedTypeBoundsTree") {
@@ -750,19 +750,19 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val hi1 = typed(hi)
     if (!(lo1.tpe <:< hi1.tpe))
       ctx.error(d"lower bound ${lo1.tpe} does not conform to upper bound ${hi1.tpe}", tree.pos)
-    assignType(cpy.TypeBoundsTree(tree, lo1, hi1), lo1, hi1)
+    assignType(cpy.TypeBoundsTree(tree)(lo1, hi1), lo1, hi1)
   }
 
   def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = track("typedBind") {
     val body1 = typed(tree.body, pt)
     typr.println(i"typed bind $tree pt = $pt bodytpe = ${body1.tpe}")
     val sym = ctx.newSymbol(ctx.owner, tree.name.asTermName, EmptyFlags, body1.tpe, coord = tree.pos)
-    assignType(cpy.Bind(tree, tree.name, body1), sym)
+    assignType(cpy.Bind(tree)(tree.name, body1), sym)
   }
 
   def typedAlternative(tree: untpd.Alternative, pt: Type)(implicit ctx: Context): Alternative = track("typedAlternative") {
     val trees1 = tree.trees mapconserve (typed(_, pt))
-    assignType(cpy.Alternative(tree, trees1), trees1)
+    assignType(cpy.Alternative(tree)(trees1), trees1)
   }
 
   def addTypedModifiersAnnotations(mods: untpd.Modifiers, sym: Symbol)(implicit ctx: Context): Modifiers = {
@@ -789,7 +789,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case Ident(nme.WILDCARD) => rhs withType tpt1.tpe
       case _ => typedExpr(rhs, tpt1.tpe)
     }
-    assignType(cpy.ValDef(vdef, mods1, name, tpt1, rhs1), sym)
+    assignType(cpy.ValDef(vdef)(mods1, name, tpt1, rhs1), sym)
   }
 
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") {
@@ -800,7 +800,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     if (sym is Implicit) checkImplicitParamsNotSingletons(vparamss1)
     val tpt1 = typedType(tpt)
     val rhs1 = typedExpr(rhs, tpt1.tpe)
-    assignType(cpy.DefDef(ddef, mods1, name, tparams1, vparamss1, tpt1, rhs1), sym)
+    assignType(cpy.DefDef(ddef)(mods1, name, tparams1, vparamss1, tpt1, rhs1), sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params
   }
 
@@ -808,7 +808,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val TypeDef(mods, name, rhs) = tdef
     val mods1 = addTypedModifiersAnnotations(mods, sym)
     val _ = typedType(rhs) // unused, typecheck only to remove from typedTree
-    assignType(cpy.TypeDef(tdef, mods1, name, TypeTree(sym.info)), sym)
+    assignType(cpy.TypeDef(tdef)(mods1, name, TypeTree(sym.info), Nil), sym)
   }
 
   def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") {
@@ -841,10 +841,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val dummy = localDummy(cls, impl)
     val body1 = typedStats(body, dummy)(inClassContext(self1.symbol))
     checkNoDoubleDefs(cls)
-    val impl1 = cpy.Template(impl, constr1, parents1, self1, body1)
+    val impl1 = cpy.Template(impl)(constr1, parents1, self1, body1)
       .withType(dummy.termRef)
     checkVariance(impl1)
-    assignType(cpy.TypeDef(cdef, mods1, name, impl1), cls)
+    assignType(cpy.TypeDef(cdef)(mods1, name, impl1, Nil), cls)
 
     // todo later: check that
     //  1. If class is non-abstract, it is instantiatable:
@@ -864,7 +864,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedImport(imp: untpd.Import, sym: Symbol)(implicit ctx: Context): Import = track("typedImport") {
     val expr1 = typedExpr(imp.expr, AnySelectionProto)
     checkStable(expr1.tpe, imp.expr.pos)
-    assignType(cpy.Import(imp, expr1, imp.selectors), sym)
+    assignType(cpy.Import(imp)(expr1, imp.selectors), sym)
   }
 
   def typedPackageDef(tree: untpd.PackageDef)(implicit ctx: Context): Tree = track("typedPackageDef") {
@@ -877,17 +877,17 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         ctx
       }
     val stats1 = typedStats(tree.stats, pkg.moduleClass)(packageContext)
-    cpy.PackageDef(tree, pid1.asInstanceOf[RefTree], stats1) withType pkg.valRef
+    cpy.PackageDef(tree)(pid1.asInstanceOf[RefTree], stats1) withType pkg.valRef
   }
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") {
     val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type)
-      assignType(cpy.Annotated(tree, annot1, arg1), annot1, arg1)
+      assignType(cpy.Annotated(tree)(annot1, arg1), annot1, arg1)
     else {
       val tpt = TypeTree(AnnotatedType(Annotation(annot1), arg1.tpe.widen))
-      assignType(cpy.Typed(tree, arg1, tpt), tpt)
+      assignType(cpy.Typed(tree)(arg1, tpt), tpt)
     }
   }
 
@@ -1074,7 +1074,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         tryEither { implicit ctx =>
           val qual1 = adaptInterpolated(qual, qualProto, EmptyTree)
           if ((qual eq qual1) || ctx.reporter.hasErrors) tree
-          else typedSelect(cpy.Select(tree, untpd.TypedSplice(qual1), name), pt)
+          else typedSelect(cpy.Select(tree)(untpd.TypedSplice(qual1), name), pt)
         } { (_, _) => tree
         }
       case _ => tree
@@ -1253,7 +1253,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the
               // body is typechecked.
-              return cpy.Closure(tree, Nil, id, TypeTree(pt)).withType(pt)
+              return cpy.Closure(tree)(Nil, id, TypeTree(pt)).withType(pt)
             case _ =>
           }
         case _ =>
diff --git a/test/test/DeSugarTest.scala b/test/test/DeSugarTest.scala
index f38706d67..c628a9ad1 100644
--- a/test/test/DeSugarTest.scala
+++ b/test/test/DeSugarTest.scala
@@ -42,29 +42,29 @@ class DeSugarTest extends ParserTest {
         case PostfixOp(od, op) =>
           PostfixOp(transform(od), op)
         case Select(qual, name) =>
-          cpy.Select(tree1, transform(qual, Expr), name)
+          cpy.Select(tree1)(transform(qual, Expr), name)
         case Apply(fn, args) =>
-          cpy.Apply(tree1, transform(fn, Expr), transform(args))
+          cpy.Apply(tree1)(transform(fn, Expr), transform(args))
         case TypeApply(fn, args) =>
-          cpy.TypeApply(tree1, transform(fn, Expr), transform(args, Type))
+          cpy.TypeApply(tree1)(transform(fn, Expr), transform(args, Type))
         case New(tpt) =>
-          cpy.New(tree1, transform(tpt, Type))
+          cpy.New(tree1)(transform(tpt, Type))
         case Typed(expr, tpt) =>
-          cpy.Typed(tree1, transform(expr), transform(tpt, Type))
+          cpy.Typed(tree1)(transform(expr), transform(tpt, Type))
         case CaseDef(pat, guard, body) =>
-          cpy.CaseDef(tree1, transform(pat, Pattern), transform(guard), transform(body))
+          cpy.CaseDef(tree1)(transform(pat, Pattern), transform(guard), transform(body))
         case SeqLiteral(elems) =>
-          cpy.SeqLiteral(tree1, transform(elems))
+          cpy.SeqLiteral(tree1)(transform(elems))
         case UnApply(fun, implicits, patterns) =>
-          cpy.UnApply(tree1, transform(fun, Expr), transform(implicits), transform(patterns))
+          cpy.UnApply(tree1)(transform(fun, Expr), transform(implicits), transform(patterns))
         case ValDef(mods, name, tpt, rhs) =>
-          cpy.ValDef(tree1, mods, name, transform(tpt, Type), transform(rhs))
+          cpy.ValDef(tree1)(mods, name, transform(tpt, Type), transform(rhs))
         case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          cpy.DefDef(tree1, mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt, Type), transform(rhs))
+          cpy.DefDef(tree1)(mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt, Type), transform(rhs))
         case tree1 @ TypeDef(mods, name, rhs) =>
-          cpy.TypeDef(tree1, mods, name, transform(rhs, Type), transformSub(tree1.tparams))
+          cpy.TypeDef(tree1)(mods, name, transform(rhs, Type), transformSub(tree1.tparams))
         case Template(constr, parents, self, body) =>
-          cpy.Template(tree1, transformSub(constr), transform(parents), transformSub(self), transform(body, Expr))
+          cpy.Template(tree1)(transformSub(constr), transform(parents), transformSub(self), transform(body, Expr))
         case Thicket(trees) =>
           Thicket(flatten(trees mapConserve super.transform))
         case tree1 =>
diff --git a/test/test/transform/TreeTransformerTest.scala b/test/test/transform/TreeTransformerTest.scala
index aea372bf4..bfabc2f2c 100644
--- a/test/test/transform/TreeTransformerTest.scala
+++ b/test/test/transform/TreeTransformerTest.scala
@@ -66,7 +66,7 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-1))"
           )
-          tpd.cpy.ValDef(tree, tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(2)))
+          tpd.cpy.ValDef(tree)(tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(2)))
         }
 
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
@@ -95,14 +95,14 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("correct constant",
             tree.const.toString == "Constant(1)"
           )
-          tpd.cpy.Literal(tree, Constant(-1))
+          tpd.cpy.Literal(tree)(Constant(-1))
         }
 
         override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo): tpd.ValDef = {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-1))"
           )
-          tpd.cpy.ValDef(tree, tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(2)))
+          tpd.cpy.ValDef(tree)(tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(2)))
         }
 
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
@@ -113,7 +113,7 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(2))"
           )
-          tpd.cpy.ValDef(tree, tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(3)))
+          tpd.cpy.ValDef(tree)(tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(3)))
         }
 
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
@@ -142,7 +142,7 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("correct constant",
             tree.const.toString == "Constant(1)"
           )
-          tpd.cpy.Literal(tree, Constant(-1))
+          tpd.cpy.Literal(tree)(Constant(-1))
         }
 
         override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo) = {
@@ -150,7 +150,7 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-3))"
           )
-          tpd.cpy.ValDef(tree, tree.mods, tree.name, tree.tpt, transformFollowing(tpd.Literal(Constant(2))))
+          tpd.cpy.ValDef(tree)(tree.mods, tree.name, tree.tpt, transformFollowing(tpd.Literal(Constant(2))))
         }
 
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
@@ -173,7 +173,7 @@ class TreeTransformerTest extends DottyTest {
             case _ => Assert.fail("to many constants seen")
           }
           constantsSeen += 1
-          tpd.cpy.Literal(tree, Constant(-3))
+          tpd.cpy.Literal(tree)(Constant(-3))
         }
 
         override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo) = {
@@ -181,7 +181,7 @@ class TreeTransformerTest extends DottyTest {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-3))"
           )
-          transformFollowing(tpd.cpy.ValDef(tree, tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(3))))
+          transformFollowing(tpd.cpy.ValDef(tree)(tree.mods, tree.name, tree.tpt, tpd.Literal(Constant(3))))
         }
 
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)