Merge pull request #4638 from lrytz/t9393

SI-9393 fix modifiers of ClassBTypes for Java annotations

8 files changed, 150 insertions, 114 deletions

diff --git a/src/reflect/scala/reflect/api/FlagSets.scala b/src/reflect/scala/reflect/api/FlagSets.scala
index d3294dad9b..2d5d1d5d6b 100644
--- a/src/reflect/scala/reflect/api/FlagSets.scala
+++ b/src/reflect/scala/reflect/api/FlagSets.scala
@@ -173,6 +173,7 @@ trait FlagSets { self: Universe =>
      *  - the enum's class
      *  - enum constants
      **/
+    @deprecated("Use `isJavaEnum` on the corresponding symbol instead.", since = "2.11.8")
     val ENUM: FlagSet
 
     /** Flag indicating that tree represents a parameter of the primary constructor of some class
diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala
index b7234ba47a..9e9fe5d67b 100644
--- a/src/reflect/scala/reflect/api/Symbols.scala
+++ b/src/reflect/scala/reflect/api/Symbols.scala
@@ -504,6 +504,18 @@ trait Symbols { self: Universe =>
      */
     def isImplicit: Boolean
 
+    /** Does this symbol represent a java enum class or a java enum value?
+      *
+      *  @group Tests
+      */
+    def isJavaEnum: Boolean
+
+    /** Does this symbol represent a java annotation interface?
+      *
+      *  @group Tests
+      */
+    def isJavaAnnotation: Boolean
+
     /******************* helpers *******************/
 
     /** Provides an alternate if symbol is a NoSymbol.
diff --git a/src/reflect/scala/reflect/internal/ClassfileConstants.scala b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
index 53241fb15b..e5d97e8959 100644
--- a/src/reflect/scala/reflect/internal/ClassfileConstants.scala
+++ b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
@@ -344,7 +344,8 @@ object ClassfileConstants {
       case JAVA_ACC_STATIC     => STATIC
       case JAVA_ACC_ABSTRACT   => if (isAnnotation) 0L else if (isClass) ABSTRACT else DEFERRED
       case JAVA_ACC_INTERFACE  => if (isAnnotation) 0L else TRAIT | INTERFACE | ABSTRACT
-      case JAVA_ACC_ENUM       => ENUM
+      case JAVA_ACC_ENUM       => JAVA_ENUM
+      case JAVA_ACC_ANNOTATION => JAVA_ANNOTATION
       case _                   => 0L
     }
     private def translateFlags(jflags: Int, baseFlags: Long, isClass: Boolean): Long = {
@@ -360,6 +361,7 @@ object ClassfileConstants {
       res |= translateFlag0(jflags & JAVA_ACC_ABSTRACT)
       res |= translateFlag0(jflags & JAVA_ACC_INTERFACE)
       res |= translateFlag0(jflags & JAVA_ACC_ENUM)
+      res |= translateFlag0(jflags & JAVA_ACC_ANNOTATION)
       res
     }
 
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 3552eb1713..02fa3c882b 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -815,7 +815,7 @@ trait Definitions extends api.StandardDefinitions {
         // must filter out "universal" members (getClass is deferred for some reason)
         val deferredMembers = (
           tp membersBasedOnFlags (excludedFlags = BridgeAndPrivateFlags, requiredFlags = METHOD)
-          filter (mem => mem.isDeferredNotDefault && !isUniversalMember(mem)) // TODO: test
+          filter (mem => mem.isDeferredNotJavaDefault && !isUniversalMember(mem)) // TODO: test
         )
 
         // if there is only one, it's monomorphic and has a single argument list
diff --git a/src/reflect/scala/reflect/internal/FlagSets.scala b/src/reflect/scala/reflect/internal/FlagSets.scala
index ef9c77878f..b6521634fb 100644
--- a/src/reflect/scala/reflect/internal/FlagSets.scala
+++ b/src/reflect/scala/reflect/internal/FlagSets.scala
@@ -42,7 +42,7 @@ trait FlagSets extends api.FlagSets { self: SymbolTable =>
     val DEFAULTPARAM  : FlagSet = Flags.DEFAULTPARAM
     val PRESUPER      : FlagSet = Flags.PRESUPER
     val DEFAULTINIT   : FlagSet = Flags.DEFAULTINIT
-    val ENUM          : FlagSet = Flags.ENUM
+    val ENUM          : FlagSet = Flags.JAVA_ENUM
     val PARAMACCESSOR : FlagSet = Flags.PARAMACCESSOR
     val CASEACCESSOR  : FlagSet = Flags.CASEACCESSOR
     val SYNTHETIC     : FlagSet = Flags.SYNTHETIC
diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala
index 1707061817..754b96a9dd 100644
--- a/src/reflect/scala/reflect/internal/Flags.scala
+++ b/src/reflect/scala/reflect/internal/Flags.scala
@@ -15,65 +15,65 @@ import scala.collection.{ mutable, immutable }
 //
 // Generated by mkFlagsTable() at Thu Feb 02 20:31:52 PST 2012
 //
-//  0:     PROTECTED/M
-//  1:      OVERRIDE/M
-//  2:       PRIVATE/M
-//  3:      ABSTRACT/M
-//  4:      DEFERRED/M
-//  5:         FINAL/M
-//  6:          METHOD
-//  7:     INTERFACE/M
-//  8:          MODULE
-//  9:      IMPLICIT/M
-// 10:        SEALED/M
-// 11:          CASE/M
-// 12:       MUTABLE/M
-// 13:         PARAM/M
-// 14:         PACKAGE
-// 15:         MACRO/M
-// 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
-// 17: CONTRAVARIANT/M INCONSTRUCTOR       LABEL
-// 18:   ABSOVERRIDE/M
-// 19:         LOCAL/M
-// 20:          JAVA/M
-// 21:       SYNTHETIC
-// 22:          STABLE
-// 23:        STATIC/M
-// 24:  CASEACCESSOR/M
-// 25:  DEFAULTPARAM/M       TRAIT/M
-// 26:          BRIDGE
-// 27:        ACCESSOR
-// 28:   SUPERACCESSOR
-// 29: PARAMACCESSOR/M
-// 30:       MODULEVAR
-// 31:          LAZY/M
-// 32:        IS_ERROR
-// 33:      OVERLOADED
-// 34:          LIFTED
-// 35:     EXISTENTIAL       MIXEDIN
-// 36:    EXPANDEDNAME
-// 37:       IMPLCLASS    PRESUPER/M
-// 38:      TRANS_FLAG
-// 39:          LOCKED
-// 40:     SPECIALIZED
-// 41:   DEFAULTINIT/M
-// 42:         VBRIDGE
-// 43:         VARARGS
-// 44:    TRIEDCOOKING
-// 45:  SYNCHRONIZED/M
-// 46:        ARTIFACT
-// 47: DEFAULTMETHOD/M
-// 48:            ENUM
-// 49:
+//  0:          PROTECTED/M
+//  1:           OVERRIDE/M
+//  2:            PRIVATE/M
+//  3:           ABSTRACT/M
+//  4:           DEFERRED/M
+//  5:              FINAL/M
+//  6:               METHOD
+//  7:          INTERFACE/M
+//  8:               MODULE
+//  9:           IMPLICIT/M
+// 10:             SEALED/M
+// 11:               CASE/M
+// 12:            MUTABLE/M
+// 13:              PARAM/M
+// 14:              PACKAGE
+// 15:              MACRO/M
+// 16:        BYNAMEPARAM/M      CAPTURED COVARIANT/M
+// 17:      CONTRAVARIANT/M INCONSTRUCTOR       LABEL
+// 18:        ABSOVERRIDE/M
+// 19:              LOCAL/M
+// 20:               JAVA/M
+// 21:            SYNTHETIC
+// 22:               STABLE
+// 23:             STATIC/M
+// 24:       CASEACCESSOR/M
+// 25:       DEFAULTPARAM/M       TRAIT/M
+// 26:               BRIDGE
+// 27:             ACCESSOR
+// 28:        SUPERACCESSOR
+// 29:      PARAMACCESSOR/M
+// 30:            MODULEVAR
+// 31:               LAZY/M
+// 32:             IS_ERROR
+// 33:           OVERLOADED
+// 34:               LIFTED
+// 35:          EXISTENTIAL       MIXEDIN
+// 36:         EXPANDEDNAME
+// 37:            IMPLCLASS    PRESUPER/M
+// 38:           TRANS_FLAG
+// 39:               LOCKED
+// 40:          SPECIALIZED
+// 41:        DEFAULTINIT/M
+// 42:              VBRIDGE
+// 43:              VARARGS
+// 44:         TRIEDCOOKING
+// 45:       SYNCHRONIZED/M
+// 46:             ARTIFACT
+// 47: JAVA_DEFAULTMETHOD/M
+// 48:            JAVA_ENUM
+// 49:      JAVA_ANNOTATION
 // 50:
-// 51:    lateDEFERRED
-// 52:       lateFINAL
-// 53:      lateMETHOD
-// 54:   lateINTERFACE
-// 55:      lateMODULE
-// 56:    notPROTECTED
-// 57:     notOVERRIDE
-// 58:      notPRIVATE
+// 51:         lateDEFERRED
+// 52:            lateFINAL
+// 53:           lateMETHOD
+// 54:        lateINTERFACE
+// 55:           lateMODULE
+// 56:         notPROTECTED
+// 57:          notOVERRIDE
+// 58:           notPRIVATE
 // 59:
 // 60:
 // 61:
@@ -119,8 +119,9 @@ class ModifierFlags {
   final val DEFAULTINIT   = 1L << 41      // symbol is initialized to the default value: used by -Xcheckinit
   final val ARTIFACT      = 1L << 46      // symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode
                                           // to see which symbols are marked as ARTIFACT, see scaladocs for FlagValues.ARTIFACT
-  final val DEFAULTMETHOD = 1L << 47      // symbol is a java default method
-  final val ENUM          = 1L << 48      // symbol is an enum
+  final val JAVA_DEFAULTMETHOD = 1L << 47     // symbol is a java default method
+  final val JAVA_ENUM          = 1L << 48     // symbol is a java enum
+  final val JAVA_ANNOTATION    = 1L << 49     // symbol is a java annotation
 
   // Overridden.
   def flagToString(flag: Long): String = ""
@@ -172,12 +173,28 @@ class Flags extends ModifierFlags {
   final val SYNCHRONIZED  = 1L << 45      // symbol is a method which should be marked ACC_SYNCHRONIZED
 
   // ------- shift definitions -------------------------------------------------------
+  //
+  // Flags from 1L to (1L << 50) are normal flags.
+  //
+  // The flags DEFERRED (1L << 4) to MODULE (1L << 8) have a `late` counterpart. Late flags change
+  // their counterpart from 0 to 1 after a specific phase (see below). The first late flag
+  // (lateDEFERRED) is at (1L << 51), i.e., late flags are shifted by 47. The last one is (1L << 55).
+  //
+  // The flags PROTECTED (1L) to PRIVATE (1L << 2) have a `not` counterpart. Negated flags change
+  // their counterpart from 1 to 0 after a specific phase (see below). They are shifted by 56, i.e.,
+  // the first negated flag (notPROTECTED) is at (1L << 56), the last at (1L << 58).
+  //
+  // Late and negative flags are only enabled after certain phases, implemented by the phaseNewFlags
+  // method of the SubComponent, so they implement a bit of a flag history.
+  //
+  // The flags (1L << 59) to (1L << 63) are currently unused. If added to the InitialFlags mask,
+  // they could be used as normal flags.
 
-  final val InitialFlags  = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1.
-  final val LateFlags     = 0x00FE000000000000L // flags that override flags in 0x1FC.
-  final val AntiFlags     = 0x7F00000000000000L // flags that cancel flags in 0x07F
-  final val LateShift     = 47L
-  final val AntiShift     = 56L
+  final val InitialFlags  = 0x0007FFFFFFFFFFFFL // normal flags, enabled from the first phase: 1L to (1L << 50)
+  final val LateFlags     = 0x00F8000000000000L // flags that override flags in (1L << 4) to (1L << 8): DEFERRED, FINAL, INTERFACE, METHOD, MODULE
+  final val AntiFlags     = 0x0700000000000000L // flags that cancel flags in 1L to (1L << 2): PROTECTED, OVERRIDE, PRIVATE
+  final val LateShift     = 47
+  final val AntiShift     = 56
 
   // Flags which sketchily share the same slot
   // 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
@@ -243,7 +260,7 @@ class Flags extends ModifierFlags {
    */
   final val ExplicitFlags =
     PRIVATE | PROTECTED | ABSTRACT | FINAL | SEALED |
-    OVERRIDE | CASE | IMPLICIT | ABSOVERRIDE | LAZY | DEFAULTMETHOD
+    OVERRIDE | CASE | IMPLICIT | ABSOVERRIDE | LAZY | JAVA_DEFAULTMETHOD
 
   /** The two bridge flags */
   final val BridgeFlags = BRIDGE | VBRIDGE
@@ -434,9 +451,9 @@ class Flags extends ModifierFlags {
     case        TRIEDCOOKING => "<triedcooking>"                      // (1L << 44)
     case        SYNCHRONIZED => "<synchronized>"                      // (1L << 45)
     case            ARTIFACT => "<artifact>"                          // (1L << 46)
-    case       DEFAULTMETHOD => "<defaultmethod>"                     // (1L << 47)
-    case                ENUM => "<enum>"                              // (1L << 48)
-    case    0x2000000000000L => ""                                    // (1L << 49)
+    case  JAVA_DEFAULTMETHOD => "<defaultmethod>"                     // (1L << 47)
+    case           JAVA_ENUM => "<enum>"                              // (1L << 48)
+    case     JAVA_ANNOTATION => "<annotation>"                        // (1L << 49)
     case    0x4000000000000L => ""                                    // (1L << 50)
     case      `lateDEFERRED` => "<latedeferred>"                      // (1L << 51)
     case         `lateFINAL` => "<latefinal>"                         // (1L << 52)
diff --git a/src/reflect/scala/reflect/internal/HasFlags.scala b/src/reflect/scala/reflect/internal/HasFlags.scala
index aa8f4c532e..5162b15206 100644
--- a/src/reflect/scala/reflect/internal/HasFlags.scala
+++ b/src/reflect/scala/reflect/internal/HasFlags.scala
@@ -79,49 +79,50 @@ trait HasFlags {
 
   // Tests which come through cleanly: both Symbol and Modifiers use these
   // identically, testing for a single flag.
-  def hasAbstractFlag    = hasFlag(ABSTRACT)
-  def hasAccessorFlag    = hasFlag(ACCESSOR)
-  def hasDefault         = hasFlag(DEFAULTPARAM) && hasFlag(METHOD | PARAM) // Second condition disambiguates with TRAIT
-  def hasEnumFlag        = hasFlag(ENUM)
+  def hasAbstractFlag       = hasFlag(ABSTRACT)
+  def hasAccessorFlag       = hasFlag(ACCESSOR)
+  def hasDefault            = hasFlag(DEFAULTPARAM) && hasFlag(METHOD | PARAM) // Second condition disambiguates with TRAIT
+  def hasJavaEnumFlag       = hasFlag(JAVA_ENUM)
+  def hasJavaAnnotationFlag = hasFlag(JAVA_ANNOTATION)
   @deprecated("Use isLocalToThis instead", "2.11.0")
-  def hasLocalFlag       = hasFlag(LOCAL)
-  def isLocalToThis      = hasFlag(LOCAL)
-  def hasModuleFlag      = hasFlag(MODULE)
-  def hasPackageFlag     = hasFlag(PACKAGE)
-  def hasStableFlag      = hasFlag(STABLE)
-  def hasStaticFlag      = hasFlag(STATIC)
-  def isAbstractOverride = hasFlag(ABSOVERRIDE)
-  def isAnyOverride      = hasFlag(OVERRIDE | ABSOVERRIDE)
-  def isCase             = hasFlag(CASE)
-  def isCaseAccessor     = hasFlag(CASEACCESSOR)
-  def isDeferred         = hasFlag(DEFERRED)
-  def isFinal            = hasFlag(FINAL)
-  def isArtifact         = hasFlag(ARTIFACT)
-  def isImplicit         = hasFlag(IMPLICIT)
-  def isInterface        = hasFlag(INTERFACE)
-  def isJavaDefined      = hasFlag(JAVA)
-  def isLabel            = hasAllFlags(LABEL | METHOD) && !hasAccessorFlag
-  def isLazy             = hasFlag(LAZY)
-  def isLifted           = hasFlag(LIFTED)
-  def isMacro            = hasFlag(MACRO)
-  def isMutable          = hasFlag(MUTABLE)
-  def isOverride         = hasFlag(OVERRIDE)
-  def isParamAccessor    = hasFlag(PARAMACCESSOR)
-  def isPrivate          = hasFlag(PRIVATE)
+  def hasLocalFlag          = hasFlag(LOCAL)
+  def isLocalToThis         = hasFlag(LOCAL)
+  def hasModuleFlag         = hasFlag(MODULE)
+  def hasPackageFlag        = hasFlag(PACKAGE)
+  def hasStableFlag         = hasFlag(STABLE)
+  def hasStaticFlag         = hasFlag(STATIC)
+  def isAbstractOverride    = hasFlag(ABSOVERRIDE)
+  def isAnyOverride         = hasFlag(OVERRIDE | ABSOVERRIDE)
+  def isCase                = hasFlag(CASE)
+  def isCaseAccessor        = hasFlag(CASEACCESSOR)
+  def isDeferred            = hasFlag(DEFERRED)
+  def isFinal               = hasFlag(FINAL)
+  def isArtifact            = hasFlag(ARTIFACT)
+  def isImplicit            = hasFlag(IMPLICIT)
+  def isInterface           = hasFlag(INTERFACE)
+  def isJavaDefined         = hasFlag(JAVA)
+  def isLabel               = hasAllFlags(LABEL | METHOD) && !hasAccessorFlag
+  def isLazy                = hasFlag(LAZY)
+  def isLifted              = hasFlag(LIFTED)
+  def isMacro               = hasFlag(MACRO)
+  def isMutable             = hasFlag(MUTABLE)
+  def isOverride            = hasFlag(OVERRIDE)
+  def isParamAccessor       = hasFlag(PARAMACCESSOR)
+  def isPrivate             = hasFlag(PRIVATE)
   @deprecated ("Use `hasPackageFlag` instead", "2.11.0")
-  def isPackage          = hasFlag(PACKAGE)
-  def isPrivateLocal     = hasAllFlags(PrivateLocal)
-  def isProtected        = hasFlag(PROTECTED)
-  def isProtectedLocal   = hasAllFlags(ProtectedLocal)
-  def isPublic           = hasNoFlags(PRIVATE | PROTECTED) && !hasAccessBoundary
-  def isSealed           = hasFlag(SEALED)
-  def isSpecialized      = hasFlag(SPECIALIZED)
-  def isSuperAccessor    = hasFlag(SUPERACCESSOR)
-  def isSynthetic        = hasFlag(SYNTHETIC)
-  def isTrait            = hasFlag(TRAIT) && !hasFlag(PARAM)
-
-  def isDeferredOrDefault  = hasFlag(DEFERRED | DEFAULTMETHOD)
-  def isDeferredNotDefault = isDeferred && !hasFlag(DEFAULTMETHOD)
+  def isPackage             = hasFlag(PACKAGE)
+  def isPrivateLocal        = hasAllFlags(PrivateLocal)
+  def isProtected           = hasFlag(PROTECTED)
+  def isProtectedLocal      = hasAllFlags(ProtectedLocal)
+  def isPublic              = hasNoFlags(PRIVATE | PROTECTED) && !hasAccessBoundary
+  def isSealed              = hasFlag(SEALED)
+  def isSpecialized         = hasFlag(SPECIALIZED)
+  def isSuperAccessor       = hasFlag(SUPERACCESSOR)
+  def isSynthetic           = hasFlag(SYNTHETIC)
+  def isTrait               = hasFlag(TRAIT) && !hasFlag(PARAM)
+
+  def isDeferredOrJavaDefault  = hasFlag(DEFERRED | JAVA_DEFAULTMETHOD)
+  def isDeferredNotJavaDefault = isDeferred && !hasFlag(JAVA_DEFAULTMETHOD)
 
   def flagBitsToString(bits: Long): String = {
     // Fast path for common case
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 7740dbdd75..8a52f0b9d8 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -102,6 +102,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def isPrivateThis = (this hasFlag PRIVATE) && (this hasFlag LOCAL)
     def isProtectedThis = (this hasFlag PROTECTED) && (this hasFlag LOCAL)
 
+    def isJavaEnum: Boolean = hasJavaEnumFlag
+    def isJavaAnnotation: Boolean = hasJavaAnnotationFlag
+
     def newNestedSymbol(name: Name, pos: Position, newFlags: Long, isClass: Boolean): Symbol = name match {
       case n: TermName => newTermSymbol(n, pos, newFlags)
       case n: TypeName => if (isClass) newClassSymbol(n, pos, newFlags) else newNonClassSymbol(n, pos, newFlags)
@@ -732,7 +735,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def flags: Long = {
       if (Statistics.hotEnabled) Statistics.incCounter(flagsCount)
       val fs = _rawflags & phase.flagMask
-      (fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
+      (fs | ((fs & LateFlags) >>> LateShift)) & ~((fs & AntiFlags) >>> AntiShift)
     }
     def flags_=(fs: Long) = _rawflags = fs
     def rawflags_=(x: Long) { _rawflags = x }