reject more classes extending enums, simplify check

Author: bishabosha

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -651,7 +651,6 @@ class Definitions {
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
 
   @tu lazy val EnumValuesClass: ClassSymbol = requiredClass("scala.runtime.EnumValues")
-  @tu lazy val EnumValueClass: ClassSymbol = requiredClass("scala.runtime.EnumValue")
 
   @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
     @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -382,8 +382,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     else
       Nil
 
+  /** Is this an anonymous class deriving from an enum definition? */
   extension (cls: ClassSymbol) private def isEnumValueImplementation(using Context): Boolean =
-    derivesFrom(defn.EnumValueClass) && classParents.exists(_.typeSymbol.flags.is(Enum))
+    isAnonymousClass && classParents.head.typeSymbol.is(Enum) // asserted in Typer
 
   /** If this is the class backing a serializable singleton enum value with base class `MyEnum`,
    *  and not deriving from `java.lang.Enum` add the method:

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1084,9 +1084,10 @@ trait Checking {
    */
   def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = {
     def isEnumAnonCls =
-      cls.isAnonymousClass &&
-      cls.owner.isTerm &&
-      (cls.owner.flagsUNSAFE.is(Case) || cls.owner.name == nme.DOLLAR_NEW)
+      cls.isAnonymousClass
+      && cls.owner.isTerm
+      && (cls.owner.flagsUNSAFE.isAllOf(EnumCase)
+        || ((cls.owner.name eq nme.DOLLAR_NEW) && cls.owner.flagsUNSAFE.isAllOf(Private | Synthetic)))
     if (!isEnumAnonCls)
       if (cdef.mods.isEnumCase) {
         if (cls.derivesFrom(defn.JavaEnumClass))
@@ -1101,8 +1102,10 @@ trait Checking {
         report.error(ClassCannotExtendEnum(cls, firstParent), cdef.sourcePos)
   }
 
-  /** Check that the firstParent derives from the declaring enum class, if not, adds it as a parent after emitting an
-   *  error.
+  /** Check that the firstParent for an enum case derives from the declaring enum class, if not, adds it as a parent
+   *  after emitting an error.
+   *
+   *  This check will have no effect on simple enum cases as their parents are inferred by the compiler.
    */
   def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit =
 
@@ -1119,8 +1122,8 @@ trait Checking {
           case _ =>
 
     val enumCase =
-      if cls.isAllOf(EnumCase) then cls
-      else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
+      if cls.flagsUNSAFE.isAllOf(EnumCase) then cls
+      else if cls.isAnonymousClass && cls.owner.flagsUNSAFE.isAllOf(EnumCase) then cls.owner
       else NoSymbol
     if enumCase.exists then
       ensureParentDerivesFrom(enumCase)

tests/neg/enums.scala

@@ -40,6 +40,20 @@ enum Option[+T] derives Eql {
   case None
 }
 
+object DollarNew {
+
+  enum MyEnum:
+    case A
+
+  object MyEnum:
+
+    def $new: MyEnum = new MyEnum with runtime.EnumValue { // error: anonymous class in method $new extends enum MyEnum, but extending enums is prohibited.
+      override def $ordinal = 1
+    }
+
+    final val F = $new
+}
+
 object Test {
 
   class Unrelated
@@ -48,4 +62,3 @@ object Test {
   x == new Unrelated // error: cannot compare
 
 }
-