bla

Author: adriaanm

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

@@ -597,10 +597,16 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     def intoConstructor(oldowner: Symbol, tree: Tree) =
       intoConstructorTransformer transform tree.changeOwner(oldowner -> constr.symbol)
 
-    // Should tree be moved in front of super constructor call?
-    def canBeMoved(tree: Tree) = tree match {
-      case ValDef(mods, _, _, _) => (mods hasFlag PRESUPER | PARAMACCESSOR)
-      case _                     => false
+    private def assignmentIntoCtor(assignSym: Symbol, stat: ValOrDefDef): Unit = {
+      val rhs1 = intoConstructor(assignSym, stat.rhs)
+
+      // Should tree be moved in front of super constructor call?
+      // (I.e., is it derived from an early definition?)
+      val constrBufPart =
+        if (stat.mods hasFlag PRESUPER | PARAMACCESSOR) constrPrefixBuf
+        else constrStatBuf
+
+      constrBufPart += mkAssign(assignSym, rhs1)
     }
 
     // Create an assignment to class field `to` with rhs `from`
@@ -668,6 +674,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
             if (stat.symbol.isPrimaryConstructor) ()
             else if (stat.symbol.isConstructor) auxConstructorBuf += stat
             else if (inTrait && stat.symbol.isAccessor) {
+              assignmentIntoCtor(stat)
               defBuf += deriveDefDef(dd)(_ => EmptyTree)
             }
             else defBuf += stat
@@ -679,11 +686,9 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         // if the val def is an early initialized or a parameter accessor, it goes
         // before the superclass constructor call, otherwise it goes after.
         // Lazy vals don't get the assignment in the constructor.
-        if (!stat.symbol.tpe.isInstanceOf[ConstantType]) {
+        if (!stat.symbol.tpe.isInstanceOf[ConstantType]) { // TODO: MethodSynthesis should no longer emit ValDefs with ConstantTypes
           if (rhs != EmptyTree && !stat.symbol.isLazy) {
-            val rhs1 = intoConstructor(stat.symbol, rhs)
-            (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign(
-              stat.symbol, rhs1)
+            assignmentIntoCtor(stat.symbol, stat)
           }
           defBuf += deriveValDef(stat)(_ => EmptyTree)
         }

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

@@ -302,8 +302,14 @@ trait MethodSynthesis {
       def derivedSym: Symbol = tree.symbol
       def derivedTree: Tree  = EmptyTree
 
-      // TODO: also don't need field when type is a ConstantType, right? Use typeNeedsNoStorage
-      def noFieldNeeded = isDeferred || (mods.isLazy && definitions.isUnitType(basisSym.tpe))
+      // - 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)
 
       def isSetter   = false
       def isDeferred = mods.isDeferred
@@ -337,7 +343,7 @@ trait MethodSynthesis {
         case _                => NoSymbol
       }
       private def setterRhs =
-        if (isDeferred || derivedSym.isOverloaded) EmptyTree
+        if (noFieldNeeded || derivedSym.isOverloaded) EmptyTree
         else Assign(fieldSelection, Ident(setterParam))
 
       private def setterDef = DefDef(derivedSym, setterRhs)
@@ -380,7 +386,7 @@ trait MethodSynthesis {
     }
     case class Getter(tree: ValDef) extends BaseGetter(tree) {
       override def derivedSym = if (isDeferred) basisSym  else basisSym.getterIn(enclClass)
-      private def derivedRhs  = if (isDeferred) EmptyTree else fieldSelection
+      private def derivedRhs  = if (noFieldNeeded) 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
@@ -401,12 +407,14 @@ trait MethodSynthesis {
       }
       override def derivedTree: DefDef = newDefDef(derivedSym, derivedRhs)(tpt = derivedTpt)
     }
+
     /** Implements lazy value accessors:
-     *    - for lazy values of type Unit and all lazy fields inside traits,
-     *      the rhs is the initializer itself
-     *    - for all other lazy values z the accessor is a block of this form:
-     *      { z = <rhs>; z } where z can be an identifier or a field.
-     */
+      *    - for lazy values of type Unit and all lazy fields inside traits,
+      *      the rhs is the initializer itself, because we'll just "compute" the result on every access
+      *     ("computing" unit / constant type is free -- the side-effect is still only run once, using the init bitmap)
+      *    - for all other lazy values z the accessor is a block of this form:
+      *      { z = <rhs>; z } where z can be an identifier or a field.
+      */
     case class LazyValGetter(tree: ValDef) extends BaseGetter(tree) {
       class ChangeOwnerAndModuleClassTraverser(oldowner: Symbol, newowner: Symbol)
         extends ChangeOwnerTraverser(oldowner, newowner) {