Reduce flagbit usage, remove some stale comments

Author: adriaanm

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

@@ -15,17 +15,9 @@ import symtab.Flags._
   * For traits:
   *
   *   - Namers translates a definition `val x = rhs` into a getter `def x = rhs` -- no underlying field is created.
-  *   - This phase moves `rhs` into a block nested under the template's local dummy.
-  *     If the value is memoized (stored), the block's final expression assigns the value to the val,
-  *     and the val itself is left without a rhs.
-  *     If the value of the rhs is a literal (ConstantType), it is not stored and the final expression of the block is ().
-  *     The val then retains this statically known value as its rhs.
-  *     (We could extend this to other fields that needn't be stored,
-  *      but would still need to lift their side-effects to the block.
-  *      We're mostly to set up for this, and experimented with doing this for Unit-typed vals.
-  *      No longer storing and writing to fields is too much of a a change in semantics.
-  *      Mainly regarding the memory model -- visibility of writes across threads etc would change.)
-  *   - This phase also synthesizes accessors and fields for any vals mixed into a non-trait class.
+  *   - This phase synthesizes accessors and fields for any vals mixed into a non-trait class.
+  *   - During erasure, AddInterfaces will move the rhs to an assignment in the template body.
+  *     We need to maintain the connection between getter and rhs until then, so specialization can duplicate as needed.
   *   - Constructors moves the statements in the template into the constructor,
   *     which means it will initialize the fields defined in this template (and execute the corresponding side effects).
   *
@@ -72,9 +64,11 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
   private def excludedAccessorOrFieldByFlags(statSym: Symbol): Boolean = statSym hasFlag LAZY | PRESUPER
 
   // used for internal communication between info and tree transform of this phase -- not pickled, not in initialflags
-  // TODO: reuse TRANS_FLAG for NEEDS_TREES
+  // TODO: reuse MIXEDIN for NEEDS_TREES
   override def phaseNewFlags: Long = NEEDS_TREES | OVERRIDDEN_TRAIT_SETTER
 
+  private final val OVERRIDDEN_TRAIT_SETTER = TRANS_FLAG
+
   final val TRAIT_SETTER_FLAGS = NEEDS_TREES | DEFERRED
 
   private def accessorImplementedInSubclass(accessor: Symbol) = accessor hasAllFlags (ACCESSOR | SYNTHESIZE_IMPL_IN_SUBCLASS)
@@ -164,17 +158,12 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
     private def newTraitSetter(getter: Symbol, clazz: Symbol) = {
       // Add setter for an immutable, memoizing getter
       // (can't emit during namers because we don't yet know whether it's going to be memoized or not)
-      // TODO: any flags to inherit from getter??? (probably not -- certainly exclude: stable, override, implicit, private, local)
-      // TODO: stable/mutable? (we need to access the setter from the init method, so it needs to be in the interface)
       // TODO: annotations?
-      // TODO: ARTIFACT or SYNTHETIC?? neither?
-      // protected, because implemented by subclass, never used outside of hierarchy
       val setterFlags = (getter.flags & ~(STABLE | PrivateLocal | OVERRIDE | IMPLICIT | FINAL)) | MUTABLE | ACCESSOR | TRAIT_SETTER_FLAGS
-      val setterName = nme.expandedSetterName(getter.name.setterName, clazz)
-      val setter = clazz.newMethod(setterName, getter.pos.focus, setterFlags)
-      val fieldTp = fieldTypeForGetterIn(getter, clazz.thisType)
-
-//      println(s"newTraitSetter in $clazz for $getter = $setterName : $fieldTp")
+      val setterName  = nme.expandedSetterName(getter.name.setterName, clazz)
+      val setter      = clazz.newMethod(setterName, getter.pos.focus, setterFlags)
+      val fieldTp     = fieldTypeForGetterIn(getter, clazz.thisType)
+      // println(s"newTraitSetter in $clazz for $getter = $setterName : $fieldTp")
 
       setter setInfo MethodType(List(setter.newSyntheticValueParam(fieldTp)), UnitTpe)
       setter

src/reflect/scala/reflect/internal/Flags.scala

@@ -176,7 +176,6 @@ class Flags extends ModifierFlags {
 
   // flags used strictly internally in the Fields phase (info/tree transform):
   final val NEEDS_TREES   = 1L << 59           // this symbol needs a tree. (distinct from SYNTHESIZE_IMPL_IN_SUBCLASS)
-  final val OVERRIDDEN_TRAIT_SETTER = 1L << 60 // this setter gets a unit body.
 
   // ------- shift definitions -------------------------------------------------------
   //
@@ -276,7 +275,7 @@ class Flags extends ModifierFlags {
   final val PrintableFlags =
     ExplicitFlags | BridgeFlags | LOCAL | SYNTHETIC | STABLE | CASEACCESSOR | MACRO |
     ACCESSOR | SUPERACCESSOR | PARAMACCESSOR | STATIC | SPECIALIZED | SYNCHRONIZED | ARTIFACT |
-    SYNTHESIZE_IMPL_IN_SUBCLASS | NEEDS_TREES | OVERRIDDEN_TRAIT_SETTER
+    SYNTHESIZE_IMPL_IN_SUBCLASS | NEEDS_TREES
 
   /** When a symbol for a field is created, only these flags survive
    *  from Modifiers.  Others which may be applied at creation time are:
@@ -461,7 +460,7 @@ class Flags extends ModifierFlags {
     case  JAVA_DEFAULTMETHOD => "<defaultmethod>"                     // (1L << 47)
     case           JAVA_ENUM => "<enum>"                              // (1L << 48)
     case     JAVA_ANNOTATION => "<annotation>"                        // (1L << 49)
-    case    NEEDS_TREES      => "<needs_trees>"                       // (1L << 50)
+    case SYNTHESIZE_IMPL_IN_SUBCLASS => "<sub_synth>"                 // (1L << 50)
     case      `lateDEFERRED` => "<latedeferred>"                      // (1L << 51)
     case         `lateFINAL` => "<latefinal>"                         // (1L << 52)
     case        `lateMETHOD` => "<latemethod>"                        // (1L << 53)
@@ -470,8 +469,7 @@ class Flags extends ModifierFlags {
     case      `notPROTECTED` => "<notprotected>"                      // (1L << 56)
     case       `notOVERRIDE` => "<notoverride>"                       // (1L << 57)
     case        `notPRIVATE` => "<notprivate>"                        // (1L << 58)
-    case SYNTHESIZE_IMPL_IN_SUBCLASS => "<sub_synth>"                 // (1L << 59)
-    case OVERRIDDEN_TRAIT_SETTER => "<overridden_trait_setter>"       // (1L << 60)
+    case 0x1000000000000000L => ""                                    // (1L << 60)
     case 0x2000000000000000L => ""                                    // (1L << 61)
     case 0x4000000000000000L => ""                                    // (1L << 62)
     case 0x8000000000000000L => ""                                    // (1L << 63)