Merge pull request #4638 from lrytz/t9393

SI-9393 fix modifiers of ClassBTypes for Java annotations

17 files changed, 209 insertions, 151 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index daa31c5dfe..93f5159f89 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -256,14 +256,17 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
       if (hasAbstractMethod) ACC_ABSTRACT else 0
     }
     GenBCode.mkFlags(
-      if (classSym.isPublic)                                 ACC_PUBLIC    else 0,
-      if (classSym.isFinal)                                  ACC_FINAL     else 0,
+      // SI-9393: the classfile / java source parser make java annotation symbols look like classes.
+      // here we recover the actual classfile flags.
+      if (classSym.hasJavaAnnotationFlag)                        ACC_ANNOTATION | ACC_INTERFACE | ACC_ABSTRACT else 0,
+      if (classSym.isPublic)                                     ACC_PUBLIC    else 0,
+      if (classSym.isFinal)                                      ACC_FINAL     else 0,
       // see the link above. javac does the same: ACC_SUPER for all classes, but not interfaces.
-      if (classSym.isInterface)                              ACC_INTERFACE else ACC_SUPER,
+      if (classSym.isInterface)                                  ACC_INTERFACE else ACC_SUPER,
       // for Java enums, we cannot trust `hasAbstractFlag` (see comment in enumFlags)
-      if (!classSym.hasEnumFlag && classSym.hasAbstractFlag) ACC_ABSTRACT  else 0,
-      if (classSym.isArtifact)                               ACC_SYNTHETIC else 0,
-      if (classSym.hasEnumFlag)                              enumFlags     else 0
+      if (!classSym.hasJavaEnumFlag && classSym.hasAbstractFlag) ACC_ABSTRACT  else 0,
+      if (classSym.isArtifact)                                   ACC_SYNTHETIC else 0,
+      if (classSym.hasJavaEnumFlag)                              enumFlags     else 0
     )
   }
 
@@ -310,10 +313,10 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
   }
 
   private def retentionPolicyOf(annot: AnnotationInfo): Symbol =
-    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).map(assoc =>
+    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).flatMap(assoc =>
       assoc.collectFirst {
         case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
-      }).flatten.getOrElse(AnnotationRetentionPolicyClassValue)
+      }).getOrElse(AnnotationRetentionPolicyClassValue)
 
   def implementedInterfaces(classSym: Symbol): List[Symbol] = {
     // Additional interface parents based on annotations and other cues
@@ -322,9 +325,18 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
       case _          => None
     }
 
-    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait
+    // SI-9393: java annotations are interfaces, but the classfile / java source parsers make them look like classes.
+    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait || sym.hasJavaAnnotationFlag
 
-    val allParents = classSym.info.parents ++ classSym.annotations.flatMap(newParentForAnnotation)
+    val classParents = {
+      val parents = classSym.info.parents
+      // SI-9393: the classfile / java source parsers add Annotation and ClassfileAnnotation to the
+      // parents of a java annotations. undo this for the backend (where we need classfile-level information).
+      if (classSym.hasJavaAnnotationFlag) parents.filterNot(c => c.typeSymbol == ClassfileAnnotationClass || c.typeSymbol == AnnotationClass)
+      else parents
+    }
+
+    val allParents = classParents ++ classSym.annotations.flatMap(newParentForAnnotation)
 
     // We keep the superClass when computing minimizeParents to eliminate more interfaces.
     // Example: T can be eliminated from D
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
index c7c2e43f82..a9b6a312e9 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
@@ -153,9 +153,9 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
      */
     private def initJClass(jclass: asm.ClassVisitor) {
 
-      val ps = claszSymbol.info.parents
-      val superClass: String = if (ps.isEmpty) ObjectReference.internalName else internalName(ps.head.typeSymbol)
-      val interfaceNames = classBTypeFromSymbol(claszSymbol).info.get.interfaces map {
+      val bType = classBTypeFromSymbol(claszSymbol)
+      val superClass = bType.info.get.superClass.getOrElse(ObjectReference).internalName
+      val interfaceNames = bType.info.get.interfaces map {
         case classBType =>
           if (classBType.isNestedClass.get) { innerClassBufferASM += classBType }
           classBType.internalName
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 9bae63f1fc..8720da84e8 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -841,17 +841,16 @@ abstract class BTypes {
 
       assert(!ClassBType.isInternalPhantomType(internalName), s"Cannot create ClassBType for phantom type $this")
 
-      // TODO bring these back in a way that doesn't trip pos/t9393
-      // assert(
-      //   if (info.get.superClass.isEmpty) { isJLO(this) || (isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) }
-      //   else if (isInterface.get) isJLO(info.get.superClass.get)
-      //   else !isJLO(this) && ifInit(info.get.superClass.get)(!_.isInterface.get),
-      //   s"Invalid superClass in $this: ${info.get.superClass}"
-      // )
-      // assert(
-      //   info.get.interfaces.forall(c => ifInit(c)(_.isInterface.get)),
-      //   s"Invalid interfaces in $this: ${info.get.interfaces}"
-      // )
+      assert(
+        if (info.get.superClass.isEmpty) { isJLO(this) || (isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) }
+        else if (isInterface.get) isJLO(info.get.superClass.get)
+        else !isJLO(this) && ifInit(info.get.superClass.get)(!_.isInterface.get),
+        s"Invalid superClass in $this: ${info.get.superClass}"
+      )
+      assert(
+        info.get.interfaces.forall(c => ifInit(c)(_.isInterface.get)),
+        s"Invalid interfaces in $this: ${info.get.interfaces}"
+      )
 
       assert(info.get.nestedClasses.forall(c => ifInit(c)(_.isNestedClass.get)), info.get.nestedClasses)
     }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 9b4451d492..45d9cc3ff3 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -216,7 +216,18 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   }
 
   private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = {
-    val superClassSym = if (classSym.isImplClass) ObjectClass else classSym.superClass
+    // Check for isImplClass: trait implementation classes have NoSymbol as superClass
+    // Check for hasAnnotationFlag for SI-9393: the classfile / java source parsers add
+    // scala.annotation.Annotation as superclass to java annotations. In reality, java
+    // annotation classfiles have superclass Object (like any interface classfile).
+    val superClassSym = if (classSym.isImplClass || classSym.hasJavaAnnotationFlag) ObjectClass else {
+      val sc = classSym.superClass
+      // SI-9393: Java annotation classes don't have the ABSTRACT/INTERFACE flag, so they appear
+      // (wrongly) as superclasses. Fix this for BTypes: the java annotation will appear as interface
+      // (handled by method implementedInterfaces), the superclass is set to Object.
+      if (sc.hasJavaAnnotationFlag) ObjectClass
+      else sc
+    }
     assert(
       if (classSym == ObjectClass)
         superClassSym == NoSymbol
@@ -567,7 +578,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0,
       if (sym.isArtifact) ACC_SYNTHETIC else 0,
       if (sym.isClass && !sym.isInterface) ACC_SUPER else 0,
-      if (sym.hasEnumFlag) ACC_ENUM else 0,
+      if (sym.hasJavaEnumFlag) ACC_ENUM else 0,
       if (sym.isVarargsMethod) ACC_VARARGS else 0,
       if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0,
       if (sym.isDeprecated) asm.Opcodes.ACC_DEPRECATED else 0
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index a5b037159c..7096f16d75 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -307,7 +307,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0,
       if (sym.isArtifact) ACC_SYNTHETIC else 0,
       if (sym.isClass && !sym.isInterface) ACC_SUPER else 0,
-      if (sym.hasEnumFlag) ACC_ENUM else 0,
+      if (sym.hasJavaEnumFlag) ACC_ENUM else 0,
       if (sym.isVarargsMethod) ACC_VARARGS else 0,
       if (sym.hasFlag(Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0
     )
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index 03f0236734..eb25eb6e06 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -370,7 +370,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
             flags |= Flags.FINAL
             in.nextToken()
           case DEFAULT =>
-            flags |= Flags.DEFAULTMETHOD
+            flags |= Flags.JAVA_DEFAULTMETHOD
             in.nextToken()
           case NATIVE =>
             addAnnot(NativeAttr)
@@ -489,7 +489,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
           val vparams = formalParams()
           if (!isVoid) rtpt = optArrayBrackets(rtpt)
           optThrows()
-          val isConcreteInterfaceMethod = !inInterface || (mods hasFlag Flags.DEFAULTMETHOD) || (mods hasFlag Flags.STATIC)
+          val isConcreteInterfaceMethod = !inInterface || (mods hasFlag Flags.JAVA_DEFAULTMETHOD) || (mods hasFlag Flags.STATIC)
           val bodyOk = !(mods1 hasFlag Flags.DEFERRED) && isConcreteInterfaceMethod
           val body =
             if (bodyOk && in.token == LBRACE) {
@@ -751,7 +751,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
       val (statics, body) = typeBody(AT, name)
       val templ = makeTemplate(annotationParents, body)
       addCompanionObject(statics, atPos(pos) {
-        ClassDef(mods, name, List(), templ)
+        ClassDef(mods | Flags.JAVA_ANNOTATION, name, List(), templ)
       })
     }
 
@@ -809,7 +809,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
         if (hasAbstractMember) Flags.ABSTRACT else 0l
       }
       addCompanionObject(consts ::: statics ::: predefs, atPos(pos) {
-        ClassDef(mods | Flags.ENUM | finalFlag | abstractFlag, name, List(),
+        ClassDef(mods | Flags.JAVA_ENUM | finalFlag | abstractFlag, name, List(),
                  makeTemplate(superclazz :: interfaces, body))
       })
     }
@@ -830,7 +830,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
           skipAhead()
           accept(RBRACE)
         }
-        ValDef(Modifiers(Flags.ENUM | Flags.STABLE | Flags.JAVA | Flags.STATIC), name.toTermName, enumType, blankExpr)
+        ValDef(Modifiers(Flags.JAVA_ENUM | Flags.STABLE | Flags.JAVA | Flags.STATIC), name.toTermName, enumType, blankExpr)
       }
       (res, hasClassBody)
     }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 91355693ee..06a0299d2a 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -862,7 +862,7 @@ abstract class ClassfileParser {
           srcfile0 = settings.outputDirs.srcFilesFor(in.file, srcpath).find(_.exists)
         case tpnme.CodeATTR =>
           if (sym.owner.isInterface) {
-            sym setFlag DEFAULTMETHOD
+            sym setFlag JAVA_DEFAULTMETHOD
             log(s"$sym in ${sym.owner} is a java8+ default method.")
           }
           in.skip(attrLen)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index c1655467e9..4ad81b60ae 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -145,8 +145,8 @@ trait Namers extends MethodSynthesis {
         // while Scala's enum constants live directly in the class.
         // We don't check for clazz.superClass == JavaEnumClass, because this causes a illegal
         // cyclic reference error. See the commit message for details.
-        if (context.unit.isJava) owner.companionClass.hasEnumFlag else owner.hasEnumFlag
-      vd.mods.hasAllFlags(ENUM | STABLE | STATIC) && ownerHasEnumFlag
+        if (context.unit.isJava) owner.companionClass.hasJavaEnumFlag else owner.hasJavaEnumFlag
+      vd.mods.hasAllFlags(JAVA_ENUM | STABLE | STATIC) && ownerHasEnumFlag
     }
 
     def setPrivateWithin[T <: Symbol](tree: Tree, sym: T, mods: Modifiers): T =
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 36423fa2aa..0198529ef7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -421,7 +421,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             overrideError("cannot be used here - classes can only override abstract types")
           } else if (other.isEffectivelyFinal) { // (1.2)
             overrideError("cannot override final member")
-          } else if (!other.isDeferredOrDefault && !other.hasFlag(DEFAULTMETHOD) && !member.isAnyOverride && !member.isSynthetic) { // (*)
+          } else if (!other.isDeferredOrJavaDefault && !other.hasFlag(JAVA_DEFAULTMETHOD) && !member.isAnyOverride && !member.isSynthetic) { // (*)
             // (*) Synthetic exclusion for (at least) default getters, fixes SI-5178. We cannot assign the OVERRIDE flag to
             // the default getter: one default getter might sometimes override, sometimes not. Example in comment on ticket.
               if (isNeitherInClass && !(other.owner isSubClass member.owner))
@@ -604,7 +604,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
         def checkNoAbstractMembers(): Unit = {
           // Avoid spurious duplicates: first gather any missing members.
           def memberList = clazz.info.nonPrivateMembersAdmitting(VBRIDGE)
-          val (missing, rest) = memberList partition (m => m.isDeferredNotDefault && !ignoreDeferred(m))
+          val (missing, rest) = memberList partition (m => m.isDeferredNotJavaDefault && !ignoreDeferred(m))
           // Group missing members by the name of the underlying symbol,
           // to consolidate getters and setters.
           val grouped = missing groupBy (sym => analyzer.underlyingSymbol(sym).name)
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 }