Pickled flag reorg

Cleaned up and optimized code that maps between raw and pickled flags. Avoids mystery constants. Makes a whole bunch of new flags be pickled which were not pickled before (more precisely: Everything in InitialFlags with value greater than 1 << 31 which is not in FlagsNotPickled now gets pickled whereas before it wasn't. Among these: VARARGS, IMPLCLASS, SPECIALZED, DEFAULTINIT, SYNCHRONIZED. I am curious how many tickets will get fixed by this change.

The first one I noted is t5504, which previously enforced the buggy behavior through a neg check!

There are also some build manager check file changes that have to do with the fact that flags now print in a different order for performance reasons.

1 files changed, 40 insertions, 41 deletions

diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala
index 37e5a23819..c17600ec41 100644
--- a/src/reflect/scala/reflect/internal/Flags.scala
+++ b/src/reflect/scala/reflect/internal/Flags.scala
@@ -165,6 +165,7 @@ class Flags extends ModifierFlags {
                                           // A Java method's type is ``cooked'' by transforming raw types to existentials
 
   final val SYNCHRONIZED  = 1L << 45      // symbol is a method which should be marked ACC_SYNCHRONIZED
+
   // ------- shift definitions -------------------------------------------------------
 
   final val InitialFlags  = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1.
@@ -211,7 +212,7 @@ class Flags extends ModifierFlags {
   /** To be a little clearer to people who aren't habitual bit twiddlers.
    */
   final val AllFlags = -1L
-
+  
   /** These flags can be set when class or module symbol is first created.
    *  They are the only flags to survive a call to resetFlags().
    */
@@ -279,6 +280,12 @@ class Flags extends ModifierFlags {
   /** Module flags inherited by their module-class */
   final val ModuleToClassFlags = AccessFlags | TopLevelCreationFlags | CASE | SYNTHETIC
 
+  /** These flags are not pickled */
+  final val FlagsNotPickled = IS_ERROR | OVERLOADED | LIFTED | TRANS_FLAG | LOCKED | TRIEDCOOKING
+  
+  /** These flags are pickled */
+  final val PickledFlags  = InitialFlags & ~FlagsNotPickled
+
   def getterFlags(fieldFlags: Long): Long = ACCESSOR + (
     if ((fieldFlags & MUTABLE) != 0) fieldFlags & ~MUTABLE & ~PRESUPER
     else fieldFlags & ~PRESUPER | STABLE
@@ -307,47 +314,45 @@ class Flags extends ModifierFlags {
 
   private final val PKL_MASK       = 0x00000FFF
 
-  final val PickledFlags  = 0xFFFFFFFFL
-
-  private def rawPickledCorrespondence = Array(
-    (IMPLICIT, IMPLICIT_PKL),
-    (FINAL, FINAL_PKL),
+  /** Pickler correspondence, ordered roughly by frequency of occurrence */
+  private def rawPickledCorrespondence = Array[(Long, Long)](
+    (METHOD, METHOD_PKL),
     (PRIVATE, PRIVATE_PKL),
+    (FINAL, FINAL_PKL),
     (PROTECTED, PROTECTED_PKL),
-    (SEALED, SEALED_PKL),
-    (OVERRIDE, OVERRIDE_PKL),
     (CASE, CASE_PKL),
-    (ABSTRACT, ABSTRACT_PKL),
     (DEFERRED, DEFERRED_PKL),
-    (METHOD, METHOD_PKL),
     (MODULE, MODULE_PKL),
-    (INTERFACE, INTERFACE_PKL)
+    (OVERRIDE, OVERRIDE_PKL),
+    (INTERFACE, INTERFACE_PKL),
+    (IMPLICIT, IMPLICIT_PKL),
+    (SEALED, SEALED_PKL),
+    (ABSTRACT, ABSTRACT_PKL)
   )
-  private val rawFlags: Array[Int]     = rawPickledCorrespondence map (_._1)
-  private val pickledFlags: Array[Int] = rawPickledCorrespondence map (_._2)
-
-  private def r2p(flags: Int): Int = {
-    var result = 0
-    var i      = 0
-    while (i < rawFlags.length) {
-      if ((flags & rawFlags(i)) != 0)
-        result |= pickledFlags(i)
-
-      i += 1
-    }
-    result
-  }
-  private def p2r(flags: Int): Int = {
-    var result = 0
-    var i      = 0
-    while (i < rawFlags.length) {
-      if ((flags & pickledFlags(i)) != 0)
-        result |= rawFlags(i)
-
-      i += 1
+  
+  private val mappedRawFlags = rawPickledCorrespondence map (_._1)
+  private val mappedPickledFlags = rawPickledCorrespondence map (_._2)
+  
+  private class MapFlags(from: Array[Long], to: Array[Long]) extends (Long => Long) {
+    val fromSet = (0L /: from) (_ | _)
+    
+    def apply(flags: Long): Long = {
+      var result = flags & ~fromSet
+      var tobeMapped = flags & fromSet
+      var i = 0
+      while (tobeMapped != 0) {
+        if ((tobeMapped & from(i)) != 0) {
+          result |= to(i)
+          tobeMapped &= ~from(i)
+        }
+        i += 1
+      }
+      result
     }
-    result
   }
+  
+  val rawToPickledFlags: Long => Long = new MapFlags(mappedRawFlags, mappedPickledFlags)
+  val pickledToRawFlags: Long => Long = new MapFlags(mappedPickledFlags, mappedRawFlags)
 
   // ------ displaying flags --------------------------------------------------------
 
@@ -462,18 +467,12 @@ class Flags extends ModifierFlags {
     }
   }
 
-  def rawFlagsToPickled(flags: Long): Long =
-    (flags & ~PKL_MASK) | r2p(flags.toInt & PKL_MASK)
-
-  def pickledToRawFlags(pflags: Long): Long =
-    (pflags & ~PKL_MASK) | p2r(pflags.toInt & PKL_MASK)
-
   // List of the raw flags, in pickled order
   final val MaxBitPosition = 62
 
   final val pickledListOrder: List[Long] = {
     val all   = 0 to MaxBitPosition map (1L << _)
-    val front = rawFlags map (_.toLong)
+    val front = mappedRawFlags map (_.toLong)
 
     front.toList ++ (all filterNot (front contains _))
   }