Remove some duplication in Namers/MethodSynthesis

Always emit accessors for traits,
since the fields will disappear in Mixins.
We need them around until Constructors,
so that their RHS can be moved to the $init$ method.

Mixin:
 - changes traits in the following way:
   - drops fields
   - replaces access to fields by usage of trait-field-setter
   - adds abstract field setter
 - mixes the following members into class that extends trait:
    - field
    - accessors (for fields, super, outer, trait-field-setter, ???)

Author: adriaanm

src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala

@@ -139,23 +139,25 @@ trait MethodSynthesis {
       if (nme.isSetterName(name))
         ValOrValWithSetterSuffixError(tree)
 
-      tree.symbol = (
+      tree.symbol =
         if (mods.isLazy) {
           val lazyValGetter = LazyValGetter(tree).createAndEnterSymbol()
           enterLazyVal(tree, lazyValGetter)
         } else {
-          if (mods.isPrivateLocal)
+          if (mods.isPrivateLocal && mods.isCaseAccessor)
             PrivateThisCaseClassParameterError(tree)
-          val getter = Getter(tree).createAndEnterSymbol()
+          val getter = Getter(tree)
+          val getterSym = getter.createAndEnterSymbol()
           // Create the setter if necessary.
           if (mods.isMutable)
             Setter(tree).createAndEnterSymbol()
 
-          // If abstract, the tree gets the getter's symbol.  Otherwise, create a field.
-          if (mods.isDeferred) getter setPos tree.pos
+          // Create a field if the getter requires storage, otherwise,
+          // the getter's abstract and the tree gets the getter's symbol.
+          if (getter.noFieldNeeded) getterSym setPos tree.pos
           else enterStrictVal(tree)
         }
-      )
+
 
       enterBeans(tree)
     }
@@ -177,11 +179,11 @@ trait MethodSynthesis {
     }
 
     def addDerivedTrees(typer: Typer, stat: Tree): List[Tree] = stat match {
-      case vd @ ValDef(mods, name, tpt, rhs) if !noFinishGetterSetter(vd) =>
+      case vd @ ValDef(mods, name, tpt, rhs) if deriveAccessors(vd) =>
         // If we don't save the annotations, they seem to wander off.
         val annotations = stat.symbol.initialize.annotations
         val trees = (
-          allValDefDerived(vd)
+          (Field(vd) :: standardAccessors(vd) ::: beanAccessors(vd))
                 map (acc => atPos(vd.pos.focus)(acc derive annotations))
           filterNot (_ eq EmptyTree)
         )
@@ -221,11 +223,11 @@ trait MethodSynthesis {
         stat :: Nil
       }
 
-    def standardAccessors(vd: ValDef): List[DerivedFromValDef] = (
+    def standardAccessors(vd: ValDef): List[DerivedFromValDef] =
       if (vd.mods.isMutable && !vd.mods.isLazy) List(Getter(vd), Setter(vd))
       else if (vd.mods.isLazy) List(LazyValGetter(vd))
       else List(Getter(vd))
-    )
+
     def beanAccessors(vd: ValDef): List[DerivedFromValDef] = {
       val setter = if (vd.mods.isMutable) List(BeanSetter(vd)) else Nil
       if (vd.symbol hasAnnotation BeanPropertyAttr)
@@ -234,11 +236,6 @@ trait MethodSynthesis {
         BooleanBeanGetter(vd) :: setter
       else Nil
     }
-    def allValDefDerived(vd: ValDef) = {
-      val field = if (vd.mods.isDeferred || (vd.mods.isLazy && hasUnitType(vd.symbol))) Nil
-                  else List(Field(vd))
-      field ::: standardAccessors(vd) ::: beanAccessors(vd)
-    }
 
     // Take into account annotations so that we keep annotated unit lazy val
     // to get better error message already from the cps plugin itself
@@ -310,6 +307,8 @@ trait MethodSynthesis {
       def derivedSym: Symbol = tree.symbol
       def derivedTree: Tree  = EmptyTree
 
+      def noFieldNeeded = isDeferred || (mods.isLazy && hasUnitType(basisSym))
+
       def isSetter   = false
       def isDeferred = mods.isDeferred
       def keepClean  = false  // whether annotations whose definitions are not meta-annotated should be kept.
@@ -341,10 +340,10 @@ trait MethodSynthesis {
         case (p :: Nil) :: _  => p
         case _                => NoSymbol
       }
-      private def setterRhs = (
-        if (mods.isDeferred || derivedSym.isOverloaded) EmptyTree
+      private def setterRhs =
+        if (isDeferred || derivedSym.isOverloaded) EmptyTree
         else Assign(fieldSelection, Ident(setterParam))
-      )
+
       private def setterDef = DefDef(derivedSym, setterRhs)
       override def derivedTree: Tree = if (setterParam == NoSymbol) EmptyTree else setterDef
     }
@@ -385,8 +384,8 @@ trait MethodSynthesis {
       }
     }
     case class Getter(tree: ValDef) extends BaseGetter(tree) {
-      override def derivedSym = if (mods.isDeferred) basisSym else basisSym.getterIn(enclClass)
-      private def derivedRhs  = if (mods.isDeferred) EmptyTree else fieldSelection
+      override def derivedSym = if (isDeferred) basisSym  else basisSym.getterIn(enclClass)
+      private def derivedRhs  = if (isDeferred) EmptyTree else fieldSelection
       private def derivedTpt = {
         // For existentials, don't specify a type for the getter, even one derived
         // from the symbol! This leads to incompatible existentials for the field and
@@ -400,7 +399,7 @@ trait MethodSynthesis {
           // Range position errors ensue if we don't duplicate this in some
           // circumstances (at least: concrete vals with existential types.)
           case ExistentialType(_, _)  => TypeTree() setOriginal (tree.tpt.duplicate setPos tree.tpt.pos.focus)
-          case _ if mods.isDeferred   => TypeTree() setOriginal tree.tpt // keep type tree of original abstract field
+          case _ if isDeferred        => TypeTree() setOriginal tree.tpt // keep type tree of original abstract field
           case tp                     => TypeTree(tp)
         }
         tpt setPos tree.tpt.pos.focus
@@ -432,10 +431,9 @@ trait MethodSynthesis {
       override def derivedTree: DefDef = {
         val ValDef(_, _, tpt0, rhs0) = tree
         val rhs1 = context.unit.transformed.getOrElse(rhs0, rhs0)
-        val body = (
-          if (tree.symbol.owner.isTrait || hasUnitType(basisSym)) rhs1
-          else gen.mkAssignAndReturn(basisSym, rhs1)
-        )
+        val body = if (noFieldNeeded) rhs1
+                   else gen.mkAssignAndReturn(basisSym, rhs1)
+
         derivedSym setPos tree.pos // cannot set it at createAndEnterSymbol because basisSym can possibly still have NoPosition
         val ddefRes = DefDef(derivedSym, new ChangeOwnerAndModuleClassTraverser(basisSym, derivedSym)(body))
         // ValDef will have its position focused whereas DefDef will have original correct rangepos
@@ -462,8 +460,13 @@ trait MethodSynthesis {
       // By default annotations go to the field, except if the field is
       // generated for a class parameter (PARAMACCESSOR).
       override def keepClean = !mods.isParamAccessor
+
+      override def derivedSym =
+        if (noFieldNeeded) NoSymbol
+        else super.derivedSym
+
       override def derivedTree = (
-        if (mods.isDeferred) EmptyTree
+        if (derivedSym eq NoSymbol) EmptyTree
         else if (mods.isLazy) copyValDef(tree)(mods = mods | flagsExtra, name = this.name, rhs = EmptyTree).setPos(tree.pos.focus)
         else copyValDef(tree)(mods = mods | flagsExtra, name = this.name)
       )

src/compiler/scala/tools/nsc/typechecker/Namers.scala

@@ -118,18 +118,16 @@ trait Namers extends MethodSynthesis {
     // PRIVATE | LOCAL are fields generated for primary constructor arguments
     // @PP: ...or fields declared as private[this].  PARAMACCESSOR marks constructor arguments.
     // Neither gets accessors so the code is as far as I know still correct.
-    def noEnterGetterSetter(vd: ValDef) = !vd.mods.isLazy && (
-         !owner.isClass
-      || (vd.mods.isPrivateLocal && !vd.mods.isCaseAccessor)
-      || (vd.name startsWith nme.OUTER)
-      || (context.unit.isJava)
-      || isEnumConstant(vd)
-    )
+    // all lazy vals need accessors, even private[this]
+    // we can't emit fields in traits, so must add accessors
+    // TODO: this is duplicative with MethodSynthesis
+    def deriveAccessors(vd: ValDef) = vd.mods.isLazy || owner.isTrait || (owner.isClass && deriveAccessorsInClass(vd))
 
-    def noFinishGetterSetter(vd: ValDef) = (
-         (vd.mods.isPrivateLocal && !vd.mods.isLazy) // all lazy vals need accessors, even private[this]
-      || vd.symbol.isModuleVar
-      || isEnumConstant(vd))
+    def deriveAccessorsInClass(vd: ValDef) = !(
+      (vd.mods.isPrivateLocal && !vd.mods.isCaseAccessor)
+        || (vd.name startsWith nme.OUTER)
+        || vd.symbol.isModuleVar // ???
+        || isEnumConstant(vd))
 
     /** Determines whether this field holds an enum constant.
       * To qualify, the following conditions must be met:
@@ -655,14 +653,12 @@ trait Namers extends MethodSynthesis {
       }
     }
 
-    def enterValDef(tree: ValDef) {
-      if (noEnterGetterSetter(tree))
-        assignAndEnterFinishedSymbol(tree)
-      else
-        enterGetterSetter(tree)
+    def enterValDef(vd: ValDef) {
+      if (!context.unit.isJava && deriveAccessors(vd)) enterGetterSetter(vd)
+      else assignAndEnterFinishedSymbol(vd)
 
-      if (isEnumConstant(tree))
-        tree.symbol setInfo ConstantType(Constant(tree.symbol))
+      if (isEnumConstant(vd))
+        vd.symbol setInfo ConstantType(Constant(vd.symbol))
     }
 
     def enterLazyVal(tree: ValDef, lazyAccessor: Symbol): TermSymbol = {
@@ -673,6 +669,7 @@ trait Namers extends MethodSynthesis {
       // via "x$lzy" as can be seen in test #3927.
       val sym = (
         if (owner.isClass) createFieldSymbol(tree)
+          // TODO owner.isTrait
         else owner.newValue(tree.name append nme.LAZY_LOCAL, tree.pos, (tree.mods.flags | ARTIFACT) & ~IMPLICIT)
       )
       enterValSymbol(tree, sym setFlag MUTABLE setLazyAccessor lazyAccessor)