Adapt generic tests to model modified enum values scheme

Author: odersky

tests/run/generic/Color.scala

@@ -10,12 +10,16 @@ import Shapes._
  */
 sealed trait Color extends Enum
 
-object Color extends EnumValues[Color](3) {
+object Color {
+
+  private val $values = new EnumValues[Color]
+  def valueOf: Int => Color = $values
+  def values = $values.values
 
   private def $new(tag: Int, name: String) = new Color {
     def enumTag = tag
     override def toString = name
-    registerEnumValue(this)
+    $values.register(this)
   }
 
   val Red: Color = $new(0, "Red")
@@ -25,6 +29,6 @@ object Color extends EnumValues[Color](3) {
   implicit val ColorShape: Color `shaped` EnumValue[Color] =
     new (Color `shaped` EnumValue[Color]) {
       def toShape(x: Color) = EnumValue(x.enumTag)
-      def fromShape(x: EnumValue[Color]) = Color.value(x.tag)
+      def fromShape(x: EnumValue[Color]) = Color.valueOf(x.tag)
     }
-}
+}

tests/run/generic/Enum.scala

@@ -1,18 +1,24 @@
 package generic
 
 import Shapes.Singleton
+import scala.collection.mutable.ResizableArray
+import scala.collection.immutable.Seq
 
 trait Enum {
   def enumTag: Int
 }
 
 trait FiniteEnum extends Enum
 
-abstract class EnumValues[E <: Enum](numVals: Int) {
-  private var myValues = new Array[AnyRef](numVals)
-
-  def registerEnumValue(v: E) =
-    myValues(v.enumTag) = v
-
-  def value: IndexedSeq[E] = (myValues: IndexedSeq[AnyRef]).asInstanceOf[IndexedSeq[E]]
+class EnumValues[E <: Enum] extends ResizableArray[E] {
+  private var valuesCache: Seq[E] = Nil
+  def register(v: E) = {
+    ensureSize(v.enumTag + 1)
+    array(v.enumTag) = v
+    valuesCache = null
+  }
+  def values: Seq[E] = {
+    if (valuesCache == null) valuesCache = array.filter(_ != null).toList.asInstanceOf[scala.List[E]]
+    valuesCache
+  }
 }

tests/run/generic/List.scala

@@ -46,7 +46,7 @@ object List0 {
     }
 }
 
-/** enum List[T] {
+/** enum List[+T] {
  *    case Cons(x: T, xs: List[T])
  *    case Nil extends List[Nothing]
  *  }

tests/run/generic/SearchResult.scala

@@ -11,12 +11,16 @@ import Shapes._
  */
 sealed trait SearchResult extends Enum
 
-object SearchResult extends EnumValues[SearchResult](3) {
+object SearchResult extends {
+
+  private val $values = new EnumValues[SearchResult]
+  def valueOf: Int => SearchResult = $values
+  def values = $values.values
 
   private def $new(tag: Int, name: String) = new SearchResult {
     def enumTag = tag
     override def toString = name
-    registerEnumValue(this)
+    $values.register(this)
   }
 
   abstract case class Success(result: Color) extends SearchResult {
@@ -31,8 +35,8 @@ object SearchResult extends EnumValues[SearchResult](3) {
     }
   }
 
-  val Diverging = $new(1, "Diverging")
-  val NoMatch = $new(2, "NoMatch")
+  val Diverging: SearchResult = $new(1, "Diverging")
+  val NoMatch: SearchResult = $new(2, "NoMatch")
 
   abstract case class Ambiguous(alt1: SearchResult, alt2: SearchResult) extends SearchResult {
     def enumTag = 3
@@ -58,7 +62,7 @@ object SearchResult extends EnumValues[SearchResult](3) {
       def fromShape(x: Sum[Success, Sum[Ambiguous, EnumValue[SearchResult]]]): SearchResult = x match {
         case Fst(s) => s
         case Snd(Fst(a)) => a
-        case Snd(Snd(ev)) => value(ev.tag)
+        case Snd(Snd(ev)) => valueOf(ev.tag)
       }
     }
-}
+}

tests/run/generic/Tree.scala

@@ -2,14 +2,14 @@ package generic
 
 import Shapes._
 
-/** enum Tree[TS] {
+/** enum Tree[T] {
  *    case True extends Tree[Boolean]
  *    case False extends Tree[Boolean]
  *    case Zero extends Tree[Int]
  *    case Succ(n: Tree[Int]) extends Tree[Int]
  *    case Pred(n: Tree[Int]) extends Tree[Int]
  *    case IsZero(n: Tree[Int]) extends Tree[Boolean]
- *    case If(cond: Boolean, thenp: Tree[T], elsep: Tree[T]) extends Tree[T]
+ *    case If(cond: Boolean, thenp: Tree[T], elsep: Tree[T])
  *  }
  */
 sealed trait Tree[TR] extends Enum
@@ -110,4 +110,4 @@ object Tree {
            case Snd(Snd(_if)) => _if
          }
       }
-}
+}