Define ordinal and name for enums

Author: anatoliykmetyuk

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

@@ -545,7 +545,11 @@ object desugar {
         yield syntheticProperty(nme.selectorName(i), caseParams(i).tpt,
           Select(This(EmptyTypeIdent), caseParams(i).name))
       }
-      def enumTagMeths = if (isEnumCase) enumTagMeth(CaseKind.Class)._1 :: Nil else Nil
+      def ordinalMeths =
+        if (isEnumCase)
+          ordinalMethLit(nextOrdinal(CaseKind.Class)._1) ::
+          nameMethLit(className.toString) :: Nil
+        else Nil
       def copyMeths = {
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
@@ -582,7 +586,7 @@ object desugar {
       }
 
       if (isCaseClass)
-        productElemNameMeth :: copyMeths ::: enumTagMeths ::: productElemMeths
+        productElemNameMeth :: copyMeths ::: ordinalMeths ::: productElemMeths
       else Nil
     }
 

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

@@ -102,29 +102,27 @@ object DesugarEnums {
 
   /** A creation method for a value of enum type `E`, which is defined as follows:
    *
-   *   private def $new(tag: Int, name: String) = new E {
-   *     def enumTag = tag
+   *   private def $new(tag: Int, name_: String) = new E {
+   *     override def ordinal = tag
+   *     override def name = name_
    *     override def toString = name
    *     $values.register(this)
    *   }
    */
   private def enumValueCreator(implicit ctx: Context) = {
     def param(name: TermName, typ: Type) =
       ValDef(name, TypeTree(typ), EmptyTree).withFlags(Param)
-    val enumTagDef =
-      DefDef(nme.enumTag, Nil, Nil, TypeTree(), Ident(nme.tag))
-    val toStringDef =
-      DefDef(nme.toString_, Nil, Nil, TypeTree(), Ident(nme.name))
-        .withFlags(Override)
+    val ordinalDef = ordinalMeth(Ident(nme.tag))
+    val nameDef = nameMeth(Ident(nme.name_))
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = List(enumTagDef, toStringDef) ++ registerCall
+      body = List(ordinalDef, nameDef, toStringMethAsName) ++ registerCall
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
-        List(List(param(nme.tag, defn.IntType), param(nme.name, defn.StringType))),
+        List(List(param(nme.tag, defn.IntType), param(nme.name_, defn.StringType))),
         TypeTree(), creator).withFlags(Private | Synthetic)
   }
 
@@ -232,7 +230,7 @@ object DesugarEnums {
    *   - scaffolding containing the necessary definitions for singleton enum cases
    *     unless that scaffolding was already generated by a previous call to `nextEnumKind`.
    */
-  def nextEnumTag(kind: CaseKind.Value)(implicit ctx: Context): (Int, List[Tree]) = {
+  def nextOrdinal(kind: CaseKind.Value)(implicit ctx: Context): (Int, List[Tree]) = {
     val (count, seenKind) = ctx.tree.removeAttachment(EnumCaseCount).getOrElse((0, CaseKind.Class))
     val minKind = if (kind < seenKind) kind else seenKind
     ctx.tree.pushAttachment(EnumCaseCount, (count + 1, minKind))
@@ -244,14 +242,23 @@ object DesugarEnums {
     (count, scaffolding)
   }
 
-  /** A pair consisting of
-   *   - a method returning the next enum tag
-   *   - scaffolding as defined in `nextEnumTag`
-   */
-  def enumTagMeth(kind: CaseKind.Value)(implicit ctx: Context): (DefDef, List[Tree]) = {
-    val (tag, scaffolding) = nextEnumTag(kind)
-    (DefDef(nme.enumTag, Nil, Nil, TypeTree(), Literal(Constant(tag))), scaffolding)
-  }
+  def ordinalMeth(body: Tree)(implicit ctx: Context): DefDef =
+    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body).withFlags(Override)
+
+  def nameMeth(body: Tree)(implicit ctx: Context): DefDef =
+    DefDef(nme.name, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
+
+  def toStringMeth(body: Tree)(implicit ctx: Context): DefDef =
+    DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
+
+  def ordinalMethLit(ord: Int)(implicit ctx: Context): DefDef =
+    ordinalMeth(Literal(Constant(ord)))
+
+  def nameMethLit(name: String)(implicit ctx: Context): DefDef =
+    nameMeth(Literal(Constant(name)))
+
+  def toStringMethAsName(implicit ctx: Context): DefDef =
+    toStringMeth(Ident(nme.name))
 
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, span: Span)(implicit ctx: Context): Tree = {
@@ -260,11 +267,10 @@ object DesugarEnums {
     else if (impl.parents.isEmpty)
       expandSimpleEnumCase(name, mods, span)
     else {
-      def toStringMeth =
-        DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), Literal(Constant(name.toString)))
-          .withFlags(Override)
-      val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
-      val impl1 = cpy.Template(impl)(body = List(tagMeth, toStringMeth) ++ registerCall)
+      val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
+      val ordinalDef = ordinalMethLit(tag)
+      val nameDef = nameMethLit(name.toString)
+      val impl1 = cpy.Template(impl)(body = List(ordinalDef, nameDef, toStringMethAsName) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
@@ -280,7 +286,7 @@ object DesugarEnums {
       expandEnumModule(name, impl, mods, span)
     }
     else {
-      val (tag, scaffolding) = nextEnumTag(CaseKind.Simple)
+      val (tag, scaffolding) = nextOrdinal(CaseKind.Simple)
       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/StdNames.scala

@@ -420,7 +420,6 @@ object StdNames {
     val elems: N                = "elems"
     val emptyValDef: N          = "emptyValDef"
     val ensureAccessible : N    = "ensureAccessible"
-    val enumTag: N              = "enumTag"
     val eq: N                   = "eq"
     val eqInstance: N           = "eqInstance"
     val equalsNumChar : N       = "equalsNumChar"
@@ -485,6 +484,7 @@ object StdNames {
     val mirror : N              = "mirror"
     val moduleClass : N         = "moduleClass"
     val name: N                 = "name"
+    val name_ : N               = "name_"
     val ne: N                   = "ne"
     val newFreeTerm: N          = "newFreeTerm"
     val newFreeType: N          = "newFreeType"

library/src/scala/Enum.scala

@@ -4,5 +4,8 @@ package scala
 trait Enum {
 
   /** A number uniquely identifying a case of an enum */
-  def enumTag: Int
+  def ordinal: Int
+
+  /** Name of the enum's case */
+  def name: String
 }

library/src/scala/runtime/EnumValues.scala

@@ -7,8 +7,8 @@ class EnumValues[E <: Enum] {
   private[this] var fromNameCache: Map[String, E] = null
 
   def register(v: E) = {
-    require(!myMap.contains(v.enumTag))
-    myMap = myMap.updated(v.enumTag, v)
+    require(!myMap.contains(v.ordinal))
+    myMap = myMap.updated(v.ordinal, v)
     fromNameCache = null
   }