Use scala.compat.JEnum instead of java.lang.Enum

Use scala.compat.JEnum instead of java.lang.Enum to publish a Scala enum
as a Java enum. This avoids having to hijack java.lang.Enums constructor.
The latter leads to problems when compiling the standard 2.13 standard library.

Author: odersky

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

@@ -293,10 +293,10 @@ class Definitions {
     cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
     cls.setFlag(NoInits)
 
-    // The companion object of a Java class doesn't really exist, `NoType` is the general
+    // The companion object doesn't really exist, `NoType` is the general
     // technique to do that. Here we need to set it before completing
     // attempt to load Object's classfile, which causes issue #1648.
-    val companion = JavaLangPackageVal.info.decl(cls.name.toTermName).symbol
+    val companion = JavaLangPackageVal.info.decl(nme.Object).symbol
     companion.moduleClass.info = NoType // to indicate that it does not really exist
     companion.info = NoType // to indicate that it does not really exist
     completeClass(cls)
@@ -613,26 +613,6 @@ class Definitions {
       JavaSerializableClass.typeRef
     else
       ctx.requiredClassRef("scala.Serializable")
-
-  lazy val JavaEnumClass: ClassSymbol           = {
-    val cls = ctx.requiredClass("java.lang.Enum")
-    val constr = cls.primaryConstructor
-    val newInfo = constr.info match {
-      case info: PolyType =>
-        info.resType match {
-          case meth: MethodType =>
-            info.derivedLambdaType(
-              resType = meth.derivedLambdaType(
-                paramNames = Nil, paramInfos = Nil))
-        }
-    }
-    constr.info = newInfo
-    constr.termRef.recomputeDenot()
-    cls.setFlag(NoInits | Permanent)
-    cls
-  }
-  def JavaEnumType = JavaEnumClass.typeRef
-
   def SerializableClass(implicit ctx: Context): ClassSymbol = SerializableType.symbol.asClass
   lazy val StringBuilderType: TypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
   def StringBuilderClass(implicit ctx: Context): ClassSymbol = StringBuilderType.symbol.asClass
@@ -693,6 +673,8 @@ class Definitions {
   def NoneClass(implicit ctx: Context): ClassSymbol = NoneModuleRef.symbol.moduleClass.asClass
   lazy val EnumType: TypeRef                    = ctx.requiredClassRef("scala.Enum")
   def EnumClass(implicit ctx: Context): ClassSymbol = EnumType.symbol.asClass
+  lazy val JEnumType: TypeRef                   = ctx.requiredClassRef("scala.compat.JEnum")
+  def JEnumClass(implicit ctx: Context): ClassSymbol = JEnumType.symbol.asClass
   lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
   def EnumValuesClass(implicit ctx: Context): ClassSymbol = EnumValuesType.symbol.asClass
   lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")
@@ -1457,7 +1439,7 @@ class Definitions {
         ScalaPackageClass.enter(m)
 
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
+      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
 
       isInitialized = true
     }

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

@@ -34,17 +34,14 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
     // Because it adds additional parameters to some constructors
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type =
-    if (sym.isConstructor && (
-         sym == defn.JavaEnumClass.primaryConstructor ||
-         derivesFromJavaEnum(sym.owner)))
-      addConstrParams(sym.info)
+    if (sym.isConstructor && derivesFromJEnum(sym.owner)) addConstrParams(sym.info)
     else tp
 
   /** Is `sym` a Scala enum class that derives (directly) from `java.lang.Enum`?
    */
-  private def derivesFromJavaEnum(sym: Symbol)(implicit ctx: Context) =
+  private def derivesFromJEnum(sym: Symbol)(implicit ctx: Context) =
     sym.is(Enum, butNot = Case) &&
-    sym.info.parents.exists(p => p.typeSymbol == defn.JavaEnumClass)
+    sym.info.parents.exists(p => p.typeSymbol == defn.JEnumClass)
 
   /** Add constructor parameters `$name: String` and `$ordinal: Int` to the end of
    *  the last parameter list of (method- or poly-) type `tp`.
@@ -100,10 +97,10 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    */
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): DefDef = {
     val sym = tree.symbol
-    if (sym.isConstructor && derivesFromJavaEnum(sym.owner))
+    if (sym.isConstructor && derivesFromJEnum(sym.owner))
       cpy.DefDef(tree)(
         vparamss = tree.vparamss.init :+ (tree.vparamss.last ++ addedParams(sym, Param)))
-    else if (sym.name == nme.DOLLAR_NEW && derivesFromJavaEnum(sym.owner.linkedClass)) {
+    else if (sym.name == nme.DOLLAR_NEW && derivesFromJEnum(sym.owner.linkedClass)) {
       val Block((tdef @ TypeDef(tpnme.ANON_CLASS, templ: Template)) :: Nil, call) = tree.rhs
       val args = tree.vparamss.last.takeRight(2).map(param => ref(param.symbol)).reverse
       val templ1 = cpy.Template(templ)(
@@ -115,7 +112,8 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
   }
 
   /** 1. If this is an enum class, add $name and $ordinal parameters to its
-   *     parameter accessors and pass them on to the java.lang.Enum constructor.
+   *     parameter accessors and pass them on to the java.lang.Enum constructor,
+   *     replacing the dummy arguments that were passed before.
    *
    *  2. If this is an anonymous class that implement a value enum case,
    *     pass $name and $ordinal parameters to the enum superclass. The class
@@ -136,15 +134,20 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    */
   override def transformTemplate(templ: Template)(implicit ctx: Context): Template = {
     val cls = templ.symbol.owner
-    if (derivesFromJavaEnum(cls)) {
+    if (derivesFromJEnum(cls)) {
       val (params, rest) = decomposeTemplateBody(templ.body)
       val addedDefs = addedParams(cls, ParamAccessor)
       val addedSyms = addedDefs.map(_.symbol.entered)
+      val parents1 = templ.parents.map {
+        case app @ Apply(fn, _) if fn.symbol.owner == defn.JEnumClass =>
+          cpy.Apply(app)(fn, addedSyms.map(ref))
+        case p => p
+      }
       cpy.Template(templ)(
-        parents = addEnumConstrArgs(defn.JavaEnumClass, templ.parents, addedSyms.map(ref)),
+        parents = parents1,
         body = params ++ addedDefs ++ rest)
     }
-    else if (cls.isAnonymousClass && cls.owner.is(EnumCase) && derivesFromJavaEnum(cls.owner.owner.linkedClass)) {
+    else if (cls.isAnonymousClass && cls.owner.is(EnumCase) && derivesFromJEnum(cls.owner.owner.linkedClass)) {
       def rhsOf(name: TermName) =
         templ.body.collect {
           case mdef: DefDef if mdef.name == name => mdef.rhs

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

@@ -1057,8 +1057,8 @@ trait Checking {
       (cls.owner.flagsUNSAFE.is(Case) || cls.owner.name == nme.DOLLAR_NEW)
     if (!isEnumAnonCls) {
       if (cdef.mods.isEnumCase) {
-        if (cls.derivesFrom(defn.JavaEnumClass))
-          ctx.error(em"paramerized case is not allowed in an enum that extends java.lang.Enum", cdef.sourcePos)
+        if (cls.derivesFrom(defn.JEnumClass))
+          ctx.error(em"parameterized case is not allowed in an enum that extends java.lang.Enum", cdef.sourcePos)
       }
       else if (cls.is(Case) || firstParent.is(Enum))
         // Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class

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

@@ -498,23 +498,9 @@ class Namer { typer: Typer =>
     recur(expanded(origStat))
   }
 
-  /** Determines whether this field holds an enum constant.
-    * To qualify, the following conditions must be met:
-    *  - The field's class has the ENUM flag set
-    *  - The field's class extends java.lang.Enum
-    *  - The field has the ENUM flag set
-    *  - The field is static
-    *  - The field is stable
-    */
-  def isEnumConstant(vd: ValDef)(implicit ctx: Context): Boolean = {
-    // val ownerHasEnumFlag =
-    // Necessary to check because scalac puts Java's static members into the companion object
-    // while Scala's enum constants live directly in the class.
-    // We don't check for clazz.superClass == JavaEnumClass, because this causes a illegal
-    // cyclic reference error. See the commit message for details.
-    //  if (ctx.compilationUnit.isJava) ctx.owner.companionClass.is(Enum) else ctx.owner.is(Enum)
-    vd.mods.is(JavaEnumValue) // && ownerHasEnumFlag
-  }
+  /** Determines whether this field holds an enum constant. */
+  def isEnumConstant(vd: ValDef)(implicit ctx: Context): Boolean =
+    vd.mods.is(JavaEnumValue)
 
   /** Add child annotation for `child` to annotations of `cls`. The annotation
    *  is added at the correct insertion point, so that Child annotations appear

library/src/scala/compat/JEnum.scala

@@ -0,0 +1,9 @@
+package scala.compat
+
+/** A base class to be used for Scala enums that should be also exposed
+ *  as Java enums.
+ */
+abstract class JEnum[E <: java.lang.Enum[E]](
+  name: String = throw new UnsupportedOperationException,  // Compiler will pass actual values for these
+  ordinal: Int = throw new UnsupportedOperationException)  // when JEnum is inherited in an enum
+extends java.lang.Enum[E](name, ordinal)

tests/neg/enum-constrs.scala

@@ -1,5 +1,5 @@
 
-enum E[+T] extends java.lang.Enum[E[_]] {
+enum E[+T] extends compat.JEnum[E[_]] {
   case S1, S2
   case C() extends E[Int]  // error: parameterized case is not allowed
 }

tests/run/enum-constrs.scala

@@ -1,13 +1,13 @@
-enum Color extends java.lang.Enum[Color] {
+enum Color extends compat.JEnum[Color] {
   case Red, Green, Blue
 }
 
-enum E[+T] extends java.lang.Enum[E[_]] {
+enum E[+T] extends compat.JEnum[E[_]] {
   case S1, S2
   case C extends E[Int]
 }
 
-enum Vehicle(wheels: Int) extends java.lang.Enum[Vehicle] {
+enum Vehicle(wheels: Int) extends compat.JEnum[Vehicle] {
   case Bike extends Vehicle(2)
   case Car extends Vehicle(4)
 }