diff options
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) |