SI-9359 Fix InnerClass entry flags for nested Java enums

The access flags in InnerClass entries for nested Java enums were
basically completely off.

A first step is to use the recently introduced backend method
`javaClassfileFlags`, which is now moved to BCodeAsmCommon.
See its doc for an explanation.

Then the flags of the enum class symbol were off. An enum is
  - final if none of its values has a class body
  - abstract if it has an abstract method
(https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.9)

When using the ClassfileParser:
  - ENUM was never added. I guess that's just an oversight.
  - ABSTRACT (together with SEALED) was always added. This is to
    enable exhaustiveness checking, see 3f7b8b5. This is a hack and we
    have to go through the class members in the backend to find out if
    the enum actually has the `ACC_ABSTRACT` flag or not.

When using the JavaParser:
  - FINAL was never added.
  - ABSTRACT was never added.

This commit fixes all of the above and tests cases (Java enum read
from the classfile and from source).

1 files changed, 8 insertions, 5 deletions

diff --git a/src/reflect/scala/reflect/internal/ClassfileConstants.scala b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
index e0a6757d34..53241fb15b 100644
--- a/src/reflect/scala/reflect/internal/ClassfileConstants.scala
+++ b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
@@ -344,10 +344,12 @@ 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 _                   => 0L
     }
-    private def translateFlags(jflags: Int, baseFlags: Long, isAnnotation: Boolean, isClass: Boolean): Long = {
-      def translateFlag0(jflags: Int): Long = translateFlag(jflags, isAnnotation, isClass)
+    private def translateFlags(jflags: Int, baseFlags: Long, isClass: Boolean): Long = {
+      val isAnnot = isAnnotation(jflags)
+      def translateFlag0(jflags: Int): Long = translateFlag(jflags, isAnnot, isClass)
       var res: Long = JAVA | baseFlags
       /* fast, elegant, maintainable, pick any two... */
       res |= translateFlag0(jflags & JAVA_ACC_PRIVATE)
@@ -357,17 +359,18 @@ object ClassfileConstants {
       res |= translateFlag0(jflags & JAVA_ACC_STATIC)
       res |= translateFlag0(jflags & JAVA_ACC_ABSTRACT)
       res |= translateFlag0(jflags & JAVA_ACC_INTERFACE)
+      res |= translateFlag0(jflags & JAVA_ACC_ENUM)
       res
     }
 
     def classFlags(jflags: Int): Long = {
-      translateFlags(jflags, 0, isAnnotation(jflags), isClass = true)
+      translateFlags(jflags, 0, isClass = true)
     }
     def fieldFlags(jflags: Int): Long = {
-      translateFlags(jflags, if ((jflags & JAVA_ACC_FINAL) == 0) MUTABLE else 0 , isAnnotation(jflags), isClass = false)
+      translateFlags(jflags, if ((jflags & JAVA_ACC_FINAL) == 0) MUTABLE else 0 , isClass = false)
     }
     def methodFlags(jflags: Int): Long = {
-      translateFlags(jflags, if ((jflags & JAVA_ACC_BRIDGE) != 0) BRIDGE | ARTIFACT else 0, isAnnotation(jflags), isClass = false)
+      translateFlags(jflags, if ((jflags & JAVA_ACC_BRIDGE) != 0) BRIDGE | ARTIFACT else 0, isClass = false)
     }
   }
   object FlagTranslation extends FlagTranslation { }