Name removed from enum

Author: anatoliykmetyuk

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

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

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

@@ -87,8 +87,8 @@ object DesugarEnums {
   /**  The following lists of definitions for an enum type E:
    *
    *   private val $values = new EnumValues[E]
-   *   def valueOf(name: String) =
-   *     try $values.fromName(name) catch
+   *   def valueOf($name: String) =
+   *     try $values.fromName($name) catch
    *       {
    *         case ex$:NoSuchElementException =>
    *           throw new IllegalArgumentException("key not found: ".concat(name))
@@ -105,17 +105,17 @@ object DesugarEnums {
 
     val valuesOfExnMessage = Apply(
       Select(Literal(Constant("key not found: ")), "concat".toTermName)
-    , Ident(nme.name) :: Nil)
+    , Ident(nme.nameDollar) :: Nil)
     val valuesOfBody = Try(
-      expr = Apply(valuesDot("fromName"), Ident(nme.name) :: Nil)
+      expr = Apply(valuesDot("fromName"), Ident(nme.nameDollar) :: Nil)
     , cases = CaseDef(
         pat = Typed(Ident(nme.DEFAULT_EXCEPTION_NAME), TypeTree(defn.NoSuchElementExceptionType))
       , guard = EmptyTree
       , body = Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(valuesOfExnMessage :: Nil)))
       ) :: Nil
     , finalizer = EmptyTree
     )
-    val valueOfDef = DefDef(nme.valueOf, Nil, List(param(nme.name, defn.StringType) :: Nil),
+    val valueOfDef = DefDef(nme.valueOf, Nil, List(param(nme.nameDollar, defn.StringType) :: Nil),
       TypeTree(), valuesOfBody)
 
     valuesDef ::
@@ -125,25 +125,24 @@ 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 {
-   *     override def ordinal = tag
-   *     override def name = name_
-   *     override def toString = name
+   *   private def $new($tag: Int, $name: String) = new E {
+   *     override def ordinal = $tag
+   *     override def toString = $name
    *     $values.register(this)
    *   }
    */
   private def enumValueCreator(implicit ctx: Context) = {
-    val ordinalDef = ordinalMeth(Ident(nme.tag))
-    val nameDef = nameMeth(Ident(nme.name_))
+    val ordinalDef = ordinalMeth(Ident(nme.tagDollar))
+    val toStringDef = toStringMeth(Ident(nme.nameDollar))
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = List(ordinalDef, nameDef, toStringMethAsName) ++ registerCall
+      body = List(ordinalDef, toStringDef) ++ registerCall
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
-        List(List(param(nme.tag, defn.IntType), param(nme.name_, defn.StringType))),
+        List(List(param(nme.tagDollar, defn.IntType), param(nme.nameDollar, defn.StringType))),
         TypeTree(), creator).withFlags(Private | Synthetic)
   }
 
@@ -269,20 +268,14 @@ object DesugarEnums {
   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))
+  def toStringMethLit(name: String)(implicit ctx: Context): DefDef =
+    toStringMeth(Literal(Constant(name)))
 
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, span: Span)(implicit ctx: Context): Tree = {
@@ -293,8 +286,8 @@ object DesugarEnums {
     else {
       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)
+      val toStringDef = toStringMethLit(name.toString)
+      val impl1 = cpy.Template(impl)(body = List(ordinalDef, toStringDef) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)

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

@@ -484,7 +484,7 @@ object StdNames {
     val mirror : N              = "mirror"
     val moduleClass : N         = "moduleClass"
     val name: N                 = "name"
-    val name_ : N               = "name_"
+    val nameDollar: N           = "$name"
     val ne: N                   = "ne"
     val newFreeTerm: N          = "newFreeTerm"
     val newFreeType: N          = "newFreeType"
@@ -539,6 +539,7 @@ object StdNames {
     val strictEquality: N       = "strictEquality"
     val synchronized_ : N       = "synchronized"
     val tag: N                  = "tag"
+    val tagDollar: N            = "$tag"
     val tail: N                 = "tail"
     val `then` : N              = "then"
     val this_ : N               = "this"

library/src/scala/Enum.scala

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

tests/pos-with-compiler/tasty/definitions.scala

@@ -65,13 +65,13 @@ object definitions {
   /** Trees denoting terms */
   enum Term extends Statement {
     def tpe: Type = ???
-    case Ident(nme: String, override val tpe: Type)
-    case Select(prefix: Term, nme: String, signature: Option[Signature])
+    case Ident(name: String, override val tpe: Type)
+    case Select(prefix: Term, name: String, signature: Option[Signature])
     case Literal(value: Constant)
     case This(id: Option[Id])
     case New(tpt: TypeTree)
     case Throw(expr: Term)
-    case NamedArg(nme: String, arg: Term)
+    case NamedArg(name: String, arg: Term)
     case Apply(fn: Term, args: List[Term])
     case TypeApply(fn: Term, args: List[TypeTree])
     case Super(thiz: Term, mixin: Option[Id])
@@ -94,9 +94,9 @@ object definitions {
   enum TypeTree extends Positioned {
     def tpe: Type = ???
     case Synthetic()
-    case Ident(nme: String, override val tpe: Type)
-    case TermSelect(prefix: Term, nme: String)
-    case TypeSelect(prefix: TypeTree, nme: String)
+    case Ident(name: String, override val tpe: Type)
+    case TermSelect(prefix: Term, name: String)
+    case TypeSelect(prefix: TypeTree, name: String)
     case Singleton(ref: Term)
     case Refined(underlying: TypeTree, refinements: List[Definition])
     case Applied(tycon: TypeTree, args: List[TypeTree | TypeBoundsTree])
@@ -105,7 +105,7 @@ object definitions {
     case Or(left: TypeTree, right: TypeTree)
     case ByName(tpt: TypeTree)
     case TypeLambda(tparams: List[TypeDef], body: Type | TypeBoundsTree)
-    case Bind(nme: String, bounds: TypeBoundsTree)
+    case Bind(name: String, bounds: TypeBoundsTree)
   }
 
   /** Trees denoting type bounds */
@@ -122,7 +122,7 @@ object definitions {
   enum Pattern extends Positioned {
     def tpe: Type = ???
     case Value(v: Term)
-    case Bind(nme: String, pat: Pattern)
+    case Bind(name: String, pat: Pattern)
     case Unapply(unapply: Term, implicits: List[Term], pats: List[Pattern])
     case Alternative(pats: List[Pattern])
     case TypeTest(tpt: TypeTree)

tests/pos/enum-List-control.scala

@@ -2,14 +2,12 @@ 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 name = "Cons"
   }
   object Cons {
     def apply[T](x: T, xs: List[T]): List[T] = new Cons(x, xs)
   }
   final class Nil[T]() extends List[T] {
     def ordinal = 1
-    def name = "Nil"
   }
   object Nil {
     def apply[T](): List[T] = new Nil()

tests/run/enum-Color.scala

@@ -6,8 +6,8 @@ enum Color {
 object Test {
   def main(args: Array[String]) =
     for (color <- Color.values) {
-      println(s"$color: ${color.name}")
-      assert(Color.valueOf(color.name) eq color)
+      println(s"$color: ${color.toString}")
+      assert(Color.valueOf(color.toString) eq color)
       import Color._
       color match {
         case Red | Green | Blue =>

tests/run/enums-java-compat.check

@@ -1,4 +1,3 @@
-name:     EARTH
 ordinal:  0
 toString: EARTH
 Values class: class [LA;

tests/run/enums-java-compat.scala

@@ -0,0 +1,41 @@
+class JEnum {
+  def name: String = "Foo"
+  def ordinal: Int = 10
+  def action = "fofofo"
+}
+
+enum A extends JEnum {
+  case MONDAY, TUESDAY, SATURDAY
+  case Stuff
+  case Someday(x: String)
+  def report = "Reported"
+}
+
+trait Foo1
+trait Bar
+
+enum B(val gravity: Double)(val isItGood: Boolean) extends Foo1 {
+  case EARTH extends B(9.8)(true)
+  case JUPITER extends B(100)(true)
+  case MOON extends B(4.3)(true)
+  case Foo extends B(10)(true) with Bar
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val t1 = B.EARTH
+    val t2 = B.JUPITER
+
+    println("ordinal:  " + t1.ordinal)
+    println("toString: " + t1.toString)
+
+    val values: Array[A] = A.values
+    println("Values class: " + values.getClass)
+    values.foreach(v => println(v.toString + " : " + v.ordinal))
+    println("By-name value: " + A.valueOf("MONDAY"))
+    try A.valueOf("stuff")
+    catch { case e: IllegalArgumentException =>
+      println("Correctly failed to retrieve illegal name, message: " + e.getMessage)
+    }
+  }
+}