emit needed members for fields in tratis from start

Author: adriaanm

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -172,7 +172,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
   /** Add all members to be mixed in into a (non-trait-) class
     * For every mixin trait T that is not also inherited by the superclass:
-    *   - for every abstract accessor in T, add a field and an implementation for that accessor
+    *   - for every abstract accessor in T, add a field (expanding its name if needed) and an implementation for that accessor
     *   - for every super accessor in T, add an implementation of that accessor
     *   - for every module in T, add a module
     *

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

@@ -149,12 +149,12 @@ trait MethodSynthesis {
           val getter = Getter(tree)
           val getterSym = getter.createAndEnterSymbol()
           // Create the setter if necessary.
-          if (mods.isMutable)
+          if (getter.needsSetter)
             Setter(tree).createAndEnterSymbol()
 
           // 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
+          if (getter.noFieldHere) getterSym setPos tree.pos
           else enterStrictVal(tree)
         }
 
@@ -302,14 +302,16 @@ trait MethodSynthesis {
       def derivedSym: Symbol = tree.symbol
       def derivedTree: Tree  = EmptyTree
 
-      // - abstract vals have no value and thus need for a field (until they become concrete, potentially)
-      // - traits store the RHS of the field in the getter;
-      //     constructors will move the assignment to the constructor, abstracting over the field using the field setter
-      // - lazy or not, a val that stores a statically known value (unit / ConstantType) doesn't need a field either,
-      //   although the lazy value will need to consult the init bitmap to make sure the lazy compute method is only run once
-      def noFieldNeeded = isDeferred ||
-                          derivedSym.owner.isTrait ||
-                          typeNeedsNoStorage(basisSym.tpe)
+      // No field for these vals:
+      //   - abstract vals have no value we could store (until they become concrete, potentially)
+      //   - a concrete val with a statically known value (Unit / ConstantType)
+      //     performs its side effect according to lazy/strict semantics, but doesn't need to store its value
+      //     each access will "evaluate" the RHS (a literal) again
+      //   - concrete vals in traits don't yield a field here either (their getter's RHS has the initial value)
+      //     Constructors will move the assignment to the constructor, abstracting over the field using the field setter,
+      //     and Mixin will add a field to the class that mixes in the trait, implementing the accessors in terms of it
+      def noFieldHere = nothingToMemoize || derivedSym.owner.isTrait
+      protected def nothingToMemoize = isDeferred || typeNeedsNoStorage(basisSym.tpe)
 
       def isSetter   = false
       def isDeferred = mods.isDeferred
@@ -334,7 +336,7 @@ trait MethodSynthesis {
       }
     }
     sealed trait DerivedGetter extends DerivedFromValDef {
-      // TODO
+      def needsSetter = mods.isMutable || (derivedSym.owner.isTrait && !nothingToMemoize)
     }
     sealed trait DerivedSetter extends DerivedFromValDef {
       override def isSetter = true
@@ -343,7 +345,7 @@ trait MethodSynthesis {
         case _                => NoSymbol
       }
       private def setterRhs =
-        if (noFieldNeeded || derivedSym.isOverloaded) EmptyTree
+        if (noFieldHere || derivedSym.isOverloaded) EmptyTree
         else Assign(fieldSelection, Ident(setterParam))
 
       private def setterDef = DefDef(derivedSym, setterRhs)
@@ -386,7 +388,8 @@ trait MethodSynthesis {
     }
     case class Getter(tree: ValDef) extends BaseGetter(tree) {
       override def derivedSym = if (isDeferred) basisSym  else basisSym.getterIn(enclClass)
-      private def derivedRhs  = if (noFieldNeeded) tree.rhs else fieldSelection
+      private def derivedRhs  = if (noFieldHere) tree.rhs 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
@@ -434,7 +437,7 @@ trait MethodSynthesis {
       override def derivedTree: DefDef = {
         val ValDef(_, _, tpt0, rhs0) = tree
         val rhs1 = context.unit.transformed.getOrElse(rhs0, rhs0)
-        val body = if (noFieldNeeded) rhs1
+        val body = if (noFieldHere) rhs1
                    else gen.mkAssignAndReturn(basisSym, rhs1)
 
         derivedSym setPos tree.pos // cannot set it at createAndEnterSymbol because basisSym can possibly still have NoPosition
@@ -465,7 +468,7 @@ trait MethodSynthesis {
       override def keepClean = !mods.isParamAccessor
 
       override def derivedSym =
-        if (noFieldNeeded) NoSymbol
+        if (noFieldHere) NoSymbol
         else super.derivedSym
 
       override def derivedTree = (