remove dollarordinal from Enum, reduce bytecode

Author: bishabosha

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

@@ -125,7 +125,8 @@ object DesugarEnums {
   /** A creation method for a value of enum type `E`, which is defined as follows:
    *
    *   private def $new(_$ordinal: Int, $name: String) = new E with scala.runtime.EnumValue {
-   *     def $ordinal = $tag
+   *     private[this] def $ordinal = _$ordinal // if deriving from jl.Enum
+   *     def ordinal = _$ordinal                // if not deriving from jl.Enum
    *     override def toString = $name
    *     $values.register(this)
    *   }
@@ -265,7 +266,9 @@ object DesugarEnums {
     ValDef(name, TypeTree(typ), EmptyTree).withFlags(Param)
 
   def ordinalMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.ordinalDollar, Nil, Nil, TypeTree(defn.IntType), body)
+    val isJEnum = ctx.owner.linkedClass.derivesFrom(defn.JavaEnumClass)
+    val method = DefDef(if isJEnum then nme.ordinalDollar else nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body)
+    if isJEnum then method.withMods(Modifiers(Private)) else method
 
   def toStringMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)

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

@@ -40,6 +40,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
          sym == defn.JavaEnumClass.primaryConstructor ||
          sym.owner.derivesFromJavaEnum))
       addConstrParams(sym.info)
+      // TODO: remove $ordinal and toString override from decls
     else tp
 
   /** Add constructor parameters `$name: String` and `$ordinal: Int` to the end of
@@ -63,8 +64,8 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    *  with given flags (either `Param` or `ParamAccessor`)
    */
   private def addedParams(owner: Symbol, flag: FlagSet)(using Context): List[ValDef] = {
-    val nameParam = newSymbol(owner, nameParamName, flag | Synthetic, defn.StringType, coord = owner.span)
-    val ordinalParam = newSymbol(owner, ordinalParamName, flag | Synthetic, defn.IntType, coord = owner.span)
+    val nameParam = newSymbol(owner, nameParamName, flag | Synthetic | Private | Local, defn.StringType, coord = owner.span)
+    val ordinalParam = newSymbol(owner, ordinalParamName, flag | Synthetic | Private | Local, defn.IntType, coord = owner.span)
     List(ValDef(nameParam), ValDef(ordinalParam))
   }
 
@@ -146,7 +147,11 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
         }.head
       val args = List(rhsOf(nme.toString_), rhsOf(nme.ordinalDollar))
       cpy.Template(templ)(
-        parents = addEnumConstrArgs(cls.owner.owner.linkedClass, templ.parents, args))
+        parents = addEnumConstrArgs(cls.owner.owner.linkedClass, templ.parents, args),
+        body = templ.body.filterNot {
+          case ddef: NamedDefTree => ddef.name == nme.toString_ || ddef.name == nme.ordinalDollar
+          case _ => false
+        })
     }
     else templ
   }

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

@@ -57,7 +57,6 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   private var myValueSymbols: List[Symbol] = Nil
   private var myCaseSymbols: List[Symbol] = Nil
   private var myCaseModuleSymbols: List[Symbol] = Nil
-  private var myEnumCaseSymbols: List[Symbol] = Nil
 
   private def initSymbols(using Context) =
     if (myValueSymbols.isEmpty) {
@@ -66,13 +65,11 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement,
         defn.Product_productElementName)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
-      myEnumCaseSymbols = List(defn.Enum_ordinal)
     }
 
   def valueSymbols(using Context): List[Symbol] = { initSymbols; myValueSymbols }
   def caseSymbols(using Context): List[Symbol] = { initSymbols; myCaseSymbols }
   def caseModuleSymbols(using Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
-  def enumCaseSymbols(using Context): List[Symbol] = { initSymbols; myEnumCaseSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = {
     val existing = sym.matchingMember(clazz.thisType)
@@ -96,9 +93,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     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
 
@@ -128,7 +123,6 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case nme.productPrefix => ownName
         case nme.productElement => productElementBody(accessors.length, vrefss.head.head)
         case nme.productElementName => productElementNameBody(accessors.length, vrefss.head.head)
-        case nme.ordinal => Select(This(clazz), nme.ordinalDollar)
       }
       report.log(s"adding $synthetic to $clazz at ${ctx.phase}")
       synthesizeDef(synthetic, syntheticRHS)

docs/docs/reference/enums/desugarEnums.md

@@ -36,8 +36,8 @@ map into `case class`es or `val`s.
    ```
    expands to a `sealed abstract` class that extends the `scala.Enum` trait and
    an associated companion object that contains the defined cases, expanded according
-   to rules (2 - 8). The enum trait starts with a compiler-generated import that imports
-   the names `<caseIds>` of all cases so that they can be used without prefix in the trait.
+   to rules (2 - 8). The enum class starts with a compiler-generated import that imports
+   the names `<caseIds>` of all cases so that they can be used without prefix in the class.
    ```scala
    sealed abstract class E ... extends <parents> with scala.Enum {
      import E.{ <caseIds> }

library/src-bootstrapped/scala/Enum.scala

@@ -5,5 +5,3 @@ trait Enum extends Product, Serializable:
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int
-  protected def $ordinal: Int
-

library/src-non-bootstrapped/scala/Enum.scala

@@ -1,7 +1,7 @@
 package scala
 
 /** A base trait of all enum classes */
-trait Enum:
+trait Enum extends Product, Serializable:
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int