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,10 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
          sym == defn.JavaEnumClass.primaryConstructor ||
          sym.owner.derivesFromJavaEnum))
       addConstrParams(sym.info)
+    else if isJavaEnumValueImpl(sym) then
+      sym.asClass.delete(tp.decl(nme.toString_).symbol)
+      sym.asClass.delete(tp.decl(nme.ordinalDollar).symbol)
+      tp
     else tp
 
   /** Add constructor parameters `$name: String` and `$ordinal: Int` to the end of
@@ -62,9 +66,10 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
   /** The list of parameter definitions `$name: String, $ordinal: Int`, in given `owner`
    *  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)
+  private def addedParams(owner: Symbol, isLocal: Boolean, flag: FlagSet)(using Context): List[ValDef] = {
+    val flags = flag | Synthetic | (if isLocal then Private | Deferred else EmptyFlags)
+    val nameParam = newSymbol(owner, nameParamName, flags, defn.StringType, coord = owner.span)
+    val ordinalParam = newSymbol(owner, ordinalParamName, flags, defn.IntType, coord = owner.span)
     List(ValDef(nameParam), ValDef(ordinalParam))
   }
 
@@ -85,7 +90,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
     val sym = tree.symbol
     if (sym.isConstructor && sym.owner.derivesFromJavaEnum)
       val tree1 = cpy.DefDef(tree)(
-        vparamss = tree.vparamss.init :+ (tree.vparamss.last ++ addedParams(sym, Param)))
+        vparamss = tree.vparamss.init :+ (tree.vparamss.last ++ addedParams(sym, isLocal=false, Param)))
       sym.setParamssFromDefs(tree1.tparams, tree1.vparamss)
       tree1
     else tree
@@ -107,6 +112,11 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
     }
   }
 
+  private def isJavaEnumValueImpl(cls: Symbol)(using Context): Boolean =
+    cls.isAnonymousClass
+    && ((cls.owner.name eq nme.DOLLAR_NEW) || cls.owner.isAllOf(EnumCase))
+    && cls.owner.owner.linkedClass.derivesFromJavaEnum
+
   /** 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.
    *
@@ -116,38 +126,39 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    *
    *       class $anon extends E(...) {
    *          ...
-   *          def ordinal = N
-   *          def toString = S
+   *          private def $ordinal = N
+   *          override def toString = S
    *          ...
    *       }
    *
    *     After the transform it is expanded to
    *
    *       class $anon extends E(..., N, S) {
-   *         "same as before"
+   *          ...
+   *          "removed $ordinal and toString"
+   *          ...
    *       }
    */
   override def transformTemplate(templ: Template)(using Context): Template = {
     val cls = templ.symbol.owner
-    if (cls.derivesFromJavaEnum) {
+    if cls.derivesFromJavaEnum then
       val (params, rest) = decomposeTemplateBody(templ.body)
-      val addedDefs = addedParams(cls, ParamAccessor)
+      val addedDefs = addedParams(cls, isLocal=true, ParamAccessor)
       val addedSyms = addedDefs.map(_.symbol.entered)
       val addedForwarders = addedEnumForwarders(cls)
       cpy.Template(templ)(
         parents = addEnumConstrArgs(defn.JavaEnumClass, templ.parents, addedSyms.map(ref)),
         body = params ++ addedDefs ++ addedForwarders ++ rest)
-    }
-    else if (cls.isAnonymousClass && ((cls.owner.name eq nme.DOLLAR_NEW) || cls.owner.isAllOf(EnumCase)) &&
-             cls.owner.owner.linkedClass.derivesFromJavaEnum) {
+    else if isJavaEnumValueImpl(cls) then
       def rhsOf(name: TermName) =
-        templ.body.collect {
-          case mdef: DefDef if mdef.name == name => mdef.rhs
-        }.head
+        templ.body.collect({ case mdef: DefDef if mdef.name == name => mdef.rhs }).head
+      def removeDefs(body: List[Tree], names: TermName*) =
+        body.filterNot { case ndef: DefDef => names.contains(ndef.name); case _ => false }
       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    = removeDefs(templ.body, nme.toString_, nme.ordinalDollar)
+      )
     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

tests/pos/enum-List-control.scala

@@ -1,7 +1,7 @@
 abstract sealed class List[T] extends Enum
 object List {
   final class Cons[T](x: T, xs: List[T]) extends List[T] {
-    def $ordinal = 0
+    def ordinal = 0
     def canEqual(that: Any): Boolean = that.isInstanceOf[Cons[_]]
     def productArity: Int = 2
     def productElement(n: Int): Any = n match
@@ -12,7 +12,7 @@ object List {
     def apply[T](x: T, xs: List[T]): List[T] = new Cons(x, xs)
   }
   final class Nil[T]() extends List[T], runtime.EnumValue {
-    def $ordinal = 1
+    def ordinal = 1
   }
   object Nil {
     def apply[T](): List[T] = new Nil()