Scala Enum conforms to Java enum interface

Author: anatoliykmetyuk

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

@@ -593,7 +593,7 @@ object desugar {
     else if (isObject)
       parents1 = parents1 :+ scalaDot(nme.Serializable.toTypeName)
     if (isEnum)
-      parents1 = parents1 :+ ref(defn.EnumType)
+      parents1 = parents1 :+ appliedRef(ref(defn.EnumType), List(cdef))
 
     // derived type classes of non-module classes go to their companions
     val (clsDerived, companionDerived) =

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

@@ -599,6 +599,8 @@ class Definitions {
   lazy val JavaSerializableClass: ClassSymbol     = ctx.requiredClass("java.io.Serializable")
 
   lazy val ComparableClass: ClassSymbol           = ctx.requiredClass("java.lang.Comparable")
+    lazy val Comparable_compareToR: TermRef = ComparableClass.requiredMethodRef(nme.compareTo)
+    def Comparable_compareTo(implicit ctx: Context): Symbol = Comparable_compareToR.symbol
   lazy val SystemClass: ClassSymbol               = ctx.requiredClass("java.lang.System")
   lazy val SystemModule: Symbol              = SystemClass.linkedClass
 
@@ -677,8 +679,6 @@ class Definitions {
     def Enum_getDeclaringClass(implicit ctx: Context): Symbol = Enum_getDeclaringClassR.symbol
     lazy val Enum_ordinalR: TermRef = EnumClass.requiredMethodRef(nme.ordinal)
     def Enum_ordinal(implicit ctx: Context): Symbol = Enum_ordinalR.symbol
-    lazy val Enum_compareToR: TermRef = EnumClass.requiredMethodRef(nme.compareTo)
-    def Enum_compareTo(implicit ctx: Context): Symbol = Enum_compareToR.symbol
 
   lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
   def EnumValuesClass(implicit ctx: Context): ClassSymbol = EnumValuesType.symbol.asClass

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

@@ -45,7 +45,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     if (myValueSymbols.isEmpty) {
       myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
       mySimpleEnumCaseSymbols = List(
-        defn.Enum_name, defn.Enum_ordinal, defn.Enum_compareTo, defn.Enum_getDeclaringClass)
+        defn.Enum_name, defn.Enum_ordinal, defn.Comparable_compareTo, defn.Enum_getDeclaringClass)
       myCaseSymbols = myValueSymbols ++ mySimpleEnumCaseSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
@@ -80,11 +80,18 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
       else Nil
     }
 
+    def removeColors(msg: String): String = msg.replaceAll("\u001b\\[.*?m", "")
     def syntheticDef(sym: Symbol): Tree = {
-      val synthetic = sym.copy(
-        owner = clazz,
-        flags = sym.flags &~ Deferred | Synthetic | Override,
-        coord = clazz.coord).enteredAfter(thisPhase).asTerm
+      // if (removeColors(sym.show) == "method getDeclaringClass")
+      //   println(s"Sym ${sym.show} info ${sym.denot.info.show} asf ${clazz.info.parents.head.show}: " +
+      //     s"${sym.denot.asSeenFrom(clazz.info.parents.head).info.show}")
+      val synthetic = sym
+        .copy(
+          owner = clazz,
+          info  = if ((sym eq defn.Enum_getDeclaringClass) || (sym eq defn.Comparable_compareTo))
+            sym.denot.asSeenFrom(clazz.info.parents.head).info else sym.info,
+          flags = sym.flags &~ Deferred | Synthetic | Override,
+          coord = clazz.coord).enteredAfter(thisPhase).asTerm
 
       def forwardToRuntime(vrefss: List[List[Tree]]): Tree =
         ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head)

library/src/scala/Enum.scala

@@ -1,12 +1,8 @@
 package scala
 
 /** A base trait of all enum classes */
-trait Enum {
-  def getDeclaringClass: Class[_]
+trait Enum[E <: Enum[E]] extends Comparable[E] {
+  def getDeclaringClass: Class[E]
   def name: String
   def ordinal: Int
-  def compareTo(that: Enum): Int
-  /** A number uniquely identifying a case of an enum */
-  // def enumTag: Int
-  // def name: String
 }

library/src/scala/runtime/EnumValues.scala

@@ -2,7 +2,7 @@ package scala.runtime
 
 import scala.collection.immutable.Map
 
-class EnumValues[E <: Enum] {
+class EnumValues[E <: Enum[E]] {
   private[this] var myMap: Map[Int, E] = Map()
   private[this] var fromNameCache: Map[String, E] = null