refactor field memoization logic -- wip

Author: adriaanm

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

@@ -111,19 +111,20 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
   class FieldMemoization(accessorOrField: Symbol, site: Symbol) {
     private val tp = fieldTypeOfAccessorIn(accessorOrField, site.thisType)
-    val memoized = !tp.isInstanceOf[ConstantType]
+    // not stored, no side-effect
+    val pureConstant = tp.isInstanceOf[ConstantType]
 
-    // do not assign to field
-    // getter for Unit-typed val, or setter for var that isn't stored (of type Unit)
-    val effectOnly = isUnitType(tp) || (!site.isTrait && accessorOrField.isSetter && !memoized)
+    val stored = !(pureConstant || isUnitType(tp))
 
-    val effectful = memoized || effectOnly
-
-    val needsField = !effectOnly && memoized
+    //  - setter (for var) or getter (for val) that isn't stored
+    // (pureConstant already shortcircuits this, but it may still be a unit-typed val)
+    def deriveStoredAccessor(stat: Tree)(deriveUnitDef: Tree => Tree) =
+      if (!stored) deriveUnitDef(stat)
+      else stat
 
     //    println(s"fieldMemoizationIn $sym $site = $tp")
     def assignSym: Symbol =
-      if (effectOnly) NoSymbol
+      if (!stored) NoSymbol
       else if (accessorOrField hasFlag ACCESSOR) accessorOrField.setterIn(site)
       else accessorOrField
   }
@@ -175,7 +176,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
         // strict, memoized accessors will receive an implementation in first real class to extend this trait
         origDecls.foreach { accessor => if (accessor hasFlag ACCESSOR) {
           // check flags before calling makeNotPrivate
-          val memoizedGetter = !(accessor hasFlag (DEFERRED | LAZY)) && fieldMemoizationIn(accessor, clazz).needsField
+          val memoizedGetter = !(accessor hasFlag (DEFERRED | LAZY)) && fieldMemoizationIn(accessor, clazz).stored
 
           // destructively mangle accessor's name (which may cause rehashing of decls), also sets flags
           if (accessor hasFlag PRIVATE) accessor makeNotPrivate clazz
@@ -282,7 +283,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           // avoid creating early errors in case of conflicts (wait until refchecks);
           // also, skip overridden accessors contributed by supertraits (only act on the last overriding one)
           else if (accessorConflictsExistingVal(accessor) || isOverriddenAccessor(accessor, clazz)) Nil
-          else if (accessor.isGetter && fieldMemoizationIn(accessor, clazz).needsField) {
+          else if (accessor.isGetter && fieldMemoizationIn(accessor, clazz).stored) {
             // add field if needed
             val field = clazz.newValue(accessor.localName, accessor.pos) setInfo fieldTypeForGetterIn(accessor, clazz.thisType)
 
@@ -299,9 +300,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 //        println(s"new decls for $clazz: $mixedInAccessorAndFields")
 
         // omit fields that are not memoized, retain all other members
-        def omittableField(sym: Symbol) =
-          sym.isValue && !sym.isMethod &&
-            fieldMemoizationIn(sym, clazz).effectOnly // TODO: not yet `needsField`, to produce same bytecode as 2.12.0-M3
+        def omittableField(sym: Symbol) = sym.isValue && !sym.isMethod && !fieldMemoizationIn(sym, clazz).stored
 
         val newDecls =
           if (mixedInAccessorAndFields.isEmpty) oldDecls.filterNot(omittableField)
@@ -396,40 +395,55 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
         }
       }
 
+      def init(rhs: Tree)(implicit fieldMemoization: FieldMemoization) = initEffect(rhs, fieldMemoization.assignSym) :: Nil
+
+      /*
+        For traits, the getter has the val's RHS, which is already constant-folded. There is no valdef.
+        For classes, we still have the classic scheme of private[this] valdef + getter & setter that read/assign to the field.
+
+        There are two axes: (1) is there a side-effect to the val (2) does the val need storage?
+        For a ConstantType, both answers are "no". (For a unit-typed field, there's a side-effect, but no storage needed.)
+
+        All others (getter for trait field, valdef for class field) have their rhs moved to an initialization statement.
+        Trait accessors for stored fields are made abstract (there can be no field in a trait).
+        All accessors for non-stored, but effectful fields, receive a constant rhs,
+        as the effect is performed by the initialization statement.
+        (We could do this for unit-typed fields, but have chosen not to for backwards compatibility.)
+       */
       stat match {
+        // TODO: consolidate with ValDef case
         case DefDef(_, _, _, _, _, rhs) if (rhs ne EmptyTree) && (statSym hasFlag ACCESSOR) && !excludedAccessorOrFieldByFlags(statSym) =>
-          val fieldMemoization = fieldMemoizationIn(statSym, clazz)
-          def getterRhs(x: Tree) = if (fieldMemoization.effectOnly) mkTypedUnit(statSym.pos) else EmptyTree
-
-          // TODO: consolidate with ValDef case
-          if (clazz.isTrait) {
-            // there's a synthetic setter if val is not mutable (symbol is created in info transform)
-            if (fieldMemoization.effectful) deriveDefDef(stat)(getterRhs) :: initEffect(rhs, fieldMemoization.assignSym) :: Nil
-            else stat :: Nil
-          } else (
-            // regular getter -- field will be preserved (see case ValDef)
-            if (fieldMemoization.needsField) stat
-            // getter for Unit-typed val, or setter for var that isn't stored (of type Unit)
-            else if (fieldMemoization.effectOnly) deriveUnitDef(stat)
-            // getter for constant, emit literal for its body
-            else deriveDefDef(stat)(_ => gen.mkAttributedQualifier(rhs.tpe))
-          ) :: Nil
-
-        // If a val needs a field, an empty valdef and an assignment to its rhs go into the template
+          // for accessors defined in a class, this wasn't done yet ???
+          def statInlinedConstantRhs = deriveDefDef(stat)(_ => gen.mkAttributedQualifier(rhs.tpe))
+
+          def dropRhs = deriveDefDef(stat)(_ => EmptyTree)
+          implicit val fieldMemoization = fieldMemoizationIn(statSym, clazz)
+          def deriveStoredAccessor(tree: Tree) = fieldMemoization.deriveStoredAccessor(tree)(deriveUnitDef)
+
+          if (clazz.isTrait)
+            if (fieldMemoization.pureConstant) stat :: Nil
+            else deriveStoredAccessor(dropRhs) :: init(rhs)
+          else
+            if (fieldMemoization.pureConstant) statInlinedConstantRhs :: Nil
+            else deriveStoredAccessor(stat) :: Nil
+
         case ValDef(mods, _, _, rhs) if (rhs ne EmptyTree) && !excludedAccessorOrFieldByFlags(statSym) =>
-          val fieldMemoization = fieldMemoizationIn(statSym, clazz)
+          def dropRhs = deriveValDef(stat)(_ => EmptyTree)
+          implicit val fieldMemoization = fieldMemoizationIn(statSym, clazz)
 
-          if (fieldMemoization.needsField) deriveValDef(stat)(_ => EmptyTree) :: initEffect(rhs, fieldMemoization.assignSym) :: Nil
-          else if (fieldMemoization.effectOnly) initEffect(rhs, NoSymbol) :: Nil // drop the val entirely -- it could not have been referenced outside accesors
-          else Nil
+          // drop the val for (a) constant (pure & not-stored) and (b) not-stored (but still effectful) fields
+          if (fieldMemoization.pureConstant) Nil // (a)
+          else if (fieldMemoization.stored) dropRhs :: init(rhs)
+          else init(rhs) // (b)
 
-        case tree => List(
+        case tree => List (
           if (exprOwner != currentOwner && tree.isTerm) atOwner(exprOwner)(super.transform(tree))
           else super.transform(tree)
         )
       }
     }
 
+
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] =
       if (!currentOwner.isClass || currentOwner.isPackageClass || currentOwner.isInterface) super.transformStats(stats, exprOwner)
       else afterOwnPhase {