wipwipwip

Author: adriaanm

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

@@ -220,9 +220,10 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         detectUsages walk auxConstructorBuf
       }
     }
-
-    def needsField(sym: Symbol): Boolean = typeNeedsStorage(enteringErasure(sym.info).resultType)
-    def mustBeKept(sym: Symbol) = !(omittables(sym) || (sym.isValue && !sym.isMethod && (sym.owner.isTrait || !needsField(sym)))) // TODO: assert(!sym.owner.isTrait, sym.ownerChain)
+    def mustBeKept(sym: Symbol) = !omittable(sym)
+    // omit unused outers and non-memoized fields (I think we're no longer creating symbols for fields in traits, but still including backstop for now)
+    def omittable(sym: Symbol) = (omittables(sym) ||
+      (sym.isValue && !sym.isMethod && (!mustMemoize(sym) || sym.owner.isTrait))) // TODO: assert(!sym.owner.isTrait, sym.ownerChain)
 
   } // OmittablesHelper
 
@@ -606,7 +607,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     // it goes before the superclass constructor call, otherwise it goes after.
     // A lazy val's effect is not moved to the constructor, as it is delayed.
     private def moveEffectToCtor(stat: ValOrDefDef): Boolean = {
-      val fieldNeeded = needsField(stat.symbol)
+      val memoized = mustMemoize(stat.symbol)
 
       if (needsCtorEffect(stat)) {
         val rhs1 = intoConstructor(stat.symbol, stat.rhs)
@@ -618,7 +619,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           else constrStatBuf
 
         val effect =
-          if (fieldNeeded) {
+          if (memoized) {
             val assignSym =
               if (stat.symbol.isGetter) stat.symbol.asInstanceOf[MethodSymbol].referenced //setterIn(clazz, hasExpandedName = false) // not yet expanded -- see Mixin
               else stat.symbol
@@ -630,7 +631,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         constrBufPart += effect
       }
 
-      fieldNeeded
+      memoized
     }
 
 
@@ -695,12 +696,6 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     // Triage all template definitions to go into defBuf/auxConstructorBuf, constrStatBuf, or constrPrefixBuf.
     for (stat <- stats) stat match {
       case dd@ DefDef(_,_,_,_,_,rhs) =>
-        // We can't mark as deferred from the start, as it will be implemented automatically in the subclass
-        // it should be marked deferred in bytecode, though
-        if (inTrait && stat.symbol.isAccessor) {
-          stat.symbol setFlag DEFERRED
-        }
-
         // methods with constant result type get literals as their body
         // all methods except the primary constructor go into template
         stat.symbol.tpe match {
@@ -710,9 +705,19 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
             if (stat.symbol.isPrimaryConstructor) ()
             else if (stat.symbol.isConstructor) auxConstructorBuf += stat
             // a concrete getter's RHS is treated like a ValDef (the actual field isn't emitted until Mixin augments the class that inherits the trait)
-            else if (inTrait && stat.symbol.isGetter && (rhs ne EmptyTree)) {
-              moveEffectToCtor(dd) // ignore whether we need a field -- it will be added in the inheriting class by Mixin
-              defBuf += deriveDefDef(dd)(_ => EmptyTree)
+            else if (inTrait) {
+              // We can't mark as deferred from the start, as it will be implemented automatically in the subclass
+              // it should be marked deferred in bytecode, though
+
+              defBuf +=
+                if (stat.symbol.isGetter && (rhs ne EmptyTree)) {
+                  val memoized = moveEffectToCtor(dd)
+                  if (memoized) {
+                    stat.symbol setFlag DEFERRED
+                    deriveDefDef(dd)(_ => EmptyTree)
+                  }
+                  else stat
+                } else stat
             }
             else defBuf += stat
         }

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

@@ -257,19 +257,21 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
       for (traitMember <- traitClass.info.decls) {
         println(traitMember)
-        // accessors that need a field (and thus can't ultimately be concrete in a trait)
-        if (isConcreteAccessor(traitMember)) {
-          if (!isOverriddenAccessor(traitMember, clazz.info.baseClasses)) {
-            mixinAccessorSym(traitClass, traitMember)
-
-            //if (traitMember.isLazy) initializer(mixedInAccessor) = traitMember
-
-            // mixin one field only (this method is called for both accessors)
-            // don't mix in a field at all if it doesn't need storage
-            if (traitMember.isGetter && typeNeedsStorage(traitMember.tpe.resultType))
-              mixinFieldSym(traitMember)
+        // accessors that need an implementation and a field
+        if (traitMember.isAccessor) {
+          if (traitMember hasFlag lateDEFERRED) {
+            if (!isOverriddenAccessor(traitMember, clazz.info.baseClasses)) {
+              mixinAccessorSym(traitClass, traitMember)
+
+              //if (traitMember.isLazy) initializer(mixedInAccessor) = traitMember
+
+              // mixin one field only (this method is called for both accessors)
+              // don't mix in a field at all if it doesn't need storage
+              if (traitMember.isGetter && mustMemoize(traitMember))
+                mixinFieldSym(traitMember)
+            }
+            else devWarning(s"Overridden concrete accessor: ${traitMember.fullLocationString}")
           }
-          else devWarning(s"Overridden concrete accessor: ${traitMember.fullLocationString}")
         } else if (traitMember.isSuperAccessor) {
           val sym = superSym(traitClass, traitMember.alias)
           if (sym ne NoSymbol) mixinSuperAccessorSym(traitMember, sym)

src/reflect/scala/reflect/internal/Definitions.scala

@@ -236,7 +236,8 @@ trait Definitions extends api.StandardDefinitions {
     // Take into account annotations so that we keep annotated unit lazy val
     // to get better error message already from the cps plugin itself
     def isUnitType(tp: Type) = tp.typeSymbol == UnitClass && tp.annotations.isEmpty // you never know with annotations...
-    def typeNeedsStorage(tp: Type) = !(tp.isInstanceOf[ConstantType] || isUnitType(tp))
+    def memoizedType(tp: Type) = !(tp.isInstanceOf[ConstantType] || isUnitType(tp))
+    def mustMemoize(sym: Symbol): Boolean = memoizedType(enteringErasure(sym.info).resultType)
 
     def hasMultipleNonImplicitParamLists(member: Symbol): Boolean = hasMultipleNonImplicitParamLists(member.info)
     def hasMultipleNonImplicitParamLists(info: Type): Boolean = info match {

test/files/trait-defaults/fields.scala

@@ -37,8 +37,8 @@ trait T {
 }
 
 class C extends T {
-  val abs = "abstract"
-  val protabs = "abstract protected"
+  final val abs = "abstract"
+  final val protabs = "abstract protected"
 }
 
 object Test extends C with App