Merge pull request #887 from paulp/topic/pickledflags

major fixes to how flags are pickled

3 files changed, 52 insertions, 49 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index 192cc94b90..cc5ed0f129 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -503,7 +503,7 @@ abstract class Pickler extends SubComponent {
     private def writeSymInfo(sym: Symbol) {
       writeRef(sym.name)
       writeRef(localizedOwner(sym))
-      writeLongNat((rawFlagsToPickled(sym.flags & PickledFlags)))
+      writeLongNat((rawToPickledFlags(sym.flags & PickledFlags)))
       if (sym.hasAccessBoundary) writeRef(sym.privateWithin)
       writeRef(sym.info)
     }
@@ -966,7 +966,7 @@ abstract class Pickler extends SubComponent {
           TREE
 
         case Modifiers(flags, privateWithin, _) =>
-          val pflags = rawFlagsToPickled(flags)
+          val pflags = rawToPickledFlags(flags)
           writeNat((pflags >> 32).toInt)
           writeNat((pflags & 0xFFFFFFFF).toInt)
           writeRef(privateWithin)
diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala
index 352196fc69..55fa00dd4d 100644
--- a/src/reflect/scala/reflect/internal/Flags.scala
+++ b/src/reflect/scala/reflect/internal/Flags.scala
@@ -166,6 +166,7 @@ class Flags extends ModifierFlags {
 
   final val SYNCHRONIZED  = 1L << 45      // symbol is a method which should be marked ACC_SYNCHRONIZED
   final val HIDDEN        = 1L << 46      // symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode
+
   // ------- shift definitions -------------------------------------------------------
 
   final val InitialFlags  = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1.
@@ -175,6 +176,11 @@ class Flags extends ModifierFlags {
   final val AntiShift     = 56L
 
   // Flags which sketchily share the same slot
+  // 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
+  // 17: CONTRAVARIANT/M INCONSTRUCTOR       LABEL
+  // 25:  DEFAULTPARAM/M       TRAIT/M
+  // 35:     EXISTENTIAL       MIXEDIN
+  // 37:       IMPLCLASS    PRESUPER/M
   val OverloadedFlagsMask = 0L | BYNAMEPARAM | CONTRAVARIANT | DEFAULTPARAM | EXISTENTIAL | IMPLCLASS
 
   // ------- late flags (set by a transformer phase) ---------------------------------
@@ -212,7 +218,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().
    */
@@ -280,6 +286,16 @@ 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
+  
+  // A precaution against future additions to FlagsNotPickled turning out
+  // to be overloaded flags thus not-pickling more than intended.
+  assert((OverloadedFlagsMask & FlagsNotPickled) == 0, flagsToString(OverloadedFlagsMask & FlagsNotPickled))
+  
+  /** 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
@@ -308,47 +324,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 --------------------------------------------------------
 
@@ -463,18 +477,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 _))
   }
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 4d8e932862..4411b79b97 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -373,12 +373,7 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ {
             NullaryMethodType(restpe)
         case EXISTENTIALtpe =>
           val restpe  = readTypeRef()
-          // @PP: Where is the flag setting supposed to happen? I infer
-          // from the lack of flag setting in the rest of the unpickler
-          // that it isn't right here. See #4757 for the immediate
-          // motivation to fix it.
-          val tparams = until(end, readSymbolRef) map (_ setFlag EXISTENTIAL)
-          newExistentialType(tparams, restpe)
+          newExistentialType(until(end, readSymbolRef), restpe)
 
         case ANNOTATEDtpe =>
           var typeRef = readNat()