Merge pull request #9989 from dotty-staging/topic/enum-dropEnumLabel

Drop enumLabel method from enums

Author: bishabosha

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

@@ -594,7 +594,7 @@ object desugar {
       def enumCaseMeths =
         if isEnumCase then
           val (ordinal, scaffolding) = nextOrdinal(className, CaseKind.Class, definesEnumLookupMethods(cdef))
-          (ordinalMethLit(ordinal) :: enumLabelLit(className.toString) :: Nil, scaffolding)
+          (ordinalMethLit(ordinal) :: Nil, scaffolding)
         else (Nil, Nil)
       def copyMeths = {
         val hasRepeatedParam = constrVparamss.nestedExists {

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

@@ -175,20 +175,11 @@ 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 = _$ordinal   // if `E` does not derive from `java.lang.Enum`
-   *     def enumLabel = $name     // if `E` does not derive from `java.lang.Enum`
-   *     def enumLabel = this.name // if `E` derives from `java.lang.Enum`
+   *     def ordinal = _$ordinal // if `E` does not derive from `java.lang.Enum`
    *   }
    */
   private def enumValueCreator(using Context) = {
-    val fieldMethods =
-      if isJavaEnum then
-        val enumLabelDef = enumLabelMeth(Select(This(Ident(tpnme.EMPTY)), nme.name))
-        enumLabelDef :: Nil
-      else
-        val ordinalDef   = ordinalMeth(Ident(nme.ordinalDollar_))
-        val enumLabelDef = enumLabelMeth(Ident(nme.nameDollar))
-        ordinalDef :: enumLabelDef :: Nil
+    val fieldMethods = if isJavaEnum then Nil else ordinalMeth(Ident(nme.ordinalDollar_)) :: Nil
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
@@ -284,15 +275,9 @@ object DesugarEnums {
   def ordinalMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body).withAddedFlags(Synthetic)
 
-  def enumLabelMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.enumLabel, Nil, Nil, TypeTree(defn.StringType), body).withAddedFlags(Synthetic)
-
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
-  def enumLabelLit(name: String)(using Context): DefDef =
-    enumLabelMeth(Literal(Constant(name)))
-
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, definesLookups: Boolean, span: Span)(using Context): Tree = {
     assert(impl.body.isEmpty)
@@ -301,11 +286,9 @@ object DesugarEnums {
       expandSimpleEnumCase(name, mods, definesLookups, span)
     else {
       val (tag, scaffolding) = nextOrdinal(name, CaseKind.Object, definesLookups)
-      val ordinalDef   = if isJavaEnum then Nil else ordinalMethLit(tag) :: Nil
-      val enumLabelDef = enumLabelLit(name.toString)
       val impl1 = cpy.Template(impl)(
         parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
-        body = ordinalDef ::: enumLabelDef :: Nil
+        body = if isJavaEnum then Nil else ordinalMethLit(tag) :: Nil
       ).withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(vdef :: scaffolding).withSpan(span)

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

@@ -456,7 +456,6 @@ object StdNames {
     val emptyValDef: N          = "emptyValDef"
     val end: N                  = "end"
     val ensureAccessible : N    = "ensureAccessible"
-    val enumLabel: N            = "enumLabel"
     val eq: N                   = "eq"
     val eqInstance: N           = "eqInstance"
     val equalsNumChar : N       = "equalsNumChar"

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

@@ -95,7 +95,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
     val isEnumValue = clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
-    val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
+    val isSimpleEnumValue = isEnumValue && !clazz.owner.isAllOf(EnumCase)
+    val isJavaEnumValue = isEnumValue && clazz.derivesFrom(defn.JavaEnumClass)
+    val isNonJavaEnumValue = isEnumValue && !isJavaEnumValue
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case))
@@ -122,12 +124,21 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       def ownName: Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))
 
-      def callEnumLabel: Tree =
-        Select(This(clazz), nme.enumLabel).ensureApplied
+      def nameRef: Tree =
+        if isJavaEnumValue then
+          Select(This(clazz), nme.name).ensureApplied
+        else
+          identifierRef
+
+      def identifierRef: Tree =
+        if isSimpleEnumValue then // owner is `def $new(_$ordinal: Int, $name: String) = new MyEnum { ... }`
+          ref(clazz.owner.paramSymss.head.find(_.name == nme.nameDollar).get)
+        else // assume owner is `val Foo = new MyEnum { def ordinal = 0 }`
+          Literal(Constant(clazz.owner.name.toString))
 
       def toStringBody(vrefss: List[List[Tree]]): Tree =
         if (clazz.is(ModuleClass)) ownName
-        else if (isNonJavaEnumValue) callEnumLabel
+        else if (isNonJavaEnumValue) identifierRef
         else forwardToRuntime(vrefss.head)
 
       def syntheticRHS(vrefss: List[List[Tree]])(using Context): Tree = synthetic.name match {
@@ -137,7 +148,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case nme.equals_ => equalsBody(vrefss.head.head)
         case nme.canEqual_ => canEqualBody(vrefss.head.head)
         case nme.productArity => Literal(Constant(accessors.length))
-        case nme.productPrefix if isEnumValue => callEnumLabel
+        case nme.productPrefix if isEnumValue => nameRef
         case nme.productPrefix => ownName
         case nme.productElement => productElementBody(accessors.length, vrefss.head.head)
         case nme.productElementName => productElementNameBody(accessors.length, vrefss.head.head)

docs/docs/reference/enums/desugarEnums.md

@@ -34,12 +34,12 @@ map into `case class`es or `val`s.
    ```scala
    enum E ... { <defs> <cases> }
    ```
-   expands to a `sealed abstract` class that extends the `scala.Enum` trait and
+   expands to a `sealed abstract` class that extends the `scala.reflect.Enum` trait and
    an associated companion object that contains the defined cases, expanded according
    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 {
+   sealed abstract class E ... extends <parents> with scala.reflect.Enum {
      import E.{ <caseIds> }
       <defs>
    }
@@ -165,7 +165,7 @@ An enum `E` (possibly generic) that defines one or more singleton cases
 will define the following additional synthetic members in its companion object (where `E'` denotes `E` with
 any type parameters replaced by wildcards):
 
-   - A method `valueOf(name: String): E'`. It returns the singleton case value whose `enumLabel` is `name`.
+   - A method `valueOf(name: String): E'`. It returns the singleton case value whose identifier is `name`.
    - A method `values` which returns an `Array[E']` of all singleton case
      values defined by `E`, in the order of their definitions.
 
@@ -177,17 +177,16 @@ If `E` contains at least one simple case, its companion object will define in ad
      ```scala
      private def $new(_$ordinal: Int, $name: String) = new E with runtime.EnumValue {
        def ordinal = _$ordinal
-       def enumLabel = $name
-       override def productPrefix = enumLabel // if not overridden in `E`
-       override def toString = enumLabel      // if not overridden in `E`
+       override def productPrefix = $name // if not overridden in `E`
+       override def toString = $name      // if not overridden in `E`
      }
      ```
 
 The anonymous class also implements the abstract `Product` methods that it inherits from `Enum`.
 The `ordinal` method is only generated if the enum does not extend from `java.lang.Enum` (as Scala enums do not extend
 `java.lang.Enum`s unless explicitly specified). In case it does, there is no need to generate `ordinal` as
 `java.lang.Enum` defines it. Similarly there is no need to override `toString` as that is defined in terms of `name` in
-`java.lang.Enum`. Finally, `enumLabel` will call `this.name` when `E` extends `java.lang.Enum`.
+`java.lang.Enum`. Finally, `productPrefix` will call `this.name` when `E` extends `java.lang.Enum`.
 
 ### Scopes for Enum Cases
 

docs/docs/reference/enums/enums.md

@@ -110,17 +110,14 @@ For a more in-depth example of using Scala 3 enums from Java, see [this test](ht
 ### Implementation
 
 Enums are represented as `sealed` classes that extend the `scala.reflect.Enum` trait.
-This trait defines two public methods, `ordinal` and `enumLabel`:
+This trait defines a single public method, `ordinal`:
 
 ```scala
 package scala.reflect
 
 /** A base trait of all Scala enum definitions */
 super trait Enum extends Any with Product with Serializable {
 
-  /** A string uniquely identifying a case of an enum */
-  def enumLabel: String
-
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int
 }
@@ -133,9 +130,8 @@ For instance, the `Venus` value above would be defined like this:
 val Venus: Planet =
   new Planet(4.869E24, 6051800.0) {
     def ordinal: Int = 1
-    def enumLabel: String = "Venus"
-    override def productPrefix: String = enumLabel
-    override def toString: String = enumLabel
+    override def productPrefix: String = "Venus"
+    override def toString: String = "Venus"
   }
 ```
 

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

@@ -3,8 +3,5 @@ package scala.reflect
 /** A base trait of all Scala enum definitions */
 super trait Enum extends Any, Product, Serializable:
 
-  /** A string uniquely identifying a case of an enum */
-  def enumLabel: String
-
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int

tests/neg/enumsLabel-overrides.scala

@@ -1,15 +1,13 @@
-enum Labelled {
-
-  case A // error: method enumLabel of type => String needs `override` modifier
-
-  def enumLabel: String = "nolabel"
-
-}
-
 enum Ordinalled {
 
   case A // error: method ordinal of type => Int needs `override` modifier
 
   def ordinal: Int = -1
 
 }
+
+trait HasOrdinal { def ordinal: Int = 23 }
+
+enum MyEnum extends HasOrdinal {
+  case Foo // error: method ordinal of type => Int needs `override` modifier
+}

tests/neg/enumsLabel-singleimpl.scala

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