SI-8700 Exhaustiveness warning for enums from Java source

Until now, the warning was only emitted for enums from Java class files.

This commit fixes it by
- aligning the flags set in JavaParsers with the flags set in
  ClassfileParser (which are required by the pattern matcher to
  even consider checking exhaustiveness)
- adding the enum members as childs to the class holding the enum
  as done in ClassfileParser so that the pattern matcher sees the enum
  members when looking for the sealed children of a type

4 files changed, 10 insertions, 13 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 3696bb3daf..53304d137f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -671,7 +671,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     // Primitives are "abstract final" to prohibit instantiation
     // without having to provide any implementations, but that is an
     // illegal combination of modifiers at the bytecode level so
-    // suppress final if abstract if present.
+    // suppress final if abstract is present.
     import asm.Opcodes._
     GenBCode.mkFlags(
       if (privateFlag) ACC_PRIVATE else ACC_PUBLIC,
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index eb25eb6e06..7224523a41 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -800,16 +800,10 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
       val superclazz =
         AppliedTypeTree(javaLangDot(tpnme.Enum), List(enumType))
       val finalFlag = if (enumIsFinal) Flags.FINAL else 0l
-      val abstractFlag = {
-        // javac adds `ACC_ABSTRACT` to enum classes with deferred members
-        val hasAbstractMember = body exists {
-          case d: DefDef => d.mods.isDeferred
-          case _         => false
-        }
-        if (hasAbstractMember) Flags.ABSTRACT else 0l
-      }
       addCompanionObject(consts ::: statics ::: predefs, atPos(pos) {
-        ClassDef(mods | Flags.JAVA_ENUM | finalFlag | abstractFlag, name, List(),
+        // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking. See also ClassfileParser.
+        // This is a bit of a hack and requires excluding the ABSTRACT flag in the backend, see method javaClassfileFlags.
+        ClassDef(mods | Flags.JAVA_ENUM | Flags.SEALED | Flags.ABSTRACT | finalFlag, name, List(),
                  makeTemplate(superclazz :: interfaces, body))
       })
     }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 99e61d2482..406411f21f 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -542,7 +542,7 @@ abstract class ClassfileParser {
             devWarning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
           case linked =>
             if (!linked.isSealed)
-              // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking.
+              // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking. See also JavaParsers.
               // This is a bit of a hack and requires excluding the ABSTRACT flag in the backend, see method javaClassfileFlags.
               linked setFlag (SEALED | ABSTRACT)
             linked addChild sym
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index e01edd196e..0b6b6065f3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -653,8 +653,10 @@ trait Namers extends MethodSynthesis {
       if (isScala && deriveAccessors(tree)) enterGetterSetter(tree)
       else assignAndEnterFinishedSymbol(tree)
 
-      if (isEnumConstant(tree))
+      if (isEnumConstant(tree)) {
         tree.symbol setInfo ConstantType(Constant(tree.symbol))
+        tree.symbol.owner.linkedClassOfClass addChild tree.symbol
+      }
     }
 
     def enterLazyVal(tree: ValDef, lazyAccessor: Symbol): TermSymbol = {
@@ -1657,7 +1659,8 @@ trait Namers extends MethodSynthesis {
         checkWithDeferred(FINAL)
       }
 
-      checkNoConflict(FINAL, SEALED)
+      if (!sym.isJavaEnum)
+        checkNoConflict(FINAL, SEALED)
       checkNoConflict(PRIVATE, PROTECTED)
       // checkNoConflict(PRIVATE, OVERRIDE) // this one leads to bad error messages like #4174, so catch in refchecks
       // checkNoConflict(PRIVATE, FINAL)    // can't do this because FINAL also means compile-time constant