Synthetically generated oridnal method for enums

Author: anatoliykmetyuk

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

@@ -142,9 +142,9 @@ object DesugarEnums {
       body = List(ordinalDef, toStringDef) ++ registerCall
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
-        List(List(param(nme.nameDollar, defn.StringType), param(nme.ordinalDollar_, defn.IntType))),
+        List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
         TypeTree(), creator).withFlags(Private | Synthetic)
-  }.reporting(e => s"marker\n${e.show}")
+  }
 
   /** The return type of an enum case apply method and any widening methods in which
    *  the apply's right hand side will be wrapped. For parents of the form
@@ -304,7 +304,7 @@ object DesugarEnums {
     }
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Simple)
-      val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(name.toString)), Literal(Constant(tag))))
+      val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
       val vdef = ValDef(name, enumClassRef, creator).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }

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

@@ -678,6 +678,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 Enum_ordinalR: TermRef = EnumClass.requiredMethodRef(nme.ordinal)
+    def Enum_ordinal(implicit ctx: Context): Symbol = Enum_ordinalR.symbol
   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")

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

@@ -16,8 +16,8 @@ import DenotTransformers._
 object CompleteJavaEnums {
   val name: String = "completeJavaEnums"
 
-  private val nameParamName: TermName = "$name".toTermName
-  private val ordinalParamName: TermName = "$ordinal".toTermName
+  private val nameParamName: TermName = "_$name".toTermName
+  private val ordinalParamName: TermName = "_$ordinal".toTermName
 }
 
 /** For Scala enums that inherit from java.lang.Enum:
@@ -152,7 +152,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
         templ.body.collect {
           case mdef: DefDef if mdef.name == name => mdef.rhs
         }.head
-      val args = List(rhsOf(nme.toString_), rhsOf(nme.ordinal))
+      val args = List(rhsOf(nme.toString_), rhsOf(nme.ordinalDollar))
       cpy.Template(templ)(
         parents = addEnumConstrArgs(cls.owner.owner.linkedClass, templ.parents, args))
     }

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

@@ -56,18 +56,21 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   private[this] var myValueSymbols: List[Symbol] = Nil
   private[this] var myCaseSymbols: List[Symbol] = Nil
   private[this] var myCaseModuleSymbols: List[Symbol] = Nil
+  private[this] var myEnumCaseSymbols: List[Symbol] = Nil
 
   private def initSymbols(implicit ctx: Context) =
     if (myValueSymbols.isEmpty) {
       myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
       myCaseSymbols = myValueSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
+      myEnumCaseSymbols = List(defn.Enum_ordinal) 
     }
 
   def valueSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myValueSymbols }
   def caseSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseSymbols }
   def caseModuleSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
+  def enumCaseSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myEnumCaseSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(implicit ctx: Context): Symbol = {
     val existing = sym.matchingMember(clazz.thisType)
@@ -86,12 +89,15 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     lazy val accessors =
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
+    val isEnumCase = clazz.derivesFrom(defn.EnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case)) {
         if (clazz.is(Module)) caseModuleSymbols
+        else if (isEnumCase) caseSymbols ++ enumCaseSymbols
         else caseSymbols
       }
+      else if (isEnumCase) enumCaseSymbols
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -120,6 +126,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case nme.productArity => Literal(Constant(accessors.length))
         case nme.productPrefix => ownName
         case nme.productElement => productElementBody(accessors.length, vrefss.head.head)
+        case nme.ordinal => Select(This(clazz), nme.ordinalDollar)
       }
       ctx.log(s"adding $synthetic to $clazz at ${ctx.phase}")
       synthesizeDef(synthetic, syntheticRHS)
@@ -362,7 +369,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
 
   /** For an enum T:
    *
-   *     def ordinal(x: MirroredMonoType) = x.ordinal
+   *     def ordinal(x: MirroredMonoType) = x.$ordinal
    *
    *  For  sealed trait with children of normalized types C_1, ..., C_n:
    *
@@ -377,7 +384,13 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  O is O.type.
    */
   def ordinalBody(cls: Symbol, param: Tree)(implicit ctx: Context): Tree =
-    if (cls.is(Enum)) Apply(param.select(nme.ordinal), Nil)
+    if (cls.is(Enum)) {
+      val ordinalMeth = param.select(nme.ordinal)
+      val derivesFromJEnum =
+        cls.is(Enum, butNot = Case) &&
+        cls.info.parents.exists(p => p.typeSymbol == defn.JEnumClass)
+      if (derivesFromJEnum) Apply(ordinalMeth, Nil) else ordinalMeth
+    }
     else {
       val cases =
         for ((child, idx) <- cls.children.zipWithIndex) yield {

tests/run/enums-java-compat.scala

@@ -1,6 +1,5 @@
 class JEnum {
   def name: String = "Foo"
-  def ordinal: Int = 10
   def action = "fofofo"
 }