produce identical bytecode for constant trait val getters

I couldn't bring myself to emit the unused fields that we
used to emit for constant vals, even though the getters
immediately return the constant, and thus the field goes unused.

In the next version, there's no need to synthesize impls
for these in subclasses -- the getter can be implemented
in the interface.

Author: adriaanm

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

@@ -111,7 +111,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
 
   class FieldMemoization(accessorOrField: Symbol, site: Symbol) {
-    private val tp = fieldTypeOfAccessorIn(accessorOrField, site.thisType)
+    val tp = fieldTypeOfAccessorIn(accessorOrField, site.thisType)
     // not stored, no side-effect
     val pureConstant = tp.isInstanceOf[ConstantType]
 
@@ -176,8 +176,9 @@ 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) {
+          val fieldMemoization = fieldMemoizationIn(accessor, clazz)
           // check flags before calling makeNotPrivate
-          val memoizedGetter = !(accessor hasFlag (DEFERRED | LAZY)) && fieldMemoizationIn(accessor, clazz).stored
+          val accessorUnderConsideration = !(accessor hasFlag (DEFERRED | LAZY))
 
           // destructively mangle accessor's name (which may cause rehashing of decls), also sets flags
           if (accessor hasFlag PRIVATE) accessor makeNotPrivate clazz
@@ -194,12 +195,12 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           // (not sure why this only problem only arose when we started setting the notPROTECTED flag)
 
           // derive trait setter after calling makeNotPrivate (so that names are mangled consistently)
-          if (memoizedGetter) {
+          if (accessorUnderConsideration && fieldMemoization.stored) {
             setTraitAccessorFlags(accessor)
 
             if (accessor hasFlag STABLE) // TODO: check isGetter?
               newSetters += newTraitSetter(accessor, clazz)
-          }
+          } else if (fieldMemoization.pureConstant) setTraitAccessorFlags(accessor) // TODO: remove when we no longer care about producing identical bytecode
         }}
 
         if (newSetters nonEmpty) {
@@ -348,6 +349,12 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
       val accessorsAndFieldsNeedingTrees = clazz.info.decls.toList.filter(checkAndClearNeedsTrees)
 
+      def getterBody(getter: Symbol): Tree = {
+        val fieldMemoization = fieldMemoizationIn(getter, clazz)
+        if (fieldMemoization.pureConstant) gen.mkAttributedQualifier(fieldMemoization.tp) // TODO: drop when we no longer care about producing identical bytecode
+        else fieldAccess(getter)
+      }
+
 //      println(s"accessorsAndFieldsNeedingTrees: $accessorsAndFieldsNeedingTrees")
       def setterBody(setter: Symbol): Tree = {
         // trait setter in trait
@@ -360,7 +367,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
       accessorsAndFieldsNeedingTrees map {
         case setter if setter.isSetter   => localTyper.typedPos(setter.pos)(DefDef(setter, setterBody(setter))).asInstanceOf[DefDef]
-        case getter if getter.isAccessor => localTyper.typedPos(getter.pos)(DefDef(getter, fieldAccess(getter))).asInstanceOf[DefDef]
+        case getter if getter.isAccessor => localTyper.typedPos(getter.pos)(DefDef(getter, getterBody(getter))).asInstanceOf[DefDef]
         case field                       => assert(field.isValue && !field.isMethod, s"Expecting field, got $field")
           localTyper.typedPos(field.pos)(ValDef(field)).asInstanceOf[ValDef]
       }