Set enum as abstract always

scala · lrytz · Jun 20, 2023 · Jun 6, 2023 · Jun 7, 2023 · Jun 19, 2023
commit 8d5cb076a3b2ef90280d411c14c4c9ef51d88f78
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -593,19 +593,17 @@ abstract class ClassfileParser(reader: ReusableInstance[ReusableDataReader]) {
       getScope(jflags) enter sym
 
       // sealed java enums
-      if (jflags.isEnum) {
-        val enumClass = sym.owner.linkedClassOfClass
-        enumClass match {
+      if (jflags.isEnum)
+        sym.owner.linkedClassOfClass match {
           case NoSymbol =>
             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. 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
+          case enumClass =>
+            // 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.
+            // Java enums may be already sealed by virtue of permittedSubclasses, if an element had a body.
+            enumClass.setFlag(SEALED | ABSTRACT)
+            enumClass.addChild(sym)
         }
-      }
     }
   }
 
@@ -1382,9 +1380,11 @@ abstract class ClassfileParser(reader: ReusableInstance[ReusableDataReader]) {
         ClassInfoType(superTpe1 :: ifacesTypes, instanceScope, clazz)
       }
       sym.setInfo(info)
-      for (k <- permittedSubclasses)
-        if (k.parentSymbols.contains(sym))
-          sym.addChild(k)
+      // enum children are its enum fields, so don't register subclasses (which are listed as permitted)
+      if (!sym.hasJavaEnumFlag)
+        for (k <- permittedSubclasses)
+          if (k.parentSymbols.contains(sym))
+            sym.addChild(k)
     }
   }
 

diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
@@ -129,7 +129,9 @@ trait TreeAndTypeAnalysis extends Debugging {
       def filterAndSortChildren(children: Set[Symbol]) = {
         // symbols which are both sealed and abstract need not be covered themselves,
         // because all of their children must be and they cannot otherwise be created.
-        val children1 = children.toList.filterNot(child => child.isSealed && child.isAbstractClass).sortBy(_.sealedSortName)
+        val children1 = children.toList
+          .filterNot(child => child.isSealed && (child.isAbstractClass || child.hasJavaEnumFlag))
+          .sortBy(_.sealedSortName)
         children1.filterNot { child =>
           // remove private abstract children that are superclasses of other children, for example in t6159 drop X2
           child.isPrivate && child.isAbstractClass && children1.exists(sym => (sym ne child) && sym.isSubClass(child))
@@ -874,7 +876,7 @@ trait MatchAnalysis extends MatchApproximation {
                       case args                            => args
                     }.map(ListExample)
                   case _ if isTupleSymbol(cls)                  => args(brevity = true).map(TupleExample)
-                  case _ if cls.isSealed && cls.isAbstractClass =>
+                  case _ if cls.isSealed && (cls.isAbstractClass || cls.hasJavaEnumFlag) =>
                     // don't report sealed abstract classes, since
                     // 1) they can't be instantiated
                     // 2) we are already reporting any missing subclass (since we know the full domain)

diff --git a/test/files/neg/t12800.check b/test/files/neg/t12800.check
@@ -0,0 +1,7 @@
+matcher_1.scala:8: warning: match may not be exhaustive.
+It would fail on the following input: ORANGE
+    jb match {
+    ^
+error: No warnings can be incurred under -Werror.
+1 warning
+1 error
diff --git a/test/files/neg/t12800/JetBrains.java b/test/files/neg/t12800/JetBrains.java
@@ -0,0 +1,13 @@
+
+public enum JetBrains {
+	APPLE {
+		@Override public String text() {
+			return "Cupertino tech company";
+		}
+	},
+	ORANGE
+	;
+	public String text() {
+		return "Boring default";
+	}
+}
diff --git a/test/files/neg/t12800/matcher_1.scala b/test/files/neg/t12800/matcher_1.scala
@@ -0,0 +1,11 @@
+
+// scalac: -Werror -Xsource:3
+
+import JetBrains.*
+
+class C {
+  def f(jb: JetBrains): Int =
+    jb match {
+      case APPLE  => 42
+    }
+}
diff --git a/test/files/pos/t12800/JetBrains.java b/test/files/pos/t12800/JetBrains.java
@@ -0,0 +1,14 @@
+
+public enum JetBrains {
+	APPLE {
+		@Override public String text() {
+			return "Cupertino tech company";
+		}
+	},
+	ORANGE {
+		@Override public String text() {
+			return "SoCal county";
+		}
+	};
+	public abstract String text();
+}
diff --git a/test/files/pos/t12800/matcher_1.scala b/test/files/pos/t12800/matcher_1.scala
@@ -0,0 +1,12 @@
+
+// scalac: -Werror -Xsource:3
+
+import JetBrains.*
+
+class C {
+  def f(jb: JetBrains): Int =
+    jb match {
+      case APPLE  => 42
+      case ORANGE => 27
+    }
+}