Moving flags around for performance.

Also trimmed some cruft which had accrued in recent work.

1 files changed, 65 insertions, 13 deletions

diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index cfab069588..e8fb33dafb 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -84,18 +84,19 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
              with HasFlags
              with SymbolFlagLogic
              with SymbolCreator
-             // with FlagVerifier
+             // with FlagVerifier   // DEBUG
              with Annotatable[Symbol] {
 
-    type FlagsType          = Long
     type AccessBoundaryType = Symbol
     type AnnotationType     = AnnotationInfo
 
     private[this] var _rawowner = initOwner // Syncnote: need not be protected, as only assignment happens in owner_=, which is not exposed to api
     private[this] var _rawname  = initName
+    private[this] var _rawflags: Long = _
 
     def rawowner = _rawowner
-    def rawname = _rawname
+    def rawname  = _rawname
+    def rawflags = _rawflags
 
     private var rawpos = initPos
 
@@ -340,7 +341,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     // True if the symbol is locked but still below the allowed recursion depth.
     // False otherwise
     private[scala] def lockOK: Boolean = {
-      ((rawflags & LOCKED) == 0L) ||
+      ((_rawflags & LOCKED) == 0L) ||
       ((settings.Yrecursion.value != 0) &&
        (recursionTable get this match {
          case Some(n) => (n <= settings.Yrecursion.value)
@@ -349,7 +350,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     // Lock a symbol, using the handler if the recursion depth becomes too great.
     private[scala] def lock(handler: => Unit): Boolean = {
-      if ((rawflags & LOCKED) != 0L) {
+      if ((_rawflags & LOCKED) != 0L) {
         if (settings.Yrecursion.value != 0) {
           recursionTable get this match {
             case Some(n) =>
@@ -366,7 +367,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           }
         } else { handler; false }
       } else {
-        rawflags |= LOCKED
+        _rawflags |= LOCKED
         true
 //        activeLocks += 1
 //        lockedSyms += this
@@ -375,10 +376,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     // Unlock a symbol
     private[scala] def unlock() = {
-      if ((rawflags & LOCKED) != 0L) {
+      if ((_rawflags & LOCKED) != 0L) {
 //        activeLocks -= 1
 //        lockedSyms -= this
-        rawflags &= ~LOCKED
+        _rawflags &= ~LOCKED
         if (settings.Yrecursion.value != 0)
           recursionTable -= this
       }
@@ -495,6 +496,32 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     @inline final override def hasFlag(mask: Long): Boolean = (flags & mask) != 0
     /** Does symbol have ALL the flags in `mask` set? */
     @inline final override def hasAllFlags(mask: Long): Boolean = (flags & mask) == mask
+    
+    override def setFlag(mask: Long): this.type   = { _rawflags |= mask ; this }
+    override def resetFlag(mask: Long): this.type = { _rawflags &= ~mask ; this }
+    override def resetFlags() { rawflags &= (TopLevelCreationFlags | alwaysHasFlags) }
+    
+    /** Default implementation calls the generic string function, which
+     *  will print overloaded flags as <flag1/flag2/flag3>.  Subclasses
+     *  of Symbol refine.
+     */
+    override def resolveOverloadedFlag(flag: Long): String = Flags.flagToString(flag)
+
+    /** Set the symbol's flags to the given value, asserting
+     *  that the previous value was 0.
+     */
+    override def initFlags(mask: Long): this.type = {
+      assert(rawflags == 0L, symbolCreationString)
+      _rawflags = mask
+      this
+    }
+    
+    final def flags: Long = {
+      val fs = _rawflags & phase.flagMask
+      (fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
+    }
+    def flags_=(fs: Long) = _rawflags = fs
+    def rawflags_=(x: Long) { _rawflags = x }
 
     /** Term symbols with the exception of static parts of Java classes and packages.
      */
@@ -1000,13 +1027,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         val tp = infos.info
         //if (settings.debug.value) System.out.println("completing " + this.rawname + tp.getClass());//debug
 
-        if ((rawflags & LOCKED) != 0L) { // rolled out once for performance
+        if ((_rawflags & LOCKED) != 0L) { // rolled out once for performance
           lock {
             setInfo(ErrorType)
             throw CyclicReference(this, tp)
           }
         } else {
-          rawflags |= LOCKED
+          _rawflags |= LOCKED
 //          activeLocks += 1
  //         lockedSyms += this
         }
@@ -1407,7 +1434,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     /** A clone of this symbol, but with given owner. */
     final def cloneSymbol(newOwner: Symbol): Symbol =
-      cloneSymbol(newOwner, this.rawflags)
+      cloneSymbol(newOwner, _rawflags)
     final def cloneSymbol(newOwner: Symbol, newFlags: Long): Symbol =
       cloneSymbol(newOwner, newFlags, nme.NO_NAME)
     final def cloneSymbol(newOwner: Symbol, newFlags: Long, newName: Name): Symbol = {
@@ -2073,7 +2100,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def debugLocationString = fullLocationString + " " + debugFlagString
 
     private def defStringCompose(infoString: String) = compose(
-      defaultFlagString,
+      flagString,
       keyString,
       varianceString + nameString + infoString + flagsExplanationString
     )
@@ -2122,6 +2149,17 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     override def isPackageObject  = isModule && (name == nme.PACKAGE)
 
+    // The name in comments is what it is being disambiguated from.
+    // TODO - rescue CAPTURED from BYNAMEPARAM so we can see all the names.
+    override def resolveOverloadedFlag(flag: Long) = flag match {
+      case DEFAULTPARAM => "<defaultparam>" // TRAIT
+      case MIXEDIN      => "<mixedin>"      // EXISTENTIAL
+      case LABEL        => "<label>"        // CONTRAVARIANT / INCONSTRUCTOR
+      case PRESUPER     => "<presuper>"     // IMPLCLASS
+      case BYNAMEPARAM  => if (this.isValueParameter) "<bynameparam>" else "<captured>" // COVARIANT
+      case _            => super.resolveOverloadedFlag(flag)
+    }
+
     def referenced: Symbol = _referenced
     def referenced_=(x: Symbol) { _referenced = x }
 
@@ -2313,6 +2351,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     final override def isType   = true
     override def isNonClassType = true
+    
+    override def resolveOverloadedFlag(flag: Long) = flag match {
+      case TRAIT         => "<trait>"         // DEFAULTPARAM
+      case EXISTENTIAL   => "<existential>"   // MIXEDIN
+      case COVARIANT     => "<covariant>"     // BYNAMEPARAM / CAPTURED
+      case CONTRAVARIANT => "<contravariant>" // LABEL / INCONSTRUCTOR (overridden again in ClassSymbol)
+      case _             => super.resolveOverloadedFlag(flag)
+    }
 
     private var tyconCache: Type = null
     private var tyconRunId = NoRunId
@@ -2499,6 +2545,12 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override protected def alwaysHasFlags: Long = 0L
     override protected def neverHasFlags: Long = 0L
 
+    override def resolveOverloadedFlag(flag: Long) = flag match {
+      case INCONSTRUCTOR => "<inconstructor>" // CONTRAVARIANT / LABEL
+      case EXISTENTIAL   => "<existential>"   // MIXEDIN
+      case _             => super.resolveOverloadedFlag(flag)
+    }
+
     final override def isClass = true
     final override def isNonClassType = false
     final override def isAbstractType = false
@@ -2732,7 +2784,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       unlock()
       validTo = currentPeriod
     }
-    override def defaultFlagMask = AllFlags
+    override def flagMask = AllFlags
     override def exists = false
     override def isHigherOrderTypeParameter = false
     override def companionClass = NoSymbol