Fix #7499, fix #7174: prevent extending jl.Enum except from an enum

Author: TheElectronWill

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

@@ -585,13 +585,18 @@ class Definitions {
 
    @tu lazy val JavaEnumClass: ClassSymbol = {
     val cls = requiredClass("java.lang.Enum")
+    // jl.Enum has a single constructor protected(name: String, ordinal: Int).
+    // We remove the arguments from the primary constructor, and enter
+    // a new constructor symbol with 2 arguments, so that both
+    // `X extends jl.Enum[X]` and `X extends jl.Enum[X](name, ordinal)`
+    // pass typer and go through jl.Enum-specific checks in RefChecks.
     cls.infoOrCompleter match {
       case completer: ClassfileLoader =>
         cls.info = new ClassfileLoader(completer.classfile) {
           override def complete(root: SymDenotation)(using Context): Unit = {
             super.complete(root)
             val constr = cls.primaryConstructor
-            val newInfo = constr.info match {
+            val noArgInfo = constr.info match {
               case info: PolyType =>
                 info.resType match {
                   case meth: MethodType =>
@@ -600,7 +605,8 @@ class Definitions {
                       paramNames = Nil, paramInfos = Nil))
                 }
             }
-            constr.info = newInfo
+            val argConstr = constr.copy().entered
+            constr.info = noArgInfo
             constr.termRef.recomputeDenot()
           }
         }

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -164,7 +164,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     UnexpectedPatternForSummonFromID,
     AnonymousInstanceCannotBeEmptyID,
     TypeSpliceInValPatternID,
-    ModifierNotAllowedForDefinitionID
+    ModifierNotAllowedForDefinitionID,
+    CannotExtendJavaEnumID
 
   def errorNumber = ordinal - 2
 }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1490,6 +1490,12 @@ import ast.tpd
           |"""
   }
 
+  class CannotExtendJavaEnum(sym: Symbol)(using Context)
+    extends SyntaxMsg(CannotExtendJavaEnumID) {
+      def msg = em"""$sym cannot extend ${hl("java.lang.Enum")}: only enums defined with the ${hl("enum")} syntax can"""
+      def explain = ""
+    }
+
   class CannotHaveSameNameAs(sym: Symbol, cls: Symbol, reason: CannotHaveSameNameAs.Reason)(using Context)
     extends SyntaxMsg(CannotHaveSameNameAsID) {
     import CannotHaveSameNameAs._

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

@@ -73,7 +73,10 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    */
   private def addEnumConstrArgs(targetCls: Symbol, parents: List[Tree], args: List[Tree])(using Context): List[Tree] =
     parents.map {
-      case app @ Apply(fn, args0) if fn.symbol.owner == targetCls => cpy.Apply(app)(fn, args0 ++ args)
+      case app @ Apply(fn, args0) if fn.symbol.owner == targetCls =>
+        if args0.nonEmpty && targetCls == defn.JavaEnumClass then
+          report.error("the constructor of java.lang.Enum cannot be called explicitly", app.sourcePos)
+        cpy.Apply(app)(fn, args0 ++ args)
       case p => p
     }
 

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

@@ -88,8 +88,9 @@ object RefChecks {
       cls.thisType
   }
 
-  /** Check that self type of this class conforms to self types of parents.
-   *  and required classes.
+  /** Check that self type of this class conforms to self types of parents
+   *  and required classes. Also check that only `enum` constructs extend
+   *  `java.lang.Enum`.
    */
   private def checkParents(cls: Symbol)(using Context): Unit = cls.info match {
     case cinfo: ClassInfo =>
@@ -99,10 +100,14 @@ object RefChecks {
           report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other.classSymbol),
             cls.sourcePos)
       }
-      for (parent <- cinfo.classParents)
+      val parents = cinfo.classParents
+      for (parent <- parents)
         checkSelfConforms(parent.classSymbol.asClass, "illegal inheritance", "parent")
       for (reqd <- cinfo.cls.givenSelfType.classSymbols)
         checkSelfConforms(reqd, "missing requirement", "required")
+
+      if !cls.is(Enum) && parents.exists(_.classSymbol == defn.JavaEnumClass) then
+        report.error(CannotExtendJavaEnum(cls), cls.sourcePos)
     case _ =>
   }