A boatload of work on Symbols and Flags.

Finally my dream of orderliness is within sight.

It's all pretty self-explanatory.  More polymorphism, more immutable
identity, more invariants.

1 files changed, 56 insertions, 24 deletions

diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala
index ce1c8d0908..38f9ec6669 100644
--- a/src/compiler/scala/reflect/internal/Flags.scala
+++ b/src/compiler/scala/reflect/internal/Flags.scala
@@ -174,6 +174,9 @@ class Flags extends ModifierFlags {
   final val LateShift     = 47L
   final val AntiShift     = 56L
 
+  // Flags which sketchily share the same slot
+  val OverloadedFlagsMask = 0L | BYNAMEPARAM | CONTRAVARIANT | DEFAULTPARAM | EXISTENTIAL | IMPLCLASS
+
   // ------- late flags (set by a transformer phase) ---------------------------------
   //
   // Summary of when these are claimed to be first used.
@@ -206,12 +209,24 @@ class Flags extends ModifierFlags {
 
   // ------- masks -----------------------------------------------------------------------
 
+  /** 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().
    */
   final val TopLevelCreationFlags: Long =
     MODULE | PACKAGE | FINAL | JAVA
 
+  // TODO - there's no call to slap four flags onto every package.
+  final val PackageFlags: Long = TopLevelCreationFlags
+
+  // FINAL not included here due to possibility of object overriding.
+  // In fact, FINAL should not be attached regardless.  We should be able
+  // to reconstruct whether an object was marked final in source.
+  final val ModuleFlags: Long = MODULE
+
   /** These modifiers can be set explicitly in source programs.  This is
    *  used only as the basis for the default flag mask (which ones to display
    *  when printing a normal message.)
@@ -220,15 +235,15 @@ class Flags extends ModifierFlags {
     PRIVATE | PROTECTED | ABSTRACT | FINAL | SEALED |
     OVERRIDE | CASE | IMPLICIT | ABSOVERRIDE | LAZY
 
-  /** These modifiers appear in TreePrinter output. */
-  final val PrintableFlags: Long =
-    ExplicitFlags | LOCAL | SYNTHETIC | STABLE | CASEACCESSOR | MACRO |
-    ACCESSOR | SUPERACCESSOR | PARAMACCESSOR | BRIDGE | STATIC | VBRIDGE | SPECIALIZED | SYNCHRONIZED
-
   /** The two bridge flags */
   final val BridgeFlags = BRIDGE | VBRIDGE
   final val BridgeAndPrivateFlags = BridgeFlags | PRIVATE
 
+  /** These modifiers appear in TreePrinter output. */
+  final val PrintableFlags: Long =
+    ExplicitFlags | BridgeFlags | LOCAL | SYNTHETIC | STABLE | CASEACCESSOR | MACRO |
+    ACCESSOR | SUPERACCESSOR | PARAMACCESSOR | STATIC | SPECIALIZED | SYNCHRONIZED
+
   /** When a symbol for a field is created, only these flags survive
    *  from Modifiers.  Others which may be applied at creation time are:
    *  PRIVATE, LOCAL.
@@ -264,7 +279,7 @@ class Flags extends ModifierFlags {
   final val ConstrFlags: Long         = JAVA
 
   /** Module flags inherited by their module-class */
-  final val ModuleToClassFlags: Long = AccessFlags | MODULE | PACKAGE | CASE | SYNTHETIC | JAVA | FINAL
+  final val ModuleToClassFlags: Long = AccessFlags | TopLevelCreationFlags | CASE | SYNTHETIC
 
   def getterFlags(fieldFlags: Long): Long = ACCESSOR + (
     if ((fieldFlags & MUTABLE) != 0) fieldFlags & ~MUTABLE & ~PRESUPER
@@ -407,26 +422,43 @@ class Flags extends ModifierFlags {
     case _ => ""
   }
 
-  def flagsToString(flags: Long, privateWithin: String): String = {
-    var f = flags
-    val pw =
-      if (privateWithin == "") {
-        if ((flags & PrivateLocal) == PrivateLocal) {
-          f &= ~PrivateLocal
-          "private[this]"
-        } else if ((flags & ProtectedLocal) == ProtectedLocal) {
-          f &= ~ProtectedLocal
-          "protected[this]"
-        } else {
-          ""
+  def accessString(flags: Long, privateWithin: String)= (
+    if (privateWithin == "") {
+      if ((flags & PrivateLocal) == PrivateLocal) "private[this]"
+      else if ((flags & ProtectedLocal) == ProtectedLocal) "protected[this]"
+      else if ((flags & PRIVATE) != 0) "private"
+      else if ((flags & PROTECTED) != 0) "protected"
+      else ""
+    }
+    else if ((flags & PROTECTED) != 0) "protected[" + privateWithin + "]"
+    else "private[" + privateWithin + "]"
+  )
+  def nonAccessString(flags0: Long)(flagStringFn: Long => String): String = {
+    val flags = flags0 & ~AccessFlags
+    // Fast path for common case
+    if (flags == 0L) "" else {
+      var sb: StringBuilder = null
+      var i = 0
+      while (i <= MaxBitPosition) {
+        val mask = rawFlagPickledOrder(i)
+        if ((flags & mask) != 0L) {
+          val s = flagStringFn(mask)
+          if (s.length > 0) {
+            if (sb eq null) sb = new StringBuilder append s
+            else if (sb.length == 0) sb append s
+            else sb append " " append s
+          }
         }
-      } else if ((f & PROTECTED) != 0L) {
-        f &= ~PROTECTED
-        "protected[" + privateWithin + "]"
-      } else {
-        "private[" + privateWithin + "]"
+        i += 1
       }
-    List(flagsToString(f), pw) filterNot (_ == "") mkString " "
+      if (sb eq null) "" else sb.toString
+    }
+  }
+
+  def flagsToString(flags: Long, privateWithin: String): String = {
+    val access = accessString(flags, privateWithin)
+    val nonAccess = flagsToString(flags & ~AccessFlags)
+    List(nonAccess, access) filterNot (_ == "") mkString " "
   }
 
   // List of the raw flags, in pickled order