check enum parents before typing body

Author: bishabosha

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -78,8 +78,7 @@ object DesugarEnums {
     Select(Ident(nme.DOLLAR_VALUES), name.toTermName)
 
   private def registerCall(using Context): Tree =
-    val asRaw = TypeApply(Select(This(EmptyTypeIdent), nme.asInstanceOf_), rawRef(enumClass.typeRef) :: Nil) // safe to cast due to refchecks
-    Apply(valuesDot("register"), asRaw :: Nil)
+    Apply(valuesDot("register"), This(EmptyTypeIdent) :: Nil)
 
   /**  The following lists of definitions for an enum type E:
    *

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

@@ -655,7 +655,7 @@ class Definitions {
 
   @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
     @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =
-      EnumValueSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty)))
+      EnumValueSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty), IntType))
 
   @tu lazy val ProductClass: ClassSymbol = requiredClass("scala.Product")
     @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)

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

@@ -294,7 +294,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(call)))
         case templ: Template =>
           withNoCheckNews(templ.parents.flatMap(newPart)) {
-            Checking.checkEnumParentOK(templ.symbol.owner)
             forwardParamAccessors(templ)
             synthMbr.addSyntheticMembers(
                 superAcc.wrapTemplate(templ)(

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

@@ -630,16 +630,10 @@ object Checking {
     }
   }
 
-  /** Check that an enum case extends its enum class */
-  def checkEnumParentOK(cls: Symbol)(using Context): Unit =
-    val enumCase =
-      if cls.isAllOf(EnumCase) then cls
-      else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
-      else NoSymbol
-    if enumCase.exists then
-      val enumCls = enumCase.owner.linkedClass
-      if !cls.info.parents.exists(_.typeSymbol == enumCls) then
-        report.error(i"enum case does not extend its enum $enumCls", enumCase.sourcePos)
+  def optEnumCase(cls: Symbol)(using Context): Symbol =
+    (if cls.isAllOf(EnumCase) then cls
+    else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
+    else NoSymbol).filter(s => s.exists && s.owner.linkedClass.derivesFrom(defn.EnumClass))
 
   /** Check the inline override methods only use inline parameters if they override an inline parameter. */
   def checkInlineOverrideParameters(sym: Symbol)(using Context): Unit =
@@ -1092,8 +1086,9 @@ trait Checking {
 
   /** 1. Check that all case classes that extend `scala.Enum` are `enum` cases
    *  2. Check that case class `enum` cases do not extend java.lang.Enum.
+   *  3. Check that the firstParent derives from the declaring enum class.
    */
-  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = {
+  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, enumCase: Symbol, firstParent: Symbol)(using Context): Boolean = {
     def isEnumAnonCls =
       cls.isAnonymousClass &&
       cls.owner.isTerm &&
@@ -1110,6 +1105,12 @@ trait Checking {
         // Unlike firstParent.derivesFrom(defn.EnumClass), this test allows inheriting from `Enum` by hand;
         // see enum-List-control.scala.
         report.error(ClassCannotExtendEnum(cls, firstParent), cdef.sourcePos)
+    val enumCls = enumCase.owner.linkedClass
+    if !firstParent.derivesFrom(enumCls) then
+      report.error(i"enum case does not extend its enum $enumCls", enumCase.sourcePos)
+      false
+    else
+      true
   }
 
   /** Check that all references coming from enum cases in an enum companion object
@@ -1205,7 +1206,7 @@ trait Checking {
 
 trait ReChecking extends Checking {
   import tpd._
-  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
+  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, enumCase: Symbol, firstParent: Symbol)(using Context): Boolean = true
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(using Context): Unit = ()
   override def checkFullyAppliedType(tree: Tree)(using Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()

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

@@ -2071,24 +2071,27 @@ class Typer extends Namer
     val parentsWithClass = ensureFirstTreeIsClass(parents.mapconserve(typedParent).filterConserve(!_.isEmpty), cdef.nameSpan)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(using superCtx)
 
+    var forceEmptyBody: Boolean = false
+    val enumCaseDef = optEnumCase(cls)
+    if enumCaseDef.exists then
+      val firstParent = parents1.head.tpe.dealias.typeSymbol
+      forceEmptyBody = !checkEnum(cdef, cls, enumCaseDef, firstParent) // don't bother looking inside the template
+
     val self1 = typed(self)(using ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
     if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1))
       // fail fast to avoid typing the body with an error type
       cdef.withType(UnspecifiedErrorType)
     else {
       val dummy = localDummy(cls, impl)
-      val body1 = addAccessorDefs(cls,
-        typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
+      val body1 =
+        if forceEmptyBody then Nil
+        else addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
 
       checkNoDoubleDeclaration(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)
         .withType(dummy.termRef)
       if (!cls.isOneOf(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.sourcePos.withSpan(cdef.nameSpan))
-      if (cls.derivesFrom(defn.EnumClass)) {
-        val firstParent = parents1.head.tpe.dealias.typeSymbol
-        checkEnum(cdef, cls, firstParent)
-      }
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
 
       val reportDynamicInheritance =

library/src/scala/runtime/EnumValueSerializationProxy.java

@@ -5,7 +5,7 @@
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
 
-/** A serialization proxy for singleton enum values */
+/** A serialization proxy for singleton enum values, based on `scala.runtime.ModuleSerializationProxy` */
 public final class EnumValueSerializationProxy implements Serializable {
     private static final long serialVersionUID = 1L;
     private final Class<?> enumClass;
@@ -17,17 +17,13 @@ protected Object[] computeValue(Class<?> type) {
                 return AccessController.doPrivileged((PrivilegedExceptionAction<Object[]>) () ->
                   (Object[])type.getMethod("values").invoke(null));
             } catch (PrivilegedActionException e) {
-                return rethrowRuntime(e.getCause());
+                Throwable cause = e.getCause();
+                if (cause instanceof RuntimeException) throw (RuntimeException) cause;
+                else throw new RuntimeException(cause);
             }
         }
     };
 
-    private static <T> T rethrowRuntime(Throwable e) {
-        Throwable cause = e.getCause();
-        if (cause instanceof RuntimeException) throw (RuntimeException) cause;
-        else throw new RuntimeException(cause);
-    }
-
     public EnumValueSerializationProxy(Class<?> enumClass, int ordinal) {
         this.enumClass = enumClass;
         this.ordinal = ordinal;