Method stabs for enums at SyntheticMethods

Author: anatoliykmetyuk

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

@@ -544,7 +544,7 @@ 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) ordinalMeth(CaseKind.Class)._1 :: Nil else Nil
       def copyMeths = {
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
@@ -581,7 +581,7 @@ object desugar {
       }
 
       if (isCaseClass)
-        productElemNameMeth :: copyMeths ::: enumTagMeths ::: productElemMeths
+        productElemNameMeth :: copyMeths ::: ordinalMeths ::: productElemMeths
       else Nil
     }
 

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

@@ -102,21 +102,21 @@ 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
+   *     def ordinal = tag
    *     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 ordinalDef =
+      DefDef(nme.ordinal, Nil, Nil, TypeTree(), Ident(nme.tag))
     val toStringDef =
       DefDef(nme.toString_, Nil, Nil, TypeTree(), Ident(nme.name))
         .withFlags(Override)
     def creator = New(Template(emptyConstructor, enumClassRef :: Nil, Nil, EmptyValDef,
-        List(enumTagDef, toStringDef) ++ registerCall))
+        List(ordinalDef, toStringDef) ++ registerCall))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.tag, defn.IntType), param(nme.name, defn.StringType))),
         TypeTree(), creator)
@@ -242,9 +242,9 @@ object DesugarEnums {
    *   - a method returning the next enum tag
    *   - scaffolding as defined in `nextEnumTag`
    */
-  def enumTagMeth(kind: CaseKind.Value)(implicit ctx: Context): (DefDef, List[Tree]) = {
+  def ordinalMeth(kind: CaseKind.Value)(implicit ctx: Context): (DefDef, List[Tree]) = {
     val (tag, scaffolding) = nextEnumTag(kind)
-    (DefDef(nme.enumTag, Nil, Nil, TypeTree(), Literal(Constant(tag))), scaffolding)
+    (DefDef(nme.ordinal, Nil, Nil, TypeTree(), Literal(Constant(tag))), scaffolding)
   }
 
   /** Expand a module definition representing a parameterless enum case */
@@ -257,7 +257,7 @@ object DesugarEnums {
       def toStringMeth =
         DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), Literal(Constant(name.toString)))
           .withFlags(Override)
-      val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
+      val (tagMeth, scaffolding) = ordinalMeth(CaseKind.Object)
       val impl1 = cpy.Template(impl)(body = List(tagMeth, toStringMeth) ++ registerCall)
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
@@ -279,7 +279,7 @@ object DesugarEnums {
       def toStringMeth =
         DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), Literal(Constant(name.toString)))
           .withFlags(Override)
-      val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
+      val (tagMeth, scaffolding) = ordinalMeth(CaseKind.Object)
       val impl = Template(emptyConstructor, enumClassRef :: Nil, Nil, EmptyValDef,
         body = List(tagMeth, toStringMeth) ++ registerCall)
       val vdef = ValDef(name, TypeTree(), New(impl)).withMods(mods | Final)

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

@@ -597,7 +597,6 @@ class Definitions {
   lazy val JavaSerializableClass: ClassSymbol     = ctx.requiredClass("java.io.Serializable")
 
   lazy val ComparableClass: ClassSymbol           = ctx.requiredClass("java.lang.Comparable")
-
   lazy val SystemClass: ClassSymbol               = ctx.requiredClass("java.lang.System")
   lazy val SystemModule: Symbol              = SystemClass.linkedClass
 
@@ -670,6 +669,15 @@ class Definitions {
   def NoneClass(implicit ctx: Context): ClassSymbol = NoneModuleRef.symbol.moduleClass.asClass
   lazy val EnumType: TypeRef                    = ctx.requiredClassRef("scala.Enum")
   def EnumClass(implicit ctx: Context): ClassSymbol = EnumType.symbol.asClass
+    lazy val Enum_nameR: TermRef = EnumClass.requiredMethodRef(nme.name)
+    def Enum_name(implicit ctx: Context): Symbol = Enum_nameR.symbol
+    lazy val Enum_getDeclaringClassR: TermRef = EnumClass.requiredMethodRef(nme.getDeclaringClass)
+    def Enum_getDeclaringClass(implicit ctx: Context): Symbol = Enum_getDeclaringClassR.symbol
+    lazy val Enum_ordinalR: TermRef = EnumClass.requiredMethodRef(nme.ordinal)
+    def Enum_ordinal(implicit ctx: Context): Symbol = Enum_ordinalR.symbol
+    lazy val Enum_compareToR: TermRef = EnumClass.requiredMethodRef(nme.compareTo)
+    def Enum_compareTo(implicit ctx: Context): Symbol = Enum_compareToR.symbol
+
   lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
   def EnumValuesClass(implicit ctx: Context): ClassSymbol = EnumValuesType.symbol.asClass
   lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")

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

@@ -398,6 +398,7 @@ object StdNames {
     val classOf: N              = "classOf"
     val clone_ : N              = "clone"
     val common: N               = "common"
+    val compareTo: N            = "compareTo"
     val conforms_ : N           = "$conforms"
     val copy: N                 = "copy"
     val currentMirror: N        = "currentMirror"
@@ -412,7 +413,6 @@ object StdNames {
     val elem: N                 = "elem"
     val emptyValDef: N          = "emptyValDef"
     val ensureAccessible : N    = "ensureAccessible"
-    val enumTag: N              = "enumTag"
     val eq: N                   = "eq"
     val eqInstance: N           = "eqInstance"
     val equalsNumChar : N       = "equalsNumChar"
@@ -436,6 +436,7 @@ object StdNames {
     val genericClass: N         = "genericClass"
     val get: N                  = "get"
     val getClass_ : N           = "getClass"
+    val getDeclaringClass: N    = "getDeclaringClass"
     val getOrElse: N            = "getOrElse"
     val hasNext: N              = "hasNext"
     val hashCode_ : N           = "hashCode"

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

@@ -38,18 +38,23 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
   private[this] var myValueSymbols: List[Symbol] = Nil
   private[this] var myCaseSymbols: List[Symbol] = Nil
   private[this] var myCaseModuleSymbols: List[Symbol] = Nil
+  private[this] var mySimpleEnumCaseSymbols: List[Symbol] = Nil
+
 
   private def initSymbols(implicit ctx: Context) =
     if (myValueSymbols.isEmpty) {
       myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
-      myCaseSymbols = myValueSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
+      mySimpleEnumCaseSymbols = List(
+        defn.Enum_name, defn.Enum_ordinal, defn.Enum_compareTo, defn.Enum_getDeclaringClass)
+      myCaseSymbols = myValueSymbols ++ mySimpleEnumCaseSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
     }
 
   def valueSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myValueSymbols }
   def caseSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseSymbols }
   def caseModuleSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
+  def simpleEnumCaseSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; mySimpleEnumCaseSymbols }
 
   /** If this is a case or value class, return the appropriate additional methods,
    *  otherwise return nothing.
@@ -65,6 +70,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         if (clazz.is(Module)) caseModuleSymbols
         else caseSymbols
       }
+      else if (clazz.owner.is(EnumCase)) simpleEnumCaseSymbols
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -95,6 +101,12 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         case nme.productArity => vrefss => Literal(Constant(accessors.length))
         case nme.productPrefix => ownName
         case nme.productElement => vrefss => productElementBody(accessors.length, vrefss.head.head)
+        
+        // Enum Methods
+        case nme.name => _ => Literal(Constant("Hello World"))
+        case nme.ordinal => _ => Literal(Constant(0))
+        case nme.compareTo => _ => Literal(Constant(0))
+        case nme.getDeclaringClass => _ => Literal(Constant(null))
       }
       ctx.log(s"adding $synthetic to $clazz at ${ctx.phase}")
       DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic))).withSpan(ctx.owner.span.focus)
@@ -293,5 +305,4 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     val clazz = ctx.owner.asClass
     cpy.Template(impl)(body = serializableObjectMethod(clazz) ::: caseAndValueMethods(clazz) ::: impl.body)
   }
-
 }

library/src/scala/Enum.scala

@@ -1,11 +1,12 @@
 package scala
 
 /** A base trait of all enum classes */
-trait Enum {// extends Comparable[Enum] {
-  // def getDeclaringClass: Class[_]
-  // def name: String
-
+trait Enum {
+  def getDeclaringClass: Class[_]
+  def name: String
+  def ordinal: Int
+  def compareTo(that: Enum): Int
   /** A number uniquely identifying a case of an enum */
-  def enumTag: Int
-  // def ordinal: Int
+  // def enumTag: Int
+  // 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
   }