refactor accessor/field derivation

in preparation of moving to compute-method style
which in turn hopefully will be more manageable for specialization

Author: adriaanm

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

@@ -390,13 +390,10 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       }
     }
 
-    private def transformStat(exprOwner: Symbol)(stat: Tree): List[Tree] = {
-      val clazz = currentOwner
-      val statSym = stat.symbol
-
-      // println(s"transformStat $statSym in ${exprOwner.ownerChain}")
-      //        currentRun.trackerFactory.snapshot()
+    def rhsAtOwner(stat: ValOrDefDef, newOwner: Symbol): Tree =
+      atOwner(newOwner)(super.transform(stat.rhs.changeOwner(stat.symbol -> newOwner)))
 
+    private def deriveStoredAccessor(clazz: Symbol, stat: ValOrDefDef, fieldMemoization: FieldMemoization, exprOwner: Symbol): List[Tree] = {
       // Which symbol should own `rhs`, as the expression is lifted from `statSym` to the class's template?
       // Normally, the local dummy (`exprOwner`) is the owner for stats in the template (not `clazz`!)
       // when we get owners wrong, the following fails:
@@ -406,21 +403,39 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       //   - test/files/trait-defaults/ultimate-nesting.scala,
       //     where a nested module class is separated from its module, as well as from the `settings` reference
       //     (this was due to changeOwner not changing a module's moduleClass's owner in addition to the module's owner)
-      def initEffect(rhs: Tree, assignSym: Symbol) = {
+      val initEffect = {
         // println(s"initEffect: owner $statSym --> $exprOwner (currentOwner= $currentOwner)")
         // println(s"initEffect for $assignSym is $rhs")
 
-        val lifted = atOwner(exprOwner)(super.transform(rhs.changeOwner(statSym -> exprOwner)))
+        val lifted = rhsAtOwner(stat, exprOwner)
+        import fieldMemoization.assignSym
 
         if (assignSym eq NoSymbol) lifted
-        else localTyper.typedPos(rhs.pos) {
+        else localTyper.typedPos(stat.pos) {
           val qual = Select(This(clazz), assignSym)
           if (assignSym.isSetter) Apply(qual, List(lifted))
           else Assign(qual, lifted)
         }
       }
 
-      def init(rhs: Tree)(implicit fieldMemoization: FieldMemoization) = initEffect(rhs, fieldMemoization.assignSym) :: Nil
+      // DefDef(computeSym, rhsAtOwner(stat, computeSym))
+      // def deriveRhs(oldRhs: Tree) = localTyper.typedPos(oldRhs.pos)(Apply(gen.mkAttributedRef(computeSym), Nil))
+
+      def deriveRhs(oldRhs: Tree) = EmptyTree
+      val derivedStat = stat match {
+        case dd: DefDef => deriveDefDef(stat)(deriveRhs)
+        case vd: ValDef => deriveValDef(stat)(deriveRhs)
+      }
+
+      derivedStat :: initEffect :: Nil
+    }
+
+    private def transformStat(exprOwner: Symbol)(stat: Tree): List[Tree] = {
+      val clazz = currentOwner
+      val statSym = stat.symbol
+
+      // println(s"transformStat $statSym in ${exprOwner.ownerChain}")
+      //        currentRun.trackerFactory.snapshot()
 
       /*
         For traits, the getter has the val's RHS, which is already constant-folded. There is no valdef.
@@ -431,39 +446,35 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
         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.)
+        (In some future version, accessors for non-stored, but effectful fields,
+         would 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) =>
-          // for accessors defined in a class, this wasn't done yet ???
-          def statInlinedConstantRhs = deriveDefDef(stat)(_ => gen.mkAttributedQualifier(rhs.tpe))
+        case stat@DefDef(_, _, _, _, _, rhs) if (rhs ne EmptyTree) && (statSym hasFlag ACCESSOR) && !excludedAccessorOrFieldByFlags(statSym) =>
+          /* TODO: defer replacing ConstantTyped tree by the corresponding constant until erasure
+             (until then, trees should not be constant-folded -- only their type tracks the resulting constant) */
+          def statInlinedConstantRhs =
+            if (clazz.isTrait) stat // we've already done this for traits.. the asymmetry will be solved by the above todo
+            else deriveDefDef(stat)(_ => gen.mkAttributedQualifier(rhs.tpe))
 
-          def dropRhs = deriveDefDef(stat)(_ => EmptyTree)
-          implicit val fieldMemoization = fieldMemoizationIn(statSym, clazz)
+          val fieldMemoization = fieldMemoizationIn(statSym, clazz)
 
-          def deriveStoredAccessor(stat: Tree) = stat
-          // if we decide to have non-stored fields with initialization effects:
-//            if (!fieldMemoization.stored) deriveUnitDef(stat)
-//            else stat
+          // if we decide to have non-stored fields with initialization effects, the stat's RHS should be replaced by unit
+          // if (!fieldMemoization.stored) deriveUnitDef(stat) else stat
 
-          if (clazz.isTrait)
-            if (fieldMemoization.pureConstant) stat :: Nil
-            else deriveStoredAccessor(dropRhs) :: init(rhs)
-          else
-            if (fieldMemoization.pureConstant) statInlinedConstantRhs :: Nil
-            else deriveStoredAccessor(stat) :: Nil
+          if (fieldMemoization.pureConstant)  statInlinedConstantRhs :: Nil
+          else if (clazz.isTrait) deriveStoredAccessor(clazz, stat, fieldMemoization, exprOwner)
+          else stat :: Nil
 
-        case ValDef(mods, _, _, rhs) if (rhs ne EmptyTree) && !excludedAccessorOrFieldByFlags(statSym) =>
-          def dropRhs = deriveValDef(stat)(_ => EmptyTree)
-          implicit val fieldMemoization = fieldMemoizationIn(statSym, clazz)
+        case stat@ValDef(mods, _, _, rhs) if (rhs ne EmptyTree) && !excludedAccessorOrFieldByFlags(statSym) =>
+          val fieldMemoization = fieldMemoizationIn(statSym, clazz)
 
           // 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) -- not used currently
+          else if (fieldMemoization.stored) deriveStoredAccessor(clazz, stat, fieldMemoization, exprOwner)
+          else rhsAtOwner(stat, exprOwner) :: Nil // (b) -- not used currently
 
         case tree => List (
           if (exprOwner != currentOwner && tree.isTerm) atOwner(exprOwner)(super.transform(tree))