Drop modifiers as separate data from MemberDef trees

Typed MemberDef trees now take the modifiers from their symbol's data.

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)