use enumLabel as the canonical name

Author: bishabosha

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

@@ -134,18 +134,18 @@ object DesugarEnums {
   private def enumValueCreator(using Context) = {
     val fieldMethods =
       if isJavaEnum then
-        val productPrefixDef = productPrefixMeth(Select(This(Ident(tpnme.EMPTY)), nme.name))
-        productPrefixDef :: Nil
+        val enumLabelDef = enumLabelMeth(Select(This(Ident(tpnme.EMPTY)), nme.name))
+        enumLabelDef :: Nil
       else
-        val ordinalDef       = ordinalMeth(Ident(nme.ordinalDollar_))
-        val productPrefixDef = productPrefixMeth(Ident(nme.nameDollar))
-        ordinalDef :: productPrefixDef :: Nil
+        val ordinalDef   = ordinalMeth(Ident(nme.ordinalDollar_))
+        val enumLabelDef = enumLabelMeth(Ident(nme.nameDollar))
+        ordinalDef :: enumLabelDef :: Nil
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = fieldMethods ::: registerCall :: Nil
+      body = fieldMethods ::: productPrefixMeth :: registerCall :: Nil
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
@@ -276,14 +276,19 @@ object DesugarEnums {
   def ordinalMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body)
 
-  def productPrefixMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.productPrefix, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
+  def enumLabelMeth(body: Tree)(using Context): DefDef =
+    DefDef(nme.enumLabel, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
+
+  def productPrefixMeth(using Context): DefDef =
+    // TODO: once `scala.Enum` is rebootstrapped and `.valueOf` is implemented in terms of `enumLabel` we can make
+    // `productPrefix` overrideable in SyntheticMembers
+    DefDef(nme.productPrefix, Nil, Nil, TypeTree(defn.StringType), Select(This(EmptyTypeIdent), nme.enumLabel)).withFlags(Override)
 
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
-  def productPrefixLit(name: String)(using Context): DefDef =
-    productPrefixMeth(Literal(Constant(name)))
+  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, span: Span)(using Context): Tree = {
@@ -293,12 +298,12 @@ object DesugarEnums {
       expandSimpleEnumCase(name, mods, span)
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
-      val productPrefixDef   = productPrefixLit(name.toString)
-      val ordinalDef         = if isJavaEnum then Nil else ordinalMethLit(tag) :: Nil
+      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 ::: productPrefixDef :: registerCall :: Nil)
-        .withAttachment(ExtendsSingletonMirror, ())
+        body = ordinalDef ::: enumLabelDef :: productPrefixMeth :: registerCall :: Nil
+      ).withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }

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

@@ -649,6 +649,7 @@ class Definitions {
 
   @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.Enum")
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
+    @tu lazy val Enum_enumLabel: Symbol = EnumClass.requiredMethod(nme.enumLabel)
 
   @tu lazy val EnumValuesClass: ClassSymbol = requiredClass("scala.runtime.EnumValues")
 

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

@@ -453,6 +453,7 @@ 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

@@ -57,7 +57,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   private var myValueSymbols: List[Symbol] = Nil
   private var myCaseSymbols: List[Symbol] = Nil
   private var myCaseModuleSymbols: List[Symbol] = Nil
-  private var myEnumValueSymbols: List[Symbol] = Nil
+  private var myEnumCaseClassSymbols: List[Symbol] = Nil
+  private var myNonJavaEnumValueSymbols: List[Symbol] = Nil
 
   private def initSymbols(using Context) =
     if (myValueSymbols.isEmpty) {
@@ -66,13 +67,15 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement,
         defn.Product_productElementName)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
-      myEnumValueSymbols = List(defn.Any_toString)
+      myEnumCaseClassSymbols = List(defn.Enum_enumLabel)
+      myNonJavaEnumValueSymbols = List(defn.Any_toString)
     }
 
   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 enumValueSymbols(using Context): List[Symbol] = { initSymbols; myEnumValueSymbols }
+  def enumCaseClassSymbols(using Context): List[Symbol] = { initSymbols; myEnumCaseClassSymbols }
+  def nonJavaEnumValueSymbols(using Context): List[Symbol] = { initSymbols; myNonJavaEnumValueSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = {
     val existing = sym.matchingMember(clazz.thisType)
@@ -92,17 +95,15 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
     val isEnumCase = clazz.derivesFrom(defn.EnumClass) && clazz != defn.EnumClass
-    val isNonJavaEnumValue =
-      isEnumCase
-      && clazz.isAnonymousClass
-      && clazz.classParents.head.classSymbol.is(Enum)
-      && !clazz.derivesFrom(defn.JavaEnumClass)
+    val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
+    val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case))
         if (clazz.is(Module)) caseModuleSymbols
+        else if (isEnumCase) caseSymbols ++ enumCaseClassSymbols
         else caseSymbols
-      else if (isNonJavaEnumValue) enumValueSymbols
+      else if (isNonJavaEnumValue) nonJavaEnumValueSymbols
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -122,12 +123,12 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       def ownName: Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))
 
-      def callProductPrefix: Tree =
-        Select(This(clazz), nme.productPrefix).ensureApplied
+      def callEnumLabel: Tree =
+        Select(This(clazz), nme.enumLabel).ensureApplied
 
       def toStringBody(vrefss: List[List[Tree]]): Tree =
         if (clazz.is(ModuleClass)) ownName
-        else if (isNonJavaEnumValue) callProductPrefix
+        else if (isNonJavaEnumValue) callEnumLabel
         else forwardToRuntime(vrefss.head)
 
       def syntheticRHS(vrefss: List[List[Tree]])(using Context): Tree = synthetic.name match {
@@ -137,7 +138,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 => ownName
+        case nme.productPrefix | nme.enumLabel => 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

@@ -175,15 +175,18 @@ 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
-       override def productPrefix = $name
-       override def toString = productPrefix
+       def enumLabel = $name
+       override def productPrefix = enumLabel // if not overridden in `E`
+       override def toString = enumLabel      // if not overridden in `E`
        $values.register(this) // register enum value so that `valueOf` and `values` can return it.
      }
      ```
 
 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`.
+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`.
 
 ### Scopes for Enum Cases
 

docs/docs/reference/enums/enums.md

@@ -119,7 +119,7 @@ package scala
 trait Enum extends Product with Serializable {
 
   /** A string uniquely identifying a case of an enum */
-  final def enumLabel: String = productPrefix
+  def enumLabel: String
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int
@@ -133,8 +133,9 @@ For instance, the `Venus` value above would be defined like this:
 val Venus: Planet =
   new Planet(4.869E24, 6051800.0) {
     def ordinal: Int = 1
-    override def productPrefix: String = "Venus"
-    override def toString: String = productPrefix
+    def enumLabel: String = "Venus"
+    override def productPrefix: String = enumLabel
+    override def toString: String = enumLabel
     // internal code to register value
   }
 ```

library/src-bootstrapped/scala/Enum.scala

@@ -4,7 +4,7 @@ package scala
 trait Enum extends Product, Serializable:
 
   /** A string uniquely identifying a case of an enum */
-  final def enumLabel: String = productPrefix
+  def enumLabel: String
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int

tests/neg/enumsLabelDef.scala

@@ -0,0 +1,6 @@
+enum Labelled {
+  case A // error: cannot override final member method enumLabel in class Labelled
+  case B(arg: Int) // ok: enumLabel has same behaviour here as productPrefix
+
+  override final def enumLabel: String = "nolabel"
+}

tests/pos/enum-List-control.scala

@@ -2,6 +2,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 enumLabel = "Cons"
     def canEqual(that: Any): Boolean = that.isInstanceOf[Cons[_]]
     def productArity: Int = 2
     def productElement(n: Int): Any = n match
@@ -13,6 +14,7 @@ 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()

tests/run/enum-custom-toString.scala

@@ -24,43 +24,80 @@ enum EC: // control case
   case F
   case G(arg: Int)
 
+enum EO:
+  case H
+  case I(arg: Int)
+  // TODO: allow `productPrefix` to be overridden in singleton enum values - until `scala.Enum` is bootstrapped with
+  // `enumLabel`, `runtime.EnumValues` uses `productPrefix` for by-name lookup.
+  override def productPrefix: String = "noprefix"
+end EO
+
+enum EL {
+  case J
+  case K(arg: Int)
+  override def enumLabel: String = "nolabel" // will always be overridden by simple cases
+}
+
+enum EQ[T] {
+  case L extends EQ[Int]
+  override def enumLabel: String = "nolabel" // will always be overridden by value cases
+}
+
 abstract class Tag[T] extends Enum
 object Tag:
   private final class IntTagImpl extends Tag[Int] with runtime.EnumValue:
     def ordinal = 0
+    def enumLabel = "IntTag"
     override def hashCode = 123
   final val IntTag: Tag[Int] = IntTagImpl()
 
 @main def Test =
-  assert(ES.A.toString == "overridden",    s"ES.A.toString = ${ES.A.toString}")
-  assert(ES.A.productPrefix == "A",        s"ES.A.productPrefix = ${ES.A.productPrefix}")
-  assert(ES.A.enumLabel == "A",            s"ES.A.enumLabel = ${ES.A.enumLabel}")
-  assert(ES.valueOf("A") == ES.A,          s"ES.valueOf(A) = ${ES.valueOf("A")}")
-  assert(EJ.B.toString == "overridden",    s"EJ.B.toString = ${EJ.B.toString}")
-  assert(EJ.B.productPrefix == "B",        s"EJ.B.productPrefix = ${EJ.B.productPrefix}")
-  assert(EJ.B.enumLabel == "B",            s"EJ.B.enumLabel = ${EJ.B.enumLabel}")
-  assert(EJ.valueOf("B") == EJ.B,          s"EJ.valueOf(B) = ${EJ.valueOf("B")}")
-  assert(EM.C.toString == "overridden",    s"EM.C.toString = ${EM.C.toString}")
-  assert(EM.C.productPrefix == "C",        s"EM.C.productPrefix = ${EM.C.productPrefix}")
-  assert(EM.C.enumLabel == "C",            s"EM.C.enumLabel = ${EM.C.enumLabel}")
-  assert(EM.valueOf("C") == EM.C,          s"EM.valueOf(C) = ${EM.valueOf("C")}")
-  assert(ET.D.toString == "overridden",    s"ET.D.toString = ${ET.D.toString}")
-  assert(ET.D.productPrefix == "D",        s"ET.D.productPrefix = ${ET.D.productPrefix}")
-  assert(ET.D.enumLabel == "D",            s"ET.D.enumLabel = ${ET.D.enumLabel}")
-  assert(EZ.E(0).toString == "overridden", s"EZ.E(0).toString = ${EZ.E(0).toString}")
-  assert(EZ.E(0).productPrefix == "E",     s"EZ.E(0).productPrefix = ${EZ.E(0).productPrefix}")
-  assert(EZ.E(0).enumLabel == "E",         s"EZ.E(0).enumLabel = ${EZ.E(0).enumLabel}")
-  assert(EC.F.toString == "F",             s"EC.F.toString = ${EC.F.toString}")
-  assert(EC.F.productPrefix == "F",        s"EC.F.productPrefix = ${EC.F.productPrefix}")
-  assert(EC.F.enumLabel == "F",            s"EC.F.enumLabel = ${EC.F.enumLabel}")
-  assert(EC.valueOf("F") == EC.F,          s"EC.valueOf(F) = ${EC.valueOf("F")}")
-  assert(EC.G(0).toString == "G(0)",       s"EC.G(0).toString = ${EC.G(0).toString}")
-  assert(EC.G(0).productPrefix == "G",     s"EC.G(0).productPrefix = ${EC.G(0).productPrefix}")
-  assert(EC.G(0).enumLabel == "G",         s"EC.G(0).enumLabel = ${EC.G(0).enumLabel}")
+  assert(ES.A.toString == "overridden",       s"ES.A.toString = ${ES.A.toString}")
+  assert(ES.A.productPrefix == "A",           s"ES.A.productPrefix = ${ES.A.productPrefix}")
+  assert(ES.A.enumLabel == "A",               s"ES.A.enumLabel = ${ES.A.enumLabel}")
+  assert(ES.valueOf("A") == ES.A,             s"ES.valueOf(A) = ${ES.valueOf("A")}")
+  assert(EJ.B.toString == "overridden",       s"EJ.B.toString = ${EJ.B.toString}")
+  assert(EJ.B.productPrefix == "B",           s"EJ.B.productPrefix = ${EJ.B.productPrefix}")
+  assert(EJ.B.enumLabel == "B",               s"EJ.B.enumLabel = ${EJ.B.enumLabel}")
+  assert(EJ.valueOf("B") == EJ.B,             s"EJ.valueOf(B) = ${EJ.valueOf("B")}")
+  assert(EM.C.toString == "overridden",       s"EM.C.toString = ${EM.C.toString}")
+  assert(EM.C.productPrefix == "C",           s"EM.C.productPrefix = ${EM.C.productPrefix}")
+  assert(EM.C.enumLabel == "C",               s"EM.C.enumLabel = ${EM.C.enumLabel}")
+  assert(EM.valueOf("C") == EM.C,             s"EM.valueOf(C) = ${EM.valueOf("C")}")
+  assert(ET.D.toString == "overridden",       s"ET.D.toString = ${ET.D.toString}")
+  assert(ET.D.productPrefix == "D",           s"ET.D.productPrefix = ${ET.D.productPrefix}")
+  assert(ET.D.enumLabel == "D",               s"ET.D.enumLabel = ${ET.D.enumLabel}")
+  assert(EZ.E(0).toString == "overridden",    s"EZ.E(0).toString = ${EZ.E(0).toString}")
+  assert(EZ.E(0).productPrefix == "E",        s"EZ.E(0).productPrefix = ${EZ.E(0).productPrefix}")
+  assert(EZ.E(0).enumLabel == "E",            s"EZ.E(0).enumLabel = ${EZ.E(0).enumLabel}")
+  assert(EC.F.toString == "F",                s"EC.F.toString = ${EC.F.toString}")
+  assert(EC.F.productPrefix == "F",           s"EC.F.productPrefix = ${EC.F.productPrefix}")
+  assert(EC.F.enumLabel == "F",               s"EC.F.enumLabel = ${EC.F.enumLabel}")
+  assert(EC.valueOf("F") == EC.F,             s"EC.valueOf(F) = ${EC.valueOf("F")}")
+  assert(EC.G(0).toString == "G(0)",          s"EC.G(0).toString = ${EC.G(0).toString}")
+  assert(EC.G(0).productPrefix == "G",        s"EC.G(0).productPrefix = ${EC.G(0).productPrefix}")
+  assert(EC.G(0).enumLabel == "G",            s"EC.G(0).enumLabel = ${EC.G(0).enumLabel}")
+  assert(EO.H.toString == "H",                s"EO.H.toString = ${EO.H.toString}")
+  assert(EO.H.productPrefix == "H",           s"EO.H.productPrefix = ${EO.H.productPrefix}") // TODO: enable override
+  assert(EO.H.enumLabel == "H",               s"EO.H.enumLabel = ${EO.H.enumLabel}")
+  assert(EO.valueOf("H") == EO.H,             s"EO.valueOf(H) = ${EO.valueOf("H")}")
+  assert(EO.I(0).toString == "noprefix(0)",   s"EO.I(0).toString = ${EO.I(0).toString}")
+  assert(EO.I(0).productPrefix == "noprefix", s"EO.I(0).productPrefix = ${EO.I(0).productPrefix}")
+  assert(EO.I(0).enumLabel == "I",            s"EO.I(0).enumLabel = ${EO.I(0).enumLabel}")
+  assert(EL.J.toString == "J",                s"EL.J.toString = ${EL.J.toString}")
+  assert(EL.J.productPrefix == "J",           s"EL.J.productPrefix = ${EL.J.productPrefix}")
+  assert(EL.J.enumLabel == "J",               s"EL.J.enumLabel = ${EL.J.enumLabel}") // can't override label in simple case
+  assert(EL.valueOf("J") == EL.J,             s"EL.valueOf(J) = ${EL.valueOf("J")}")
+  assert(EL.K(0).toString == "K(0)",          s"EL.K(0).toString = ${EL.K(0).toString}")
+  assert(EL.K(0).productPrefix == "K",        s"EL.K(0).productPrefix = ${EL.K(0).productPrefix}")
+  assert(EL.K(0).enumLabel == "nolabel",      s"EL.K(0).enumLabel = ${EL.K(0).enumLabel}") // enum label overridden in class case
+  assert(EQ.L.toString == "L",                s"EQ.L.toString = ${EQ.L.toString}")
+  assert(EQ.L.productPrefix == "L",           s"EQ.L.productPrefix = ${EQ.L.productPrefix}")
+  assert(EQ.L.enumLabel == "L",               s"EQ.L.enumLabel = ${EQ.L.enumLabel}") // can't override label in value case
 
   assert(
     assertion = Tag.IntTag.toString == s"${Tag.IntTag.getClass.getName}@${Integer.toHexString(123)}",
     message   = s"Tag.IntTag.toString = ${Tag.IntTag.toString}"
   )
   assert(Tag.IntTag.productPrefix == Tag.IntTag.toString, s"Tag.IntTag.productPrefix = ${Tag.IntTag.productPrefix}")
-  assert(Tag.IntTag.enumLabel     == Tag.IntTag.toString, s"Tag.IntTag.enumLabel = ${Tag.IntTag.enumLabel}")
+  assert(Tag.IntTag.enumLabel     == "IntTag", s"Tag.IntTag.enumLabel = ${Tag.IntTag.enumLabel}")