diff options
author | Martin Odersky <odersky@gmail.com> | 2014-11-10 18:29:58 +0100 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2014-11-10 18:29:58 +0100 |
commit | f7a4d811f769583be13a376a3daedd2eadd31447 (patch) | |
tree | 1c82858472d08575dfb6815d9c70cee92095a79a /src/dotty/tools | |
parent | c9d7eefc0989066e85ca598dff2639d412aabbee (diff) | |
download | dotty-f7a4d811f769583be13a376a3daedd2eadd31447.tar.gz dotty-f7a4d811f769583be13a376a3daedd2eadd31447.tar.bz2 dotty-f7a4d811f769583be13a376a3daedd2eadd31447.zip |
Drop modifiers as separate data from MemberDef trees
Typed MemberDef trees now take the modifiers from their symbol's data.
Diffstat (limited to 'src/dotty/tools')
26 files changed, 284 insertions, 409 deletions
diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala index 3d217f38f..b7786e00c 100644 --- a/src/dotty/tools/dotc/ast/Desugar.scala +++ b/src/dotty/tools/dotc/ast/Desugar.scala @@ -88,7 +88,8 @@ object desugar { * def x_=($1: <TypeTree()>): Unit = () */ def valDef(vdef: ValDef)(implicit ctx: Context): Tree = { - val ValDef(mods, name, tpt, rhs) = vdef + val ValDef(name, tpt, rhs) = vdef + val mods = vdef.mods def setterNeeded = (mods is Mutable) && ctx.owner.isClass && (!(mods is PrivateLocal) || (ctx.owner is Trait)) if (setterNeeded) { @@ -99,8 +100,12 @@ object desugar { val setterParam = makeSyntheticParameter(tpt = (new SetterParamTree).watching(vdef)) val setterRhs = if (vdef.rhs.isEmpty) EmptyTree else unitLiteral val setter = cpy.DefDef(vdef)( - (mods | Accessor) &~ CaseAccessor, name.setterName, Nil, (setterParam :: Nil) :: Nil, - TypeTree(defn.UnitType), setterRhs) // rhs gets filled in later, when field is generated and getter has parameters + name = name.setterName, + tparams = Nil, + vparamss = (setterParam :: Nil) :: Nil, + tpt = TypeTree(defn.UnitType), + rhs = setterRhs + ).withMods((mods | Accessor) &~ CaseAccessor) // rhs gets filled in later, when field is generated and getter has parameters Thicket(vdef, setter) } else vdef @@ -121,15 +126,15 @@ object desugar { * def f$default$2(x: Int) = x + "m" */ def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = { - val DefDef(mods, name, tparams, vparamss, tpt, rhs) = meth + val DefDef(name, tparams, vparamss, tpt, rhs) = meth + val mods = meth.mods val epbuf = new ListBuffer[ValDef] val tparams1 = tparams mapConserve { - case tparam @ TypeDef(_, _, 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) + epbuf += ValDef(epname, cxbound, EmptyTree).withFlags(paramFlags | Implicit) } cpy.TypeDef(tparam)(rhs = tbounds) case tparam => @@ -165,12 +170,12 @@ object desugar { case (vparam :: vparams) :: vparamss1 => def defaultGetter: DefDef = DefDef( - mods = vparam.mods & AccessFlags, name = meth.name.defaultGetterName(n), tparams = meth.tparams map toDefParam, vparamss = takeUpTo(normalizedVparamss, n), tpt = TypeTree(), - rhs = vparam.rhs) + rhs = vparam.rhs + ).withMods(vparam.mods & AccessFlags) val rest = defaultGetters(vparams :: vparamss1, n + 1) if (vparam.rhs.isEmpty) rest else defaultGetter :: rest case Nil :: vparamss1 => @@ -182,9 +187,8 @@ object desugar { val defGetters = defaultGetters(vparamss, 0) if (defGetters.isEmpty) meth1 else { - val meth2 = cpy.DefDef(meth1)( - mods = meth1.mods | DefaultParameterized, - vparamss = normalizedVparamss) + val meth2 = cpy.DefDef(meth1)(vparamss = normalizedVparamss) + .withMods(meth1.mods | DefaultParameterized) Thicket(meth2 :: defGetters) } } @@ -197,13 +201,10 @@ object desugar { */ def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = { if (tdef.mods is PrivateLocalParam) { - val tparam = cpy.TypeDef(tdef)( - mods = tdef.mods &~ PrivateLocal | ExpandedName, - name = tdef.name.expandedName(ctx.owner)) - val alias = cpy.TypeDef(tdef)( - mods = Modifiers(PrivateLocalParamAccessor | Synthetic | tdef.mods.flags & VarianceFlags), - rhs = refOfDef(tparam), - tparams = Nil) + val tparam = cpy.TypeDef(tdef)(name = tdef.name.expandedName(ctx.owner)) + .withMods(tdef.mods &~ PrivateLocal | ExpandedName) + val alias = cpy.TypeDef(tdef)(rhs = refOfDef(tparam), tparams = Nil) + .withFlags(PrivateLocalParamAccessor | Synthetic | tdef.mods.flags & VarianceFlags) Thicket(tparam, alias) } else tdef @@ -211,16 +212,15 @@ object desugar { private val synthetic = Modifiers(Synthetic) - private def toDefParam(tparam: TypeDef) = - cpy.TypeDef(tparam)(mods = Modifiers(Param)) - - private def toDefParam(vparam: ValDef) = - cpy.ValDef(vparam)(mods = Modifiers(Param | vparam.mods.flags & Implicit)) + private def toDefParam(tparam: TypeDef): TypeDef = + tparam.withFlags(Param) + private def toDefParam(vparam: ValDef): ValDef = + vparam.withFlags(Param | vparam.rawMods.flags & Implicit) /** The expansion of a class definition. See inline comments for what is involved */ def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = { - val TypeDef( - mods, name, impl @ Template(constr0, parents, self, body)) = cdef + val TypeDef(name, impl @ Template(constr0, parents, self, body)) = cdef + val mods = cdef.mods val (constr1, defaultGetters) = defDef(constr0, isPrimaryConstructor = true) match { case meth: DefDef => (meth, Nil) @@ -285,7 +285,7 @@ object desugar { val caseClassMeths = if (mods is Case) { def syntheticProperty(name: TermName, rhs: Tree) = - DefDef(synthetic, name, Nil, Nil, TypeTree(), rhs) + DefDef(name, Nil, Nil, TypeTree(), rhs).withMods(synthetic) val isDefinedMeth = syntheticProperty(nme.isDefined, Literal(Constant(true))) val caseParams = constrVparamss.head.toArray val productElemMeths = for (i <- 0 until arity) yield @@ -299,7 +299,8 @@ object desugar { cpy.ValDef(vparam)(rhs = copyDefault(vparam))) val copyRestParamss = derivedVparamss.tail.nestedMap(vparam => cpy.ValDef(vparam)(rhs = EmptyTree)) - DefDef(synthetic, nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr) :: Nil + DefDef(nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr) + .withMods(synthetic) :: Nil } copyMeths ::: isDefinedMeth :: productElemMeths.toList } @@ -322,8 +323,8 @@ object desugar { def companionDefs(parentTpt: Tree, defs: List[Tree]) = moduleDef( ModuleDef( - Modifiers(Synthetic), name.toTermName, - Template(emptyConstructor, parentTpt :: Nil, EmptyValDef, defs))) + name.toTermName, Template(emptyConstructor, parentTpt :: Nil, EmptyValDef, defs)) + .withMods(synthetic)) .withPos(cdef.pos).toList // The companion object defifinitions, if a companion is needed, Nil otherwise. @@ -344,13 +345,13 @@ object desugar { val applyMeths = if (mods is Abstract) Nil else - DefDef( - synthetic | (constr1.mods.flags & DefaultParameterized), nme.apply, - derivedTparams, derivedVparamss, TypeTree(), creatorExpr) :: Nil + DefDef(nme.apply, derivedTparams, derivedVparamss, TypeTree(), creatorExpr) + .withMods(synthetic | (constr1.mods.flags & DefaultParameterized)) :: Nil val unapplyMeth = { val unapplyParam = makeSyntheticParameter(tpt = classTypeRef) val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name) - DefDef(synthetic, nme.unapply, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS) + DefDef(nme.unapply, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS) + .withMods(synthetic) } companionDefs(parent, applyMeths ::: unapplyMeth :: defaultGetters) } @@ -370,27 +371,23 @@ object desugar { // implicit wrapper is typechecked in same scope as constructor, so // we can reuse the constructor parameters; no derived params are needed. - DefDef(Modifiers(Synthetic | Implicit), name.toTermName, - constrTparams, constrVparamss, classTypeRef, creatorExpr) :: Nil + DefDef(name.toTermName, constrTparams, constrVparamss, classTypeRef, creatorExpr) + .withFlags(Synthetic | Implicit) :: Nil } else Nil val self1 = { val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt if (self.isEmpty) self - else cpy.ValDef(self)(mods = self.mods | SelfName, tpt = selfType) + else cpy.ValDef(self)(tpt = selfType).withMods(self.mods | SelfName) } val cdef1 = { val originalTparams = constr1.tparams.toIterator val originalVparams = constr1.vparamss.toIterator.flatten - val tparamAccessors = derivedTparams map { tdef => - cpy.TypeDef(tdef)(mods = originalTparams.next.mods) - } + val tparamAccessors = derivedTparams.map(_.withMods(originalTparams.next.mods)) val caseAccessor = if (mods is Case) CaseAccessor else EmptyFlags - val vparamAccessors = derivedVparamss.flatten map { vdef => - cpy.ValDef(vdef)(mods = originalVparams.next.mods | caseAccessor) - } + val vparamAccessors = derivedVparamss.flatten.map(_.withMods(originalVparams.next.mods | caseAccessor)) cpy.TypeDef(cdef)( rhs = cpy.Template(impl)(constr, parents1, self1, tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths), @@ -415,19 +412,25 @@ object desugar { * <module> final class name$ extends parents { self: name.type => body } */ def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = { - val ModuleDef(mods, name, tmpl) = mdef + val ModuleDef(name, tmpl) = mdef + val mods = mdef.mods if (mods is Package) - PackageDef(Ident(name), cpy.ModuleDef(mdef)(mods &~ Package, nme.PACKAGE, tmpl) :: Nil) + PackageDef(Ident(name), cpy.ModuleDef(mdef)(nme.PACKAGE, tmpl).withMods(mods &~ Package) :: Nil) else { val clsName = name.moduleClassName val clsRef = Ident(clsName) - val modul = ValDef(mods | ModuleCreationFlags, name, clsRef, New(clsRef, Nil)) withPos mdef.pos - val ValDef(selfMods, selfName, selfTpt, selfRhs) = tmpl.self + val modul = ValDef(name, clsRef, New(clsRef, Nil)) + .withMods(mods | ModuleCreationFlags) + .withPos(mdef.pos) + val ValDef(selfName, selfTpt, selfRhs) = tmpl.self + val selfMods = tmpl.self.mods if (!selfTpt.isEmpty) ctx.error("object definition may not have a self type", tmpl.self.pos) - val clsSelf = ValDef(selfMods, selfName, SingletonTypeTree(Ident(name)), selfRhs) + val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(name)), selfRhs) + .withMods(selfMods) .withPos(tmpl.self.pos orElse tmpl.pos.startPos) val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body) - val cls = TypeDef(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags, clsName, clsTmpl) + val cls = TypeDef(clsName, clsTmpl) + .withMods(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags) Thicket(modul, classDef(cls)) } } @@ -459,7 +462,7 @@ object desugar { */ def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree)(implicit ctx: Context): Tree = pat match { case VarPattern(named, tpt) => - derivedValDef(mods, named, tpt, rhs) + derivedValDef(named, tpt, rhs, mods) case _ => val rhsUnchecked = makeAnnotated(defn.UncheckedAnnot, rhs) val vars = getVariables(pat) @@ -476,15 +479,15 @@ object desugar { case Nil => matchExpr case (named, tpt) :: Nil => - derivedValDef(mods, named, tpt, matchExpr) + derivedValDef(named, tpt, matchExpr, mods) case _ => val tmpName = ctx.freshName().toTermName - val patMods = Modifiers(PrivateLocal | Synthetic | (mods.flags & Lazy)) - val firstDef = ValDef(patMods, tmpName, TypeTree(), matchExpr) + val patFlags = PrivateLocal | Synthetic | (mods.flags & Lazy) + val firstDef = ValDef(tmpName, TypeTree(), matchExpr).withFlags(patFlags) def selector(n: Int) = Select(Ident(tmpName), nme.selectorName(n)) val restDefs = for (((named, tpt), n) <- vars.zipWithIndex) - yield derivedValDef(mods, named, tpt, selector(n)) + yield derivedValDef(named, tpt, selector(n), mods) flatTree(firstDef :: restDefs) } } @@ -527,7 +530,7 @@ object desugar { */ def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree()) = Block( - DefDef(Modifiers(Synthetic), nme.ANON_FUN, Nil, params :: Nil, tpt, body), + DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic), Closure(Nil, Ident(nme.ANON_FUN), EmptyTree)) /** Expand partial function @@ -546,8 +549,8 @@ object desugar { def makeAnnotated(cls: Symbol, tree: Tree)(implicit ctx: Context) = Annotated(TypedSplice(tpd.New(cls.typeRef, Nil)), tree) - private def derivedValDef(mods: Modifiers, named: NameTree, tpt: Tree, rhs: Tree) = - ValDef(mods, named.name.asTermName, tpt, rhs).withPos(named.pos) + private def derivedValDef(named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers) = + ValDef(named.name.asTermName, tpt, rhs).withMods(mods).withPos(named.pos) /** Main desugaring method */ def apply(tree: Tree)(implicit ctx: Context): Tree = { @@ -555,7 +558,7 @@ object desugar { /** { label def lname(): Unit = rhs; call } */ def labelDefAndCall(lname: TermName, rhs: Tree, call: Tree) = { - val ldef = DefDef(Modifiers(Label), lname, Nil, ListOfNil, TypeTree(defn.UnitType), rhs) + val ldef = DefDef(lname, Nil, ListOfNil, TypeTree(defn.UnitType), rhs).withFlags(Label) Block(ldef, call) } @@ -576,7 +579,7 @@ object desugar { } else { val x = ctx.freshName().toTermName Block( - ValDef(Modifiers(Synthetic), x, TypeTree(), left), + ValDef(x, TypeTree(), left).withMods(synthetic), Apply(Select(right, op), Ident(x))) } } @@ -637,7 +640,7 @@ object desugar { */ def makeLambda(pat: Tree, body: Tree): Tree = pat match { case VarPattern(named, tpt) => - Function(derivedValDef(Modifiers(Param), named, tpt, EmptyTree) :: Nil, body) + Function(derivedValDef(named, tpt, EmptyTree, Modifiers(Param)) :: Nil, body) case _ => makeCaseLambda(CaseDef(pat, EmptyTree, body) :: Nil) } @@ -841,7 +844,7 @@ object desugar { def refinedTypeToClass(tree: RefinedTypeTree)(implicit ctx: Context): TypeDef = { val parent = if (tree.tpt.isEmpty) TypeTree(defn.ObjectType) else tree.tpt val impl = Template(emptyConstructor, parent :: Nil, EmptyValDef, tree.refinements) - TypeDef(Modifiers(Trait), tpnme.REFINE_CLASS, impl) + TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait) } /** If tree is a variable pattern, return its name and type, otherwise return None. diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala index 8163c8bcc..3d633c58d 100644 --- a/src/dotty/tools/dotc/ast/TreeInfo.scala +++ b/src/dotty/tools/dotc/ast/TreeInfo.scala @@ -18,18 +18,18 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] => } def isDeclarationOrTypeDef(tree: Tree): Boolean = unsplice(tree) match { - case DefDef(_, _, _, _, _, EmptyTree) - | ValDef(_, _, _, EmptyTree) - | TypeDef(_, _, _) => true + case DefDef(_, _, _, _, EmptyTree) + | ValDef(_, _, EmptyTree) + | TypeDef(_, _) => true case _ => false } /** Is tree legal as a member definition of an interface? */ def isPureInterfaceMember(tree: Tree): Boolean = unsplice(tree) match { - case EmptyTree | Import(_, _) | TypeDef(_, _, _) => true - case DefDef(_, _, _, _, _, rhs) => rhs.isEmpty - case ValDef(mods, _, _, rhs) => rhs.isEmpty + case EmptyTree | Import(_, _) | TypeDef(_, _) => true + case DefDef(_, _, _, _, rhs) => rhs.isEmpty + case ValDef(_, _, rhs) => rhs.isEmpty case _ => false } @@ -91,7 +91,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] => /** If tree is a closure, it's body, otherwise tree itself */ def closureBody(tree: tpd.Tree): tpd.Tree = tree match { - case Block(DefDef(_, nme.ANON_FUN, _, _, _, rhs) :: Nil, Closure(_, _, _)) => rhs + case Block(DefDef(nme.ANON_FUN, _, _, _, rhs) :: Nil, Closure(_, _, _)) => rhs case _ => tree } @@ -162,26 +162,10 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] => /** The arguments to the first constructor in `stats`. */ def firstConstructorArgs(stats: List[Tree]): List[Tree] = firstConstructor(stats) match { - case DefDef(_, _, _, args :: _, _, _) => args + case DefDef(_, _, args :: _, _, _) => args case _ => Nil } - /** The value definitions marked PRESUPER in this statement sequence */ - def preSuperFields(stats: List[Tree]): List[ValDef] = - (stats filter isEarlyValDef).asInstanceOf[List[ValDef]] - - def isEarlyDef(tree: Tree) = isEarlyValDef(tree) || isEarlyTypeDef(tree) - - def isEarlyValDef(tree: Tree) = unsplice(tree) match { - case ValDef(mods, _, _, _) => mods is Scala2PreSuper - case _ => false - } - - def isEarlyTypeDef(tree: Tree) = unsplice(tree) match { - case TypeDef(mods, _, _) => mods is Scala2PreSuper - case _ => false - } - /** Is tpt a vararg type of the form T* ? */ def isRepeatedParamType(tpt: Tree)(implicit ctx: Context) = tpt match { case tpt: TypeTree => tpt.typeOpt.isRepeatedParam @@ -263,7 +247,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] => /** True iff definition if a val or def with no right-hand-side, or it * is an abstract typoe declaration */ - def lacksDefinition(mdef: MemberDef) = mdef match { + def lacksDefinition(mdef: MemberDef)(implicit ctx: Context) = mdef match { case mdef: ValOrDefDef => mdef.rhs.isEmpty && !mdef.name.isConstructorName && !mdef.mods.is(ParamAccessor) case mdef: TypeDef => mdef.rhs.isEmpty || mdef.rhs.isInstanceOf[TypeBoundsTree] case _ => false @@ -299,12 +283,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] => */ private def statPurity(tree: tpd.Tree)(implicit ctx: Context): PurityLevel = unsplice(tree) match { case EmptyTree - | TypeDef(_, _, _) + | TypeDef(_, _) | Import(_, _) - | DefDef(_, _, _, _, _, _) => + | DefDef(_, _, _, _, _) => Pure - case ValDef(mods, _, _, rhs) => - if (mods is Mutable) Impure else exprPurity(rhs) + case vdef @ ValDef(_, _, rhs) => + if (vdef.mods is Mutable) Impure else exprPurity(rhs) case _ => Impure } diff --git a/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/src/dotty/tools/dotc/ast/TreeTypeMap.scala index 32c89c94f..846c661f5 100644 --- a/src/dotty/tools/dotc/ast/TreeTypeMap.scala +++ b/src/dotty/tools/dotc/ast/TreeTypeMap.scala @@ -90,10 +90,10 @@ final class TreeTypeMap( tree1.withType(mapType(tree1.tpe)) match { case id: Ident if tpd.needsSelect(id.tpe) => ref(id.tpe.asInstanceOf[TermRef]).withPos(id.pos) - case ddef @ DefDef(mods, name, tparams, vparamss, tpt, rhs) => + case ddef @ DefDef(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)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(rhs)) case blk @ Block(stats, expr) => val (tmap1, stats1) = transformDefs(stats) val expr1 = tmap1.transform(expr) diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala index 648f19a4f..0886a2ace 100644 --- a/src/dotty/tools/dotc/ast/Trees.scala +++ b/src/dotty/tools/dotc/ast/Trees.scala @@ -13,6 +13,7 @@ import parsing.Tokens.Token import printing.Printer import util.{Stats, Attachment, DotClass} import annotation.unchecked.uncheckedVariance +import language.implicitConversions object Trees { @@ -435,10 +436,25 @@ object Trees { * The envelope of a MemberDef contains the whole definition and his its point * on the opening keyword (or the next token after that if keyword is missing). */ - trait MemberDef[-T >: Untyped] extends NameTree[T] with DefTree[T] { + abstract class MemberDef[-T >: Untyped] extends NameTree[T] with DefTree[T] { type ThisTree[-T >: Untyped] <: MemberDef[T] - def mods: Modifiers[T] - override def envelope: Position = mods.pos union pos union initialPos + + private[this] var myMods: Modifiers[T] = null + + private[ast] def rawMods: Modifiers[T] = + if (myMods == null) genericEmptyModifiers else myMods + + def withMods(mods: Modifiers[T @uncheckedVariance]): ThisTree[T] = { // TODO move to untpd.modsDeco? + val tree = if (myMods == null || (myMods == mods)) this else clone.asInstanceOf[MemberDef[T]] + tree.setMods(mods) + tree.asInstanceOf[ThisTree[T]] + } + + def withFlags(flags: FlagSet): ThisTree[T] = withMods(Modifiers(flags)) + + protected def setMods(mods: Modifiers[T @uncheckedVariance]) = myMods = mods + + override def envelope: Position = rawMods.pos union pos union initialPos } /** A ValDef or DefDef tree */ @@ -731,14 +747,14 @@ object Trees { } /** mods val name: tpt = rhs */ - case class ValDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TermName, tpt: Tree[T], rhs: Tree[T]) + case class ValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], rhs: Tree[T]) extends ValOrDefDef[T] { type ThisTree[-T >: Untyped] = ValDef[T] assert(isEmpty || tpt != genericEmptyTree) } /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */ - 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]) + case class DefDef[-T >: Untyped] private[ast] (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] assert(tpt != genericEmptyTree) @@ -749,7 +765,7 @@ object Trees { * mods type name = rhs or * mods type name >: lo <: hi, if rhs = TypeBoundsTree(lo, hi) & (lo ne hi) */ - case class TypeDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TypeName, rhs: Tree[T]) + case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T]) extends MemberDef[T] { type ThisTree[-T >: Untyped] = TypeDef[T] @@ -819,15 +835,18 @@ object Trees { } class EmptyValDef[T >: Untyped] extends ValDef[T]( - Modifiers[T](PrivateLocal), nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] { + nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] { override def isEmpty: Boolean = true + setMods(Modifiers[T](PrivateLocal)) } val theEmptyTree: Thicket[Type] = Thicket(Nil) val theEmptyValDef = new EmptyValDef[Type] + val theEmptyModifiers = new Modifiers() - def genericEmptyValDef[T >: Untyped]: ValDef[T] = theEmptyValDef.asInstanceOf[ValDef[T]] - def genericEmptyTree[T >: Untyped]: Thicket[T] = theEmptyTree.asInstanceOf[Thicket[T]] + def genericEmptyValDef[T >: Untyped]: ValDef[T] = theEmptyValDef.asInstanceOf[ValDef[T]] + def genericEmptyTree[T >: Untyped]: Thicket[T] = theEmptyTree.asInstanceOf[Thicket[T]] + def genericEmptyModifiers[T >: Untyped]: Modifiers[T] = theEmptyModifiers.asInstanceOf[Modifiers[T]] def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = { var buf: ListBuffer[Tree[T]] = null @@ -919,6 +938,7 @@ object Trees { val EmptyTree: Thicket = genericEmptyTree val EmptyValDef: ValDef = genericEmptyValDef + val EmptyModifiers: Modifiers = genericEmptyModifiers // ----- Auxiliary creation methods ------------------ @@ -935,6 +955,11 @@ object Trees { case ys => Thicket(ys) } + // ----- Accessing modifiers ---------------------------------------------------- + + abstract class ModsDeco { def mods: Modifiers } + implicit def modsDeco(mdef: MemberDef)(implicit ctx: Context): ModsDeco + // ----- Helper classes for copying, transforming, accumulating ----------------- val cpy: TreeCopier @@ -949,10 +974,14 @@ object Trees { abstract class TreeCopier { def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] + def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] = postProcess(tree, copied withPos tree.pos) + def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] = + postProcess(tree, copied withPos tree.pos) + def Ident(tree: Tree)(name: Name): Ident = tree match { case tree: BackquotedIdent => if (name == tree.name) tree @@ -1094,17 +1123,17 @@ object Trees { 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 { - 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 ValDef(tree: Tree)(name: TermName, tpt: Tree, rhs: Tree): ValDef = tree match { + case tree: ValDef if (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree + case _ => finalize(tree, untpd.ValDef(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 { - 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 DefDef(tree: Tree)(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = tree match { + case tree: DefDef if (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(name, tparams, vparamss, tpt, rhs)) } - 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 TypeDef(tree: Tree)(name: TypeName, rhs: Tree, tparams: List[untpd.TypeDef]): TypeDef = tree match { + case tree: TypeDef if (name == tree.name) && (rhs eq tree.rhs) && (tparams eq tree.tparams) => tree + case _ => finalize(tree, untpd.TypeDef(name, tparams, rhs)) } 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 @@ -1139,12 +1168,12 @@ object Trees { Try(tree: Tree)(expr, cases, finalizer) 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 ValDef(tree: ValDef)(name: TermName = tree.name, tpt: Tree = tree.tpt, rhs: Tree = tree.rhs): ValDef = + ValDef(tree: Tree)(name, tpt, rhs) + def DefDef(tree: DefDef)(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)(name, tparams, vparamss, tpt, rhs) + def TypeDef(tree: TypeDef)(name: TypeName = tree.name, rhs: Tree = tree.rhs, tparams: List[untpd.TypeDef] = tree.tparams): TypeDef = + TypeDef(tree: Tree)(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) } @@ -1220,14 +1249,17 @@ object Trees { cpy.UnApply(tree)(transform(fun), transform(implicits), transform(patterns)) case EmptyValDef => tree - case ValDef(mods, name, tpt, rhs) => + case tree @ ValDef(name, tpt, rhs) => val tpt1 = transform(tpt) val rhs1 = transform(rhs) - cpy.ValDef(tree)(mods, name, transform(tpt1), transform(rhs1)) - case DefDef(mods, name, tparams, vparamss, tpt, 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.ValDef(tree)(name, transform(tpt1), transform(rhs1)) + .withMods(tree.rawMods) + case tree @ DefDef(name, tparams, vparamss, tpt, rhs) => + cpy.DefDef(tree)(name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(rhs)) + .withMods(tree.rawMods) + case tree @ TypeDef(name, rhs) => + cpy.TypeDef(tree)(name, transform(rhs), tree.tparams) + .withMods(tree.rawMods) case Template(constr, parents, self, body) => cpy.Template(tree)(transformSub(constr), transform(parents), transformSub(self), transformStats(body)) case Import(expr, selectors) => @@ -1321,11 +1353,11 @@ object Trees { this(x, trees) case UnApply(fun, implicits, patterns) => this(this(this(x, fun), implicits), patterns) - case ValDef(mods, name, tpt, rhs) => + case ValDef(name, tpt, rhs) => this(this(x, tpt), rhs) - case DefDef(mods, name, tparams, vparamss, tpt, rhs) => + case DefDef(name, tparams, vparamss, tpt, rhs) => this(this((this(x, tparams) /: vparamss)(apply), tpt), rhs) - case TypeDef(mods, name, rhs) => + case TypeDef(name, rhs) => this(x, rhs) case Template(constr, parents, self, body) => this(this(this(this(x, constr), parents), self), body) @@ -1369,163 +1401,10 @@ object Trees { case tree: Bind => cpy.Bind(tree)(newName, tree.body) case tree: ValDef => cpy.ValDef(tree)(name = newName.asTermName) case tree: DefDef => cpy.DefDef(tree)(name = newName.asTermName) - case tree: untpd.PolyTypeDef => untpd.cpy.PolyTypeDef(tree)(tree.mods, newName.asTypeName, tree.tparams, tree.rhs) + case tree: untpd.PolyTypeDef => untpd.cpy.PolyTypeDef(tree)(newName.asTypeName, tree.tparams, tree.rhs).withMods(tree.rawMods) case tree: TypeDef => cpy.TypeDef(tree)(name = newName.asTypeName) case tree: SelectFromTypeTree => cpy.SelectFromTypeTree(tree)(tree.qualifier, newName) } }.asInstanceOf[tree.ThisTree[T]] } } - // ----- Helper functions and classes --------------------------------------- -/* - - abstract class FullTreeTransformer[T >: Untyped, C] { - var sharedMemo: Map[SharedTree[T], SharedTree[T]] = Map() - - def transform(tree: Tree[T], c: C): Tree[T] = tree match { - case Ident(name) => - finishIdent(tree, tree, c, plugins) - case Select(qualifier, name) => - finishSelect(tree.derivedSelect(transform(qualifier, c), name), tree, c, plugins) - case This(qual) => - finishThis(tree, tree, c, plugins) - case Super(qual, mix) => - finishSuper(tree.derivedSuper(transform(qual, c), mix), tree, c, plugins) - case Apply(fun, args) => - finishApply(tree.derivedApply(transform(fun, c), transform(args, c)), tree, c, plugins) - case TypeApply(fun, args) => - finishTypeApply(tree.derivedTypeApply(transform(fun, c), transform(args, c)), tree, c, plugins) - case Literal(const) => - finishLiteral(tree, tree, c, plugins) - case New(tpt) => - finishNew(tree.derivedNew(transform(tpt, c)), tree, c, plugins) - case Pair(left, right) => - finishPair(tree.derivedPair(transform(left, c), transform(right, c)), tree, c, plugins) - case Typed(expr, tpt) => - finishTyped(tree.derivedTyped(transform(expr, c), transform(tpt, c)), tree, c, plugins) - case NamedArg(name, arg) => - finishNamedArg(tree.derivedNamedArg(name, transform(arg, c)), tree, c, plugins) - case Assign(lhs, rhs) => - finishAssign(tree.derivedAssign(transform(lhs, c), transform(rhs, c)), tree, c, plugins) - case Block(stats, expr) => - finishBlock(tree.derivedBlock(transform(stats, c), transform(expr, c)), tree, c, plugins) - case If(cond, thenp, elsep) => - finishIf(tree.derivedIf(transform(cond, c), transform(thenp, c), transform(elsep, c)), tree, c, plugins) - case Closure(env, meth, tpt) => - finishClosure(tree.derivedClosure(transform(env, c), transformSub(meth, c)), tree, c, plugins) - case Match(selector, cases) => - finishMatch(tree.derivedMatch(transform(selector, c), transformSub(cases, c)), tree, c, plugins) - case CaseDef(pat, guard, body) => - finishCaseDef(tree.derivedCaseDef(transform(pat, c), transform(guard, c), transform(body, c)), tree, c, plugins) - case Return(expr, from) => - finishReturn(tree.derivedReturn(transform(expr, c), transform(from, c)), tree, c, plugins) - case Try(block, handler, finalizer) => - finishTry(tree.derivedTry(transform(block, c), transform(handler, c), transform(finalizer, c)), tree, c, plugins) - case Throw(expr) => - finishThrow(tree.derivedThrow(transform(expr, c)), tree, c, plugins) - case SeqLiteral(elems) => - finishSeqLiteral(tree.derivedSeqLiteral(transform(elems, c)), tree, c, plugins) - case TypeTree(original) => - finishTypeTree(tree, tree, c, plugins) - case SingletonTypeTree(ref) => - finishSingletonTypeTree(tree.derivedSingletonTypeTree(transform(ref, c)), tree, c, plugins) - case SelectFromTypeTree(qualifier, name) => - finishSelectFromTypeTree(tree.derivedSelectFromTypeTree(transform(qualifier, c), name), tree, c, plugins) - case AndTypeTree(left, right) => - finishAndTypeTree(tree.derivedAndTypeTree(transform(left, c), transform(right, c)), tree, c, plugins) - case OrTypeTree(left, right) => - finishOrTypeTree(tree.derivedOrTypeTree(transform(left, c), transform(right, c)), tree, c, plugins) - case RefinedTypeTree(tpt, refinements) => - finishRefinedTypeTree(tree.derivedRefinedTypeTree(transform(tpt, c), transformSub(refinements, c)), tree, c, plugins) - case AppliedTypeTree(tpt, args) => - finishAppliedTypeTree(tree.derivedAppliedTypeTree(transform(tpt, c), transform(args, c)), tree, c, plugins) - case TypeBoundsTree(lo, hi) => - finishTypeBoundsTree(tree.derivedTypeBoundsTree(transform(lo, c), transform(hi, c)), tree, c, plugins) - case Bind(name, body) => - finishBind(tree.derivedBind(name, transform(body, c)), tree, c, plugins) - case Alternative(trees) => - finishAlternative(tree.derivedAlternative(transform(trees, c)), tree, c, plugins) - case UnApply(fun, args) => - finishUnApply(tree.derivedUnApply(transform(fun, c), transform(args, c)), tree, c, plugins) - case ValDef(mods, name, tpt, rhs) => - finishValDef(tree.derivedValDef(mods, name, transform(tpt, c), transform(rhs, c)), tree, c, plugins) - case DefDef(mods, name, tparams, vparamss, tpt, rhs) => - finishDefDef(tree.derivedDefDef(mods, name, transformSub(tparams, c), vparamss mapConserve (transformSub(_, c)), transform(tpt, c), transform(rhs, c)), tree, c, plugins) - case tree @ TypeDef(mods, name, rhs) => - finishTypeDef(tree.derivedTypeDef(mods, name, transform(rhs, c), tree.tparams), tree, c, plugins) - case Template(constr, parents, self, body) => - finishTemplate(tree.derivedTemplate(transformSub(constr, c), transform(parents, c), transformSub(self, c), transform(body, c)), tree, c, plugins) - case Import(expr, selectors) => - finishImport(tree.derivedImport(transform(expr, c), selectors), tree, c, plugins) - case PackageDef(pid, stats) => - finishPackageDef(tree.derivedPackageDef(transformSub(pid, c), transform(stats, c)), tree, c, plugins) - case Annotated(annot, arg) => - finishAnnotated(tree.derivedAnnotated(transform(annot, c), transform(arg, c)), tree, c, plugins) - case EmptyTree => - finishEmptyTree(tree, tree, c, plugins) - case tree @ SharedTree(shared) => - finishSharedTree( - sharedMemo get tree match { - case Some(tree1) => tree1 - case None => - val tree1 = tree.derivedSharedTree(transform(shared, c)) - sharedMemo = sharedMemo.updated(tree, tree1) - tree1 - }, - tree, c, plugins) - } - def transform(trees: List[Tree[T]], c: C): List[Tree[T]] = - flatten(trees) mapConserve (transform(_, c)) - def transformSub(tree: Tree[T], c: C): tree.ThisTree[T] = - transform(tree, c).asInstanceOf[tree.ThisTree[T]] - def transformSub[TT <: Tree[T]](trees: List[TT], c: C): List[TT] = - transform(trees, c).asInstanceOf[List[TT]] - - type Plugins >: Null - def plugins: Plugins = null - - def finishIdent(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSelect(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishThis(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSuper(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishApply(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTypeApply(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishLiteral(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishNew(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishPair(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTyped(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishNamedArg(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishAssign(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishFunction(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishBlock(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishIf(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishClosure(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishMatch(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishCaseDef(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishReturn(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTry(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishThrow(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSeqLiteral(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSingletonTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSelectFromTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishAndTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishOrTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishRefinedTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishAppliedTypeTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTypeBoundsTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishBind(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishAlternative(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishUnApply(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishValDef(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishDefDef(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTypeDef(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishTemplate(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishImport(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishPackageDef(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishAnnotated(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishEmptyTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - def finishSharedTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree - } -*/ - diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala index 735b218e3..12d4ac5e4 100644 --- a/src/dotty/tools/dotc/ast/tpd.scala +++ b/src/dotty/tools/dotc/ast/tpd.scala @@ -165,7 +165,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { ta.assignType(untpd.UnApply(fun, implicits, patterns), proto) def ValDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): ValDef = - ta.assignType(untpd.ValDef(Modifiers(sym), sym.name, TypeTree(sym.info), rhs), sym) + ta.assignType(untpd.ValDef(sym.name, TypeTree(sym.info), rhs), sym) def SyntheticValDef(name: TermName, rhs: Tree)(implicit ctx: Context): ValDef = ValDef(ctx.newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.pos), rhs) @@ -198,12 +198,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { val argss = vparamss.nestedMap(vparam => Ident(vparam.termRef)) ta.assignType( untpd.DefDef( - Modifiers(sym), sym.name, tparams map TypeDef, - vparamss.nestedMap(ValDef(_)), TypeTree(rtp), rhsFn(targs)(argss)), sym) + sym.name, + tparams map TypeDef, + vparamss.nestedMap(ValDef(_)), + TypeTree(rtp), + rhsFn(targs)(argss)), + sym) } def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef = - ta.assignType(untpd.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info)), sym) + ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym) def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = { val firstParent :: otherParents = cls.info.parents @@ -237,7 +241,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { .orElse(ctx.newLocalDummy(cls)) val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body) .withType(localDummy.nonMemberTermRef) - ta.assignType(untpd.TypeDef(Modifiers(cls), cls.name, impl), cls) + ta.assignType(untpd.TypeDef(cls.name, impl), cls) } def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = @@ -367,11 +371,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } else foldOver(sym, tree) } + implicit class modsDeco(mdef: MemberDef)(implicit ctx: Context) extends ModsDeco { + def mods = if (mdef.hasType) Modifiers(mdef.symbol) else mdef.rawMods + } + override val cpy = new TypedTreeCopier class TypedTreeCopier extends TreeCopier { def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[Type] = copied.withTypeUnchecked(tree.tpe) + def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[Type] = + copied.withTypeUnchecked(tree.tpe) override def Select(tree: Tree)(qualifier: Tree, name: Name)(implicit ctx: Context): Select = { val tree1 = untpd.cpy.Select(tree)(qualifier, name) diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala index 9e6ce4450..02ee1eddf 100644 --- a/src/dotty/tools/dotc/ast/untpd.scala +++ b/src/dotty/tools/dotc/ast/untpd.scala @@ -26,10 +26,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { } /** mods object name impl */ - case class ModuleDef(mods: Modifiers, name: TermName, impl: Template) + case class ModuleDef(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)(name.toTermName, impl) } case class ParsedTry(expr: Tree, handler: Tree, finalizer: Tree) extends TermTree @@ -59,8 +59,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree]) extends TypTree case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree) extends DefTree - class PolyTypeDef(mods: Modifiers, name: TypeName, override val tparams: List[TypeDef], rhs: Tree) - extends TypeDef(mods, name, rhs) + class PolyTypeDef(name: TypeName, override val tparams: List[TypeDef], rhs: Tree) + extends TypeDef(name, rhs) // ----- TypeTrees that refer to other tree's symbols ------------------- @@ -142,9 +142,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { def Bind(name: Name, body: Tree): Bind = new Bind(name, body) def Alternative(trees: List[Tree]): Alternative = new Alternative(trees) def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree]): UnApply = new UnApply(fun, implicits, patterns) - def ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef = new ValDef(mods, name, tpt, rhs) - def DefDef(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = new DefDef(mods, name, tparams, vparamss, tpt, rhs) - def TypeDef(mods: Modifiers, name: TypeName, rhs: Tree): TypeDef = new TypeDef(mods, name, rhs) + def ValDef(name: TermName, tpt: Tree, rhs: Tree): ValDef = new ValDef(name, tpt, rhs) + def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs) + def TypeDef(name: TypeName, rhs: Tree): TypeDef = new TypeDef(name, rhs) def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree]): Template = new Template(constr, parents, self, body) def Import(expr: Tree, selectors: List[untpd.Tree]): Import = new Import(expr, selectors) def PackageDef(pid: RefTree, stats: List[Tree]): PackageDef = new PackageDef(pid, stats) @@ -193,8 +193,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { def TypeTree(tpe: Type): TypedSplice = TypedSplice(TypeTree().withTypeUnchecked(tpe)) - def TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree): TypeDef = - if (tparams.isEmpty) TypeDef(mods, name, rhs) else new PolyTypeDef(mods, name, tparams, rhs) + def TypeDef(name: TypeName, tparams: List[TypeDef], rhs: Tree): TypeDef = + if (tparams.isEmpty) TypeDef(name, rhs) else new PolyTypeDef(name, tparams, rhs) def unitLiteral = Literal(Constant(())) @@ -203,14 +203,14 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { def scalaUnit(implicit ctx: Context) = ref(defn.UnitClass.typeRef) - def makeConstructor(mods: Modifiers, tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef = - DefDef(mods, nme.CONSTRUCTOR, tparams, vparamss, TypeTree(), rhs) + def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef = + DefDef(nme.CONSTRUCTOR, tparams, vparamss, TypeTree(), rhs) def emptyConstructor(implicit ctx: Context): DefDef = - makeConstructor(Modifiers(), Nil, Nil) + makeConstructor(Nil, Nil) def makeSelfDef(name: TermName, tpt: Tree)(implicit ctx: Context) = - ValDef(Modifiers(PrivateLocal), name, tpt, EmptyTree) + ValDef(name, tpt, EmptyTree).withFlags(PrivateLocal) def makeTupleOrParens(ts: List[Tree])(implicit ctx: Context) = ts match { case t :: Nil => Parens(t) @@ -222,15 +222,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { case _ => Tuple(ts) } - def makeParameter(pname: TermName, tpe: Tree, mods: Modifiers = Modifiers())(implicit ctx: Context): ValDef = - ValDef(mods | Param, pname, tpe, EmptyTree) + def makeParameter(pname: TermName, tpe: Tree, mods: Modifiers = EmptyModifiers)(implicit ctx: Context): ValDef = + ValDef(pname, tpe, EmptyTree).withMods(mods | Param) def makeSyntheticParameter(n: Int = 1, tpt: Tree = TypeTree())(implicit ctx: Context): ValDef = - ValDef(Modifiers(SyntheticTermParam), nme.syntheticParamName(n), tpt, EmptyTree) + ValDef(nme.syntheticParamName(n), tpt, EmptyTree).withFlags(SyntheticTermParam) def refOfDef(tree: NameTree)(implicit ctx: Context) = Ident(tree.name) -// ------- A decorator for producing a path to a location -------------- +// ------- Decorators ------------------------------------------------- implicit class UntypedTreeDecorator(val self: Tree) extends AnyVal { def locateEnclosing(base: List[Tree], pos: Position): List[Tree] = { @@ -245,21 +245,33 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { } } + implicit class modsDeco(val mdef: MemberDef)(implicit ctx: Context) extends ModsDeco { + def mods = mdef.rawMods + } + // --------- Copier/Transformer/Accumulator classes for untyped trees ----- override val cpy: UntypedTreeCopier = new UntypedTreeCopier class UntypedTreeCopier extends TreeCopier { + 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 { - 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 postProcess(tree: Tree, copied: MemberDef): copied.ThisTree[Untyped] = { + tree match { + case tree: MemberDef => copied.withMods(tree.rawMods) + case _ => copied + } + }.asInstanceOf[copied.ThisTree[Untyped]] + + def ModuleDef(tree: Tree)(name: TermName, impl: Template) = tree match { + case tree: ModuleDef if (name eq tree.name) && (impl eq tree.impl) => tree + case _ => untpd.ModuleDef(name, impl).withPos(tree.pos) } - 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 PolyTypeDef(tree: Tree)(name: TypeName, tparams: List[TypeDef], rhs: Tree) = tree match { + case tree: PolyTypeDef if (name eq tree.name) && (tparams eq tree.tparams) && (rhs eq tree.rhs) => tree + case _ => new PolyTypeDef(name, tparams, rhs).withPos(tree.pos) } def SymbolLit(tree: Tree)(str: String) = tree match { case tree: SymbolLit if (str == tree.str) => tree @@ -329,8 +341,8 @@ 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)) + case ModuleDef(name, impl) => + cpy.ModuleDef(tree)(name, transformSub(impl)) case SymbolLit(str) => cpy.SymbolLit(tree)(str) case InterpolatedString(id, strings, elems) => @@ -364,7 +376,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { case PatDef(mods, pats, tpt, 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.name, transformSub(tree.tparams), transform(tree.rhs)) case _ => super.transform(tree) } @@ -372,7 +384,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] { override def foldOver(x: X, tree: Tree): X = tree match { - case ModuleDef(mods, name, impl) => + case ModuleDef(name, impl) => this(x, impl) case SymbolLit(str) => x @@ -417,7 +429,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { override def rename(tree: NameTree, newName: Name)(implicit ctx: Context): tree.ThisTree[Untyped] = tree match { case t: PolyTypeDef => - cpy.PolyTypeDef(t)(t.mods, newName.asTypeName, t.tparams, t.rhs).asInstanceOf[tree.ThisTree[Untyped]] + cpy.PolyTypeDef(t)(newName.asTypeName, t.tparams, t.rhs).asInstanceOf[tree.ThisTree[Untyped]] case _ => super.rename(tree, newName) } } diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala index 2651b7514..af4229763 100644 --- a/src/dotty/tools/dotc/parsing/Parsers.scala +++ b/src/dotty/tools/dotc/parsing/Parsers.scala @@ -1030,7 +1030,7 @@ object Parsers { case USCORE => val start = in.skipToken() val pname = ctx.freshName(nme.USCORE_PARAM_PREFIX).toTermName - val param = ValDef(Modifiers(SyntheticTermParam), pname, TypeTree(), EmptyTree) + val param = ValDef(pname, TypeTree(), EmptyTree).withFlags(SyntheticTermParam) .withPos(Position(start)) placeholderParams = param :: placeholderParams atPos(start) { Ident(pname) } @@ -1486,7 +1486,7 @@ object Parsers { val bounds = if (isConcreteOwner) typeParamBounds(name) else typeBounds() - TypeDef(mods, name, hkparams, bounds) + TypeDef(name, hkparams, bounds).withMods(mods) } } commaSeparated(typeParam) @@ -1550,7 +1550,7 @@ object Parsers { mods = mods.withPos(mods.pos.withStart(implicitOffset)) implicitOffset = -1 } - ValDef(addFlag(mods, implicitFlag), name, tpt, default) + ValDef(name, tpt, default).withMods(addFlag(mods, implicitFlag)) } } def paramClause(): List[ValDef] = inParens { @@ -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)(name, tpt, rhs).withMods(mods) case _ => PatDef(mods, lhs, tpt, rhs) } } @@ -1705,7 +1705,7 @@ object Parsers { accept(EQUALS) atPos(in.offset) { constrExpr() } } - makeConstructor(mods, Nil, vparamss, rhs) + makeConstructor(Nil, vparamss, rhs).withMods(mods) } else { val name = ident() val tparams = typeParamClauseOpt(ParamOwner.Def) @@ -1716,7 +1716,7 @@ object Parsers { accept(EQUALS) expr() } else EmptyTree - DefDef(mods | Method, name, tparams, vparamss, tpt, rhs) + DefDef(name, tparams, vparamss, tpt, rhs).withMods(mods | Method) } } @@ -1758,9 +1758,9 @@ object Parsers { in.token match { case EQUALS => in.nextToken() - TypeDef(mods, name, tparams, typ()) + TypeDef(name, tparams, typ()).withMods(mods) case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | EOF => - TypeDef(mods, name, tparams, typeBounds()) + TypeDef(name, tparams, typeBounds()).withMods(mods) case _ => syntaxErrorOrIncomplete("`=', `>:', or `<:' expected") EmptyTree @@ -1796,10 +1796,10 @@ object Parsers { val tparams = typeParamClauseOpt(ParamOwner.Class) val cmods = constrModsOpt() val vparamss = paramClauses(name, mods is Case) - makeConstructor(cmods, tparams, vparamss) + makeConstructor(tparams, vparamss).withMods(cmods) } val templ = templateOpt(constr) - TypeDef(mods, name, templ) + TypeDef(name, templ).withMods(mods) } /** ConstrMods ::= AccessModifier @@ -1818,7 +1818,7 @@ object Parsers { def objectDef(mods: Modifiers): ModuleDef = { val name = ident() val template = templateOpt(emptyConstructor()) - ModuleDef(mods, name, template) + ModuleDef(name, template).withMods(mods) } /* -------- TEMPLATES ------------------------------------------- */ @@ -1941,7 +1941,7 @@ object Parsers { case Typed(tree @ This(tpnme.EMPTY), tpt) => self = makeSelfDef(nme.WILDCARD, tpt).withPos(first.pos) case _ => - val ValDef(_, name, tpt, _) = convertToParam(first, expected = "self type clause") + val ValDef(name, tpt, _) = convertToParam(first, expected = "self type clause") self = makeSelfDef(name, tpt).withPos(first.pos) } in.nextToken() diff --git a/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala b/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala index 138172012..46d2a450e 100644 --- a/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala +++ b/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala @@ -165,7 +165,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont /** could optimize if args.length == 0, args.length == 1 AND args(0) is <: Node. */ def makeXMLseq(pos: Position, args: Seq[Tree]) = { - val buffer = ValDef(Modifiers(), _buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil)) + val buffer = ValDef(_buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil)) val applies = args filterNot isEmptyText map (t => Apply(Select(Ident(_buf), _plus), List(t))) atPos(pos)( Block(buffer :: applies.toList, Ident(_buf)) ) @@ -235,9 +235,9 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont case _ => handleUnprefixedAttribute(k, v) } - lazy val scopeDef = ValDef(Modifiers(), _scope, _scala_xml_NamespaceBinding, Ident(_tmpscope)) - lazy val tmpScopeDef = ValDef(Modifiers(Mutable), _tmpscope, _scala_xml_NamespaceBinding, Ident(_scope)) - lazy val metadataDef = ValDef(Modifiers(Mutable), _md, _scala_xml_MetaData, _scala_xml_Null) + lazy val scopeDef = ValDef(_scope, _scala_xml_NamespaceBinding, Ident(_tmpscope)) + lazy val tmpScopeDef = ValDef(_tmpscope, _scala_xml_NamespaceBinding, Ident(_scope)).withFlags(Mutable) + lazy val metadataDef = ValDef(_md, _scala_xml_MetaData, _scala_xml_Null).withFlags(Mutable) val makeSymbolicAttrs = if (!attributes.isEmpty) Ident(_md) else _scala_xml_Null val (attrResult, nsResult) = diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala index 50b73a357..12ac03bd0 100644 --- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala +++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala @@ -307,28 +307,28 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { toTextLocal(extractor) ~ "(" ~ toTextGlobal(patterns, ", ") ~ ")" ~ ("(" ~ toTextGlobal(implicits, ", ") ~ ")" provided implicits.nonEmpty) - case tree @ ValDef(mods, name, tpt, rhs) => + case tree @ ValDef(name, tpt, rhs) => dclTextOr { - modText(mods, if (mods is Mutable) "var" else "val") ~~ nameIdText(tree) ~ + modText(tree.mods, if (tree.mods is Mutable) "var" else "val") ~~ nameIdText(tree) ~ optAscription(tpt) } ~ optText(rhs)(" = " ~ _) - case tree @ DefDef(mods, name, tparams, vparamss, tpt, rhs) => + case tree @ DefDef(name, tparams, vparamss, tpt, rhs) => atOwner(tree) { dclTextOr { - val first = modText(mods, "def") ~~ nameIdText(tree) ~ tparamsText(tparams) + val first = modText(tree.mods, "def") ~~ nameIdText(tree) ~ tparamsText(tparams) addVparamssText(first, vparamss) ~ optAscription(tpt) } ~ optText(rhs)(" = " ~ _) } - case tree @ TypeDef(mods, name, rhs) => + case tree @ TypeDef(name, rhs) => atOwner(tree) { def typeDefText(rhsText: Text) = dclTextOr { val rhsText1 = if (tree.hasType) toText(tree.symbol.info) else rhsText - modText(mods, "type") ~~ nameIdText(tree) ~ tparamsText(tree.tparams) ~ rhsText1 + modText(tree.mods, "type") ~~ nameIdText(tree) ~ tparamsText(tree.tparams) ~ rhsText1 } rhs match { case impl: Template => - modText(mods, if (mods is Trait) "trait" else "class") ~~ nameIdText(tree) ~ toText(impl) ~ + modText(tree.mods, if (tree.mods is Trait) "trait" else "class") ~~ nameIdText(tree) ~ toText(impl) ~ (if (tree.hasType && ctx.settings.verbose.value) s"[decls = ${tree.symbol.info.decls}]" else "") case rhs: TypeBoundsTree => typeDefText(toText(rhs)) @@ -336,14 +336,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { typeDefText(optText(rhs)(" = " ~ _)) } } - case Template(constr @ DefDef(mods, _, tparams, vparamss, _, rhs), parents, self, stats) => + case Template(constr @ DefDef(_, tparams, vparamss, _, rhs), parents, self, stats) => val tparamsTxt = tparamsText(tparams) val primaryConstrs = if (rhs.isEmpty) Nil else constr :: Nil val prefix: Text = if (vparamss.isEmpty || primaryConstrs.nonEmpty) tparamsTxt else { - var modsText = modText(mods, "") - if (mods.hasAnnotations && !mods.hasFlags) modsText = modsText ~~ " this" + var modsText = modText(constr.mods, "") + if (constr.mods.hasAnnotations && !constr.mods.hasFlags) modsText = modsText ~~ " this" addVparamssText(tparamsTxt ~~ modsText, vparamss) } val parentsText = Text(parents map constrText, " with ") @@ -377,9 +377,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { "<empty>" case TypedSplice(t) => toText(t) - case tree @ ModuleDef(mods, name, impl) => + case tree @ ModuleDef(name, impl) => atOwner(tree) { - modText(mods, "object") ~~ nameIdText(tree) ~ toText(impl) + modText(tree.mods, "object") ~~ nameIdText(tree) ~ toText(impl) } case SymbolLit(str) => "'" + str @@ -395,16 +395,16 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { case Function(args, body) => var implicitSeen: Boolean = false def argToText(arg: Tree) = arg match { - case ValDef(mods, name, tpt, _) => + case arg @ ValDef(name, tpt, _) => val implicitText = - if ((mods is Implicit) && !implicitSeen) { implicitSeen = true; "implicit " } + if ((arg.mods is Implicit) && !implicitSeen) { implicitSeen = true; "implicit " } else "" implicitText ~ toText(name) ~ optAscription(tpt) case _ => toText(arg) } val argsText = args match { - case (arg @ ValDef(_, _, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg) + case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg) case _ => "(" ~ Text(args map argToText, ", ") ~ ")" } changePrec(GlobalPrec) { diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala index 9420ce2c0..2e8196ff0 100644 --- a/src/dotty/tools/dotc/transform/Constructors.scala +++ b/src/dotty/tools/dotc/transform/Constructors.scala @@ -62,7 +62,7 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor override def transformTemplate(tree: Template)(implicit ctx: Context, info: TransformerInfo): Tree = { val cls = ctx.owner.asClass - val constr @ DefDef(_, nme.CONSTRUCTOR, Nil, vparams :: Nil, _, EmptyTree) = tree.constr + val constr @ DefDef(nme.CONSTRUCTOR, Nil, vparams :: Nil, _, EmptyTree) = tree.constr // Produce aligned accessors and constructor parameters. We have to adjust // for any outer parameters, which are last in the sequence of original @@ -157,7 +157,7 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor def splitStats(stats: List[Tree]): Unit = stats match { case stat :: stats1 => stat match { - case stat @ ValDef(mods, name, tpt, rhs) if !stat.symbol.is(Lazy) => + case stat @ ValDef(name, tpt, rhs) if !stat.symbol.is(Lazy) => val sym = stat.symbol if (isRetained(sym)) { if (!rhs.isEmpty && !isWildcardArg(rhs)) diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala index 4adbfe164..7606a08a3 100644 --- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -180,8 +180,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful newC } store += atGroupEnd(fullyParameterizedDef(extensionMeth, tree)(_)) - cpy.DefDef(tree)(tree.mods, tree.name, tree.tparams, tree.vparamss, tree.tpt, - atGroupEnd(forwarder(extensionMeth, tree)(_))) + cpy.DefDef(tree)(rhs = atGroupEnd(forwarder(extensionMeth, tree)(_))) } else tree } } diff --git a/src/dotty/tools/dotc/transform/GettersSetters.scala b/src/dotty/tools/dotc/transform/GettersSetters.scala index b5933cc48..e1b4b59a0 100644 --- a/src/dotty/tools/dotc/transform/GettersSetters.scala +++ b/src/dotty/tools/dotc/transform/GettersSetters.scala @@ -89,7 +89,6 @@ import Decorators._ assert(tree.rhs.tpe.exists, tree.show) val fieldDef = cpy.ValDef(tree)( - mods = tree.mods & EmptyFlags | field.flags, name = field.name, rhs = tree.rhs.changeOwner(getter, field).ensureConforms(field.info.widen) ).withType(field.valRef) diff --git a/src/dotty/tools/dotc/transform/LambdaLift.scala b/src/dotty/tools/dotc/transform/LambdaLift.scala index f36ff6247..b239008fb 100644 --- a/src/dotty/tools/dotc/transform/LambdaLift.scala +++ b/src/dotty/tools/dotc/transform/LambdaLift.scala @@ -386,9 +386,7 @@ class LambdaLift extends MiniPhaseTransform with IdentityDenotTransformer { this val sym = tree.symbol val proxyHolder = sym.skipConstructor if (needsLifting(proxyHolder)) { - var paramsAdded = addFreeParams(tree, proxies(proxyHolder)).asInstanceOf[DefDef] - if (sym.is(JavaStatic) && !paramsAdded.mods.is(JavaStatic)) - paramsAdded = cpy.DefDef(paramsAdded)(mods = paramsAdded.mods | JavaStatic) + val paramsAdded = addFreeParams(tree, proxies(proxyHolder)).asInstanceOf[DefDef] if (sym.isConstructor) paramsAdded else liftDef(paramsAdded) } else tree diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala index 9c47ce628..8b430aae9 100644 --- a/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/src/dotty/tools/dotc/transform/LazyVals.scala @@ -74,7 +74,7 @@ class LazyValsTransform extends MiniPhaseTransform with IdentityDenotTransformer * dotty.runtime(eg dotty.runtime.LazyInt) */ def transformLocalValDef(x: ValDef)(implicit ctx: Context) = x match { - case x@ValDef(mods, name, tpt, rhs) => + case x@ValDef(name, tpt, rhs) => val valueInitter = rhs val holderName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName val tpe = x.tpe.widen @@ -141,12 +141,12 @@ class LazyValsTransform extends MiniPhaseTransform with IdentityDenotTransformer } def transformFieldValDefNonVolatile(x: ValDef)(implicit ctx: Context) = x match { - case x@ValDef(mods, name, tpt, rhs) if (mods is Flags.Lazy) => + case x@ValDef(name, tpt, rhs) if (x.mods is Flags.Lazy) => val claz = x.symbol.owner.asClass val tpe = x.tpe.widen - assert(!(mods is Flags.Mutable)) + assert(!(x.mods is Flags.Mutable)) val containerName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName - val containerSymbol = ctx.newSymbol(claz, containerName, (mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this) + val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this) val containerTree = ValDef(containerSymbol, initValue(tpe)) if (x.tpe.isNotNull && tpe <:< defn.AnyRefType) { // can use 'null' value instead of flag @@ -260,8 +260,8 @@ class LazyValsTransform extends MiniPhaseTransform with IdentityDenotTransformer } def transformFieldValDefVolatile(x: ValDef)(implicit ctx: Context) = x match { - case x@ValDef(mods, name, tpt, rhs) if (mods is Flags.Lazy) => - assert(!(mods is Flags.Mutable)) + case x@ValDef(name, tpt, rhs) if (x.mods is Flags.Lazy) => + assert(!(x.mods is Flags.Mutable)) val tpe = x.tpe.widen val claz = x.symbol.owner.asClass @@ -303,7 +303,7 @@ class LazyValsTransform extends MiniPhaseTransform with IdentityDenotTransformer } val containerName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName - val containerSymbol = ctx.newSymbol(claz, containerName, (mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this) + val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this) val containerTree = ValDef(containerSymbol, initValue(tpe)) val offset = Select(ref(companion), offsetSymbol.name) diff --git a/src/dotty/tools/dotc/transform/Mixin.scala b/src/dotty/tools/dotc/transform/Mixin.scala index 3d68a2687..a96e5f1f5 100644 --- a/src/dotty/tools/dotc/transform/Mixin.scala +++ b/src/dotty/tools/dotc/transform/Mixin.scala @@ -105,15 +105,11 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform => initBuf.toList.map(_.changeOwner(impl.symbol, isym)), stat.rhs.changeOwner(vsym, isym)) initBuf.clear() - List( - cpy.DefDef(stat)(mods = stat.mods | Deferred, rhs = EmptyTree), - DefDef(isym, rhs)) + cpy.DefDef(stat)(rhs = EmptyTree) :: DefDef(isym, rhs) :: Nil case stat: DefDef if stat.symbol.isSetter => - List(cpy.DefDef(stat)( - mods = stat.mods | Deferred, - rhs = EmptyTree)) + cpy.DefDef(stat)(rhs = EmptyTree) :: Nil case stat: DefTree => - List(stat) + stat :: Nil case stat => initBuf += stat Nil diff --git a/src/dotty/tools/dotc/transform/PrivateToStatic.scala b/src/dotty/tools/dotc/transform/PrivateToStatic.scala index 5562fc6b2..15697e655 100644 --- a/src/dotty/tools/dotc/transform/PrivateToStatic.scala +++ b/src/dotty/tools/dotc/transform/PrivateToStatic.scala @@ -61,9 +61,7 @@ class PrivateToStatic extends MiniPhase with SymTransformer { thisTransform => if (shouldBeStatic(tree.symbol)) { val thisParamDef = ValDef(thisParam.asTerm) val vparams :: Nil = tree.vparamss - cpy.DefDef(tree)( - mods = tree.mods | JavaStatic, - vparamss = (thisParamDef :: vparams) :: Nil) + cpy.DefDef(tree)(vparamss = (thisParamDef :: vparams) :: Nil) } else tree diff --git a/src/dotty/tools/dotc/transform/RestoreScopes.scala b/src/dotty/tools/dotc/transform/RestoreScopes.scala index 4a4252326..e133ae2f2 100644 --- a/src/dotty/tools/dotc/transform/RestoreScopes.scala +++ b/src/dotty/tools/dotc/transform/RestoreScopes.scala @@ -22,7 +22,7 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t override def treeTransformPhase = thisTransform.next override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo) = { - val TypeDef(_, _, Template(constr, _, _, body)) = tree + val TypeDef(_, Template(constr, _, _, body)) = tree val restoredDecls = newScope for (stat <- constr :: body) if (stat.isInstanceOf[MemberDef] && stat.symbol.exists) diff --git a/src/dotty/tools/dotc/transform/SuperAccessors.scala b/src/dotty/tools/dotc/transform/SuperAccessors.scala index 537c8c0c6..8a531de8d 100644 --- a/src/dotty/tools/dotc/transform/SuperAccessors.scala +++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala @@ -224,7 +224,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this case CaseDef(pat, guard, body) => cpy.CaseDef(tree)(pat, transform(guard), transform(body)) - case TypeDef(_, _, impl: Template) => + case TypeDef(_, impl: Template) => val cls = sym.asClass checkCompanionNameClashes(cls) expandQualifiedPrivates(cls) @@ -368,7 +368,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this } transformSelect - case tree@DefDef(_, _, _, _, _, rhs) => + case tree @ DefDef(_, _, _, _, rhs) => cpy.DefDef(tree)( rhs = if (isMethodWithExtension(sym)) withInvalidOwner(transform(rhs)) else transform(rhs)) diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala index 376a41646..57f1336ed 100644 --- a/src/dotty/tools/dotc/transform/TailRec.scala +++ b/src/dotty/tools/dotc/transform/TailRec.scala @@ -81,7 +81,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { tree match { - case dd@DefDef(mods, name, tparams, vparamss0, tpt, rhs0) + case dd@DefDef(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) atGroupEnd { implicit ctx: Context => @@ -296,8 +296,8 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete assert(false, "We should've never gotten inside a pattern") tree - case ValDef(_, _, _, _) | EmptyTree | Super(_, _) | This(_) | - Literal(_) | TypeTree(_) | DefDef(_, _, _, _, _, _) | TypeDef(_, _, _) => + case ValDef(_, _, _) | EmptyTree | Super(_, _) | This(_) | + Literal(_) | TypeTree(_) | DefDef(_, _, _, _, _) | TypeDef(_, _) => tree case Return(expr, from) => diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala index f6e36a129..dd84cd53a 100644 --- a/src/dotty/tools/dotc/transform/TreeChecker.scala +++ b/src/dotty/tools/dotc/transform/TreeChecker.scala @@ -144,7 +144,7 @@ class TreeChecker { } override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = { - val TypeDef(_, _, impl @ Template(constr, _, _, _)) = cdef + val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef assert(cdef.symbol == cls) assert(impl.symbol.owner == cls) assert(constr.symbol.owner == cls) diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala index 850563a48..a70ab8aed 100644 --- a/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -960,7 +960,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.name, tpt, rhs), mutatedInfo.nx.nxTransValDef(cur)) } case tree: DefDef => implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForDefDef, info.nx.nxPrepDefDef, tree, cur) @@ -971,14 +971,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.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.name, rhs, tree.tparams), mutatedInfo.nx.nxTransTypeDef(cur)) } case _ => tree diff --git a/src/dotty/tools/dotc/typer/EtaExpansion.scala b/src/dotty/tools/dotc/typer/EtaExpansion.scala index 394accd03..6ecd90c08 100644 --- a/src/dotty/tools/dotc/typer/EtaExpansion.scala +++ b/src/dotty/tools/dotc/typer/EtaExpansion.scala @@ -135,7 +135,7 @@ object EtaExpansion { if (mt.paramTypes.length == xarity) mt.paramTypes map (_ => TypeTree()) else mt.paramTypes map TypeTree val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) => - ValDef(Modifiers(Synthetic | Param), name, TypeTree(tpe), EmptyTree).withPos(tree.pos)) + ValDef(name, TypeTree(tpe), EmptyTree).withFlags(Synthetic | Param).withPos(tree.pos)) val ids = mt.paramNames map (name => Ident(name).withPos(tree.pos)) val body = Apply(lifted, ids) diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala index e8bb1b9e7..0ca681d32 100644 --- a/src/dotty/tools/dotc/typer/Namer.scala +++ b/src/dotty/tools/dotc/typer/Namer.scala @@ -361,14 +361,14 @@ class Namer { typer: Typer => */ def mergeCompanionDefs() = { val classDef = mutable.Map[TypeName, TypeDef]() - for (cdef @ TypeDef(mods, name, _) <- stats) + for (cdef @ TypeDef(name, _) <- stats) if (cdef.isClassDef) classDef(name) = cdef - for (mdef @ ModuleDef(_, name, _) <- stats) + for (mdef @ ModuleDef(name, _) <- stats) classDef get name.toTypeName match { case Some(cdef) => - val Thicket(vdef :: (mcls @ TypeDef(_, _, impl: Template)) :: Nil) = mdef.attachment(ExpandedTree) + val Thicket(vdef :: (mcls @ TypeDef(_, impl: Template)) :: Nil) = mdef.attachment(ExpandedTree) cdef.attachmentOrElse(ExpandedTree, cdef) match { - case Thicket(cls :: mval :: TypeDef(_, _, compimpl: Template) :: crest) => + case Thicket(cls :: mval :: TypeDef(_, compimpl: Template) :: crest) => val mcls1 = cpy.TypeDef(mcls)( rhs = cpy.Template(impl)(body = compimpl.body ++ impl.body)) mdef.putAttachment(ExpandedTree, Thicket(vdef :: mcls1 :: Nil)) @@ -433,7 +433,7 @@ class Namer { typer: Typer => protected implicit val ctx: Context = localContext(cls).setMode(ictx.mode &~ Mode.InSuperCall) - val TypeDef(_, name, impl @ Template(constr, parents, self, body)) = original + val TypeDef(name, impl @ Template(constr, parents, self, body)) = original val (params, rest) = body span { case td: TypeDef => td.mods is Param @@ -635,7 +635,7 @@ class Namer { typer: Typer => /** The type signature of a DefDef with given symbol */ def defDefSig(ddef: DefDef, sym: Symbol)(implicit ctx: Context) = { - val DefDef(_, name, tparams, vparamss, _, _) = ddef + val DefDef(name, tparams, vparamss, _, _) = ddef completeParams(tparams) vparamss foreach completeParams val isConstructor = name == nme.CONSTRUCTOR diff --git a/src/dotty/tools/dotc/typer/ReTyper.scala b/src/dotty/tools/dotc/typer/ReTyper.scala index 713549840..a2d4ebad8 100644 --- a/src/dotty/tools/dotc/typer/ReTyper.scala +++ b/src/dotty/tools/dotc/typer/ReTyper.scala @@ -71,8 +71,9 @@ class ReTyper extends Typer { override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType)(fallBack: (Tree, TyperState) => Tree)(implicit ctx: Context): Tree = fallBack(tree, ctx.typerState) - override def addTypedModifiersAnnotations(mods: untpd.Modifiers, sym: Symbol)(implicit ctx: Context): Modifiers = - typedModifiers(mods, sym) + override def addTypedModifiersAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = + () // was: typedModifiers(Modifiers(sym), sym) + // but annotations are not transformed after typer, so no use to check them. override def ensureConstrCall(cls: ClassSymbol, parents: List[Tree])(implicit ctx: Context): List[Tree] = parents diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala index a5396d445..93a8dff7d 100644 --- a/src/dotty/tools/dotc/typer/Typer.scala +++ b/src/dotty/tools/dotc/typer/Typer.scala @@ -312,7 +312,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit case templ: untpd.Template => import untpd._ val x = tpnme.ANON_CLASS - val clsDef = TypeDef(Modifiers(Final), x, templ) + val clsDef = TypeDef(x, templ).withFlags(Final) typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt) case _ => val tpt1 = typedType(tree.tpt) @@ -538,10 +538,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val inferredParams: List[untpd.ValDef] = for ((param, i) <- params.zipWithIndex) yield if (!param.tpt.isEmpty) param - else { - val paramTpt = untpd.TypeTree(inferredParamType(param, protoFormal(i))) - cpy.ValDef(param)(param.mods, param.name, paramTpt, param.rhs) - } + else cpy.ValDef(param)(tpt = untpd.TypeTree(inferredParamType(param, protoFormal(i)))) // Define result type of closure as the expected type, thereby pushing // down any implicit searches. We do this even if the expected type is not fully @@ -729,7 +726,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val tpt1 = if (tree.tpt.isEmpty) TypeTree(defn.ObjectType) else typedAheadType(tree.tpt) val refineClsDef = desugar.refinedTypeToClass(tree) val refineCls = createSymbol(refineClsDef).asClass - val TypeDef(_, _, Template(_, _, _, refinements1)) = typed(refineClsDef) + val TypeDef(_, Template(_, _, _, refinements1)) = typed(refineClsDef) assert(tree.refinements.length == refinements1.length, s"${tree.refinements} != $refinements1") def addRefinement(parent: Type, refinement: Tree): Type = { typr.println(s"adding refinement $refinement") @@ -785,10 +782,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit assignType(cpy.Alternative(tree)(trees1), trees1) } - def addTypedModifiersAnnotations(mods: untpd.Modifiers, sym: Symbol)(implicit ctx: Context): Modifiers = { - val mods1 = typedModifiers(mods, sym) + def addTypedModifiersAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = { + val mods1 = typedModifiers(untpd.modsDeco(mdef).mods, sym) for (tree <- mods1.annotations) sym.addAnnotation(Annotation(tree)) - mods1 } def typedModifiers(mods: untpd.Modifiers, sym: Symbol)(implicit ctx: Context): Modifiers = track("typedModifiers") { @@ -802,37 +798,37 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = track("typedValDef") { - val ValDef(mods, name, tpt, rhs) = vdef - val mods1 = addTypedModifiersAnnotations(mods, sym) + val ValDef(name, tpt, rhs) = vdef + addTypedModifiersAnnotations(vdef, sym) val tpt1 = typedType(tpt) val rhs1 = rhs match { 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)(name, tpt1, rhs1), sym) } def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") { - val DefDef(mods, name, tparams, vparamss, tpt, rhs) = ddef - val mods1 = addTypedModifiersAnnotations(mods, sym) + val DefDef(name, tparams, vparamss, tpt, rhs) = ddef + addTypedModifiersAnnotations(ddef, sym) val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef]) val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef]) 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)(name, tparams1, vparamss1, tpt1, rhs1), sym) //todo: make sure dependent method types do not depend on implicits or by-name params } def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(implicit ctx: Context): Tree = track("typedTypeDef") { - val TypeDef(mods, name, rhs) = tdef - val mods1 = addTypedModifiersAnnotations(mods, sym) + val TypeDef(name, rhs) = tdef + addTypedModifiersAnnotations(tdef, sym) val _ = typedType(rhs) // unused, typecheck only to remove from typedTree - assignType(cpy.TypeDef(tdef)(mods1, name, TypeTree(sym.info), Nil), sym) + assignType(cpy.TypeDef(tdef)(name, TypeTree(sym.info), Nil), sym) } def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") { - val TypeDef(mods, name, impl @ Template(constr, parents, self, body)) = cdef + val TypeDef(name, impl @ Template(constr, parents, self, body)) = cdef val superCtx = ctx.superCallContext def typedParent(tree: untpd.Tree): Tree = if (tree.isType) typedType(tree)(superCtx) @@ -843,7 +839,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit result } - val mods1 = addTypedModifiersAnnotations(mods, cls) + addTypedModifiersAnnotations(cdef, cls) val constr1 = typed(constr).asInstanceOf[DefDef] val parentsWithClass = ensureFirstIsClass(parents mapconserve typedParent, cdef.pos.toSynthetic) val parents1 = ensureConstrCall(cls, parentsWithClass)(superCtx) @@ -854,7 +850,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val impl1 = cpy.Template(impl)(constr1, parents1, self1, body1) .withType(dummy.nonMemberTermRef) checkVariance(impl1) - assignType(cpy.TypeDef(cdef)(mods1, name, impl1, Nil), cls) + assignType(cpy.TypeDef(cdef)(name, impl1, Nil), cls) // todo later: check that // 1. If class is non-abstract, it is instantiatable: diff --git a/src/dotty/tools/dotc/typer/VarianceChecker.scala b/src/dotty/tools/dotc/typer/VarianceChecker.scala index e1f50ded9..8fff52170 100644 --- a/src/dotty/tools/dotc/typer/VarianceChecker.scala +++ b/src/dotty/tools/dotc/typer/VarianceChecker.scala @@ -128,7 +128,7 @@ class VarianceChecker()(implicit ctx: Context) { traverseChildren(tree) case tree: ValDef => checkVariance(sym) - case DefDef(_, _, tparams, vparamss, _, _) => + case DefDef(_, tparams, vparamss, _, _) => checkVariance(sym) tparams foreach traverse vparamss foreach (_ foreach traverse) |