Forbid inheriting from Scala enums altogether

Author: Blaisorblade

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

@@ -846,14 +846,21 @@ trait Checking {
   }
 
   /** Check that all case classes that extend `scala.Enum` are `enum` cases */
-  def checkEnum(cdef: untpd.TypeDef, cls: Symbol)(implicit ctx: Context): Unit = {
+  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(implicit ctx: Context): Unit = {
     import untpd.modsDeco
     def isEnumAnonCls =
       cls.isAnonymousClass &&
       cls.owner.isTerm &&
       (cls.owner.flagsUNSAFE.is(Case) || cls.owner.name == nme.DOLLAR_NEW)
-    if (!cdef.mods.isEnumCase && !isEnumAnonCls)
-      ctx.error(em"normal case $cls in ${cls.owner} cannot extend an enum", cdef.pos)
+    if (!cdef.mods.isEnumCase && !isEnumAnonCls) {
+      if (cls.is(Case))
+        ctx.error(em"normal case $cls in ${cls.owner} cannot extend an enum", cdef.pos)
+      else if (firstParent != defn.EnumClass && firstParent.derivesFrom(defn.EnumClass) && !cdef.mods.isEnumCase && !isEnumAnonCls)
+        // Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class
+        // parent.
+        //Tricky to phrase; language taken from "case-to-case inheritance is prohibited".
+        ctx.error(s"${cls.name} has enum ancestor ${firstParent.name}, but inheriting from enums is prohibited", cdef.pos)
+    }
   }
 
   /** Check that all references coming from enum cases in an enum companion object
@@ -931,7 +938,7 @@ trait Checking {
 
 trait ReChecking extends Checking {
   import tpd._
-  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol)(implicit ctx: Context): Unit = ()
+  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(implicit ctx: Context): Unit = ()
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(implicit ctx: Context): Unit = ()
   override def checkEnumCompanions(stats: List[Tree], enumContexts: collection.Map[Symbol, Context])(implicit ctx: Context): List[Tree] = stats
 }

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

@@ -1574,15 +1574,8 @@ class Typer extends Namer
         .withType(dummy.termRef)
       if (!cls.is(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.namePos)
-      if (cls.is(Case) && cls.derivesFrom(defn.EnumClass)) checkEnum(cdef, cls)
-      if (seenParents.contains(defn.EnumClass)) {
-        // Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class
-        // parent.
-        val firstParent = parents1.head.tpe.dealias.typeSymbol
-        if (firstParent.derivesFrom(defn.EnumClass))
-          //Tricky to phrase; language taken from "case-to-case inheritance is prohibited".
-          ctx.error(s"Enum ${cls.name} has enum ancestor ${firstParent.name}, but enum-to-enum inheritance is prohibited", cdef.pos)
-      }
+      val firstParent = parents1.head.tpe.dealias.typeSymbol
+      if (cls.derivesFrom(defn.EnumClass)) checkEnum(cdef, cls, firstParent)
 
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
       checkVariance(cdef1)

tests/neg/i5008.scala

@@ -3,3 +3,6 @@ enum Bar { case A }
 enum Baz extends Foo { case Z } // error
 
 enum Quux extends Foo with Bar { case Z } // error
+
+class Quuw extends Foo // error
+class Quuz extends Foo { val enumTag = 1 } // error