Conform tests to the new Enums API

Author: anatoliykmetyuk

tests/neg/i5008.scala

@@ -5,4 +5,4 @@ enum Baz extends Foo { case Z } // error
 enum Quux extends Foo with Bar { case Z } // error
 
 class Quuw extends Foo // error
-class Quuz extends Foo { val enumTag = 1 } // error
+class Quuz extends Foo { val ordinal = 1 } // error

tests/neg/i5019.scala

@@ -1,3 +1,3 @@
 enum A { // error
-  def newA(tag: Int) = new A { val enumTag = tag } // error 
+  def newA(tag: Int) = new A { val ordinal = tag } // error 
 }

tests/patmat/planets.scala

@@ -15,11 +15,10 @@ enum Planet(mass: Double, radius: Double) {
 object Test {
   def main(args: Array[String]) = {
     import Planet._
-    assert(enumValueNamed("SATURN") == SATURN)
-    assert(enumValue(2) == EARTH)
+    assert(valueOf("SATURN") == SATURN)
     val earthWeight = 100
     val mass = earthWeight/EARTH.surfaceGravity
-    for (p <- enumValues)
+    for (p <- values)
       println(s"Your weight on $p is ${p.surfaceWeight(mass)}")
   }
 }

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(name: String, override val tpe: Type)
-    case Select(prefix: Term, name: String, signature: Option[Signature])
+    case Ident(nme: String, override val tpe: Type)
+    case Select(prefix: Term, nme: String, signature: Option[Signature])
     case Literal(value: Constant)
     case This(id: Option[Id])
     case New(tpt: TypeTree)
     case Throw(expr: Term)
-    case NamedArg(name: String, arg: Term)
+    case NamedArg(nme: 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(name: String, override val tpe: Type)
-    case TermSelect(prefix: Term, name: String)
-    case TypeSelect(prefix: TypeTree, name: String)
+    case Ident(nme: String, override val tpe: Type)
+    case TermSelect(prefix: Term, nme: String)
+    case TypeSelect(prefix: TypeTree, nme: 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(name: String, bounds: TypeBoundsTree)
+    case Bind(nme: 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(name: String, pat: Pattern)
+    case Bind(nme: 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

@@ -1,13 +1,15 @@
 abstract sealed class List[T] extends Enum
 object List {
   final class Cons[T](x: T, xs: List[T]) extends List[T] {
-    def enumTag = 0
+    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 enumTag = 1
+    def ordinal = 1
+    def name = "Nil"
   }
   object Nil {
     def apply[T](): List[T] = new Nil()

tests/pos/reference/enums.scala

@@ -47,7 +47,7 @@ object Planet {
   def main(args: Array[String]) = {
     val earthWeight = args(0).toDouble
     val mass = earthWeight/EARTH.surfaceGravity
-    for (p <- enumValues)
+    for (p <- values)
       println(s"Your weight on $p is ${p.surfaceWeight(mass)}")
   }
 }

tests/run/enum-Color.check

@@ -1,3 +1,3 @@
-Red: 0
-Green: 1
-Blue: 2
+Red: Red
+Green: Green
+Blue: Blue

tests/run/enum-Color.scala

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

tests/run/generic/Color.scala

@@ -18,7 +18,7 @@ object Color {
   def values = $values.values
 
   private def $new(tag: Int, name: String) = new Color {
-    def enumTag = tag
+    def ordinal = tag
     override def toString = name
     $values.register(this)
   }
@@ -29,7 +29,7 @@ object Color {
 
   implicit val ColorShape: Color `shaped` EnumValue[Color] =
     new (Color `shaped` EnumValue[Color]) {
-      def toShape(x: Color) = EnumValue(x.enumTag)
+      def toShape(x: Color) = EnumValue(x.ordinal)
       def fromShape(x: EnumValue[Color]) = Color.valueOf(x.tag)
     }
 }

tests/run/generic/Enum.scala

@@ -1,7 +1,7 @@
 package generic
 
 trait Enum {
-  def enumTag: Int
+  def ordinal: Int
 }
 
 object runtime {
@@ -10,8 +10,8 @@ object runtime {
     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
     }