Merge pull request #1958 from dotty-staging/add-enum

Add "enum" construct

25 files changed, 246 insertions, 32 deletions

diff --git a/tests/neg/enums.scala b/tests/neg/enums.scala
new file mode 100644
index 000000000..108ec4a6c
--- /dev/null
+++ b/tests/neg/enums.scala
@@ -0,0 +1,20 @@
+enum List[+T] {
+  case Cons(x: T, xs: List[T])
+  case Snoc[U](xs: List[U], x: U) // error: case with type parameters needs extends clause
+}
+
+enum class X {
+  case Y // error: case not allowed here
+}
+
+enum E1[T] {
+  case C // error: cannot determine type argument
+}
+
+enum E2[+T, +U >: T] {
+  case C // error: cannot determine type argument
+}
+
+enum E3[-T <: Ordered[T]] {
+  case C // error: cannot determine type argument
+}
diff --git a/tests/pos/enum-List-control.scala b/tests/pos/enum-List-control.scala
new file mode 100644
index 000000000..d9df176d1
--- /dev/null
+++ b/tests/pos/enum-List-control.scala
@@ -0,0 +1,14 @@
+abstract sealed class List[T] extends Enum
+object List {
+  final case class Cons[T](x: T, xs: List[T]) extends List[T] {
+    def enumTag = 0
+  }
+  final case class Nil[T]() extends List[T] {
+    def enumTag = 1
+  }
+}
+object Test {
+  import List._
+  val xs = Cons(1, Cons(2, Cons(3, Nil())))
+  def main(args: Array[String]) = println(xs)
+}
diff --git a/tests/run/enum-Color.check b/tests/run/enum-Color.check
new file mode 100644
index 000000000..865c47e49
--- /dev/null
+++ b/tests/run/enum-Color.check
@@ -0,0 +1,3 @@
+Red: 0
+Green: 1
+Blue: 2
diff --git a/tests/run/enum-Color.scala b/tests/run/enum-Color.scala
new file mode 100644
index 000000000..683d18d9e
--- /dev/null
+++ b/tests/run/enum-Color.scala
@@ -0,0 +1,11 @@
+enum Color {
+  case Red, Green, Blue
+}
+
+object Test {
+  def main(args: Array[String]) =
+    for (color <- Color.enumValues) {
+      println(s"$color: ${color.enumTag}")
+      assert(Color.enumValue(color.enumTag) eq color)
+    }
+}
diff --git a/tests/run/enum-HList.scala b/tests/run/enum-HList.scala
new file mode 100644
index 000000000..c019cb6cc
--- /dev/null
+++ b/tests/run/enum-HList.scala
@@ -0,0 +1,22 @@
+enum HLst {
+  case HCons[+Hd, +Tl <: HLst](hd: Hd, tl: Tl)
+  case HNil
+}
+
+object Test {
+  import HLst._
+  def length(hl: HLst): Int = hl match {
+    case HCons(_, tl) => 1 + length(tl)
+    case HNil => 0
+  }
+  def sumInts(hl: HLst): Int = hl match {
+    case HCons(x: Int, tl) => x + sumInts(tl)
+    case HCons(_, tl) => sumInts(tl)
+    case HNil => 0
+  }
+  def main(args: Array[String]) = {
+    val hl = HCons(1, HCons("A", HNil))
+    assert(length(hl) == 2, length(hl))
+    assert(sumInts(hl) == 1)
+  }
+}
diff --git a/tests/run/enum-List1.check b/tests/run/enum-List1.check
new file mode 100644
index 000000000..3ed5061b4
--- /dev/null
+++ b/tests/run/enum-List1.check
@@ -0,0 +1 @@
+Cons(1,Cons(2,Cons(3,Nil())))
diff --git a/tests/run/enum-List1.scala b/tests/run/enum-List1.scala
new file mode 100644
index 000000000..bb75bec4a
--- /dev/null
+++ b/tests/run/enum-List1.scala
@@ -0,0 +1,10 @@
+enum class List[T]
+object List {
+  case Cons(x: T, xs: List[T])
+  case Nil()
+}
+object Test {
+  import List._
+  val xs = Cons(1, Cons(2, Cons(3, Nil())))
+  def main(args: Array[String]) = println(xs)
+}
diff --git a/tests/run/enum-List2.check b/tests/run/enum-List2.check
new file mode 100644
index 000000000..1d4812de1
--- /dev/null
+++ b/tests/run/enum-List2.check
@@ -0,0 +1 @@
+Cons(1,Cons(2,Cons(3,Nil)))
diff --git a/tests/run/enum-List2.scala b/tests/run/enum-List2.scala
new file mode 100644
index 000000000..030de0f84
--- /dev/null
+++ b/tests/run/enum-List2.scala
@@ -0,0 +1,11 @@
+enum class List[+T]
+object List {
+  case Cons(x: T, xs: List[T])
+  case Nil extends List[Nothing]
+}
+object Test {
+  import List._
+  val xs = Cons(1, Cons(2, Cons(3, Nil)))
+  def main(args: Array[String]) = println(xs)
+}
+
diff --git a/tests/run/enum-List2a.check b/tests/run/enum-List2a.check
new file mode 100644
index 000000000..1d4812de1
--- /dev/null
+++ b/tests/run/enum-List2a.check
@@ -0,0 +1 @@
+Cons(1,Cons(2,Cons(3,Nil)))
diff --git a/tests/run/enum-List2a.scala b/tests/run/enum-List2a.scala
new file mode 100644
index 000000000..323a5587c
--- /dev/null
+++ b/tests/run/enum-List2a.scala
@@ -0,0 +1,11 @@
+enum class List[+T]
+object List {
+  case Cons(x: T, xs: List[T])
+  case Nil
+}
+object Test {
+  import List._
+  val xs = Cons(1, Cons(2, Cons(3, Nil)))
+  def main(args: Array[String]) = println(xs)
+}
+
diff --git a/tests/run/enum-List3.check b/tests/run/enum-List3.check
new file mode 100644
index 000000000..1d4812de1
--- /dev/null
+++ b/tests/run/enum-List3.check
@@ -0,0 +1 @@
+Cons(1,Cons(2,Cons(3,Nil)))
diff --git a/tests/run/enum-List3.scala b/tests/run/enum-List3.scala
new file mode 100644
index 000000000..e5ffe1a28
--- /dev/null
+++ b/tests/run/enum-List3.scala
@@ -0,0 +1,10 @@
+enum List[+T] {
+  case Cons(x: T, xs: List[T])
+  case Nil extends List[Nothing]
+}
+object Test {
+  import List._
+  val xs = Cons(1, Cons(2, Cons(3, Nil)))
+  def main(args: Array[String]) = println(xs)
+}
+
diff --git a/tests/run/enum-Option.scala b/tests/run/enum-Option.scala
new file mode 100644
index 000000000..76f5641b3
--- /dev/null
+++ b/tests/run/enum-Option.scala
@@ -0,0 +1,19 @@
+enum class Option[+T >: Null] extends Serializable {
+   def isDefined: Boolean
+}
+object Option {
+  def apply[T >: Null](x: T): Option[T] = if (x == null) None else Some(x)
+  case Some(x: T) {
+     def isDefined = true
+  }
+  case None {
+     def isDefined = false
+  }
+}
+
+object Test {
+  def main(args: Array[String]) = {
+    assert(Some(None).isDefined)
+    Option("22") match { case Option.Some(x) => assert(x == "22") }
+  }
+}
diff --git a/tests/run/enum-Tree.check b/tests/run/enum-Tree.check
new file mode 100644
index 000000000..02f5151be
--- /dev/null
+++ b/tests/run/enum-Tree.check
@@ -0,0 +1 @@
+If(IsZero(Pred(Succ(Zero))),Succ(Succ(Zero)),Pred(Pred(Zero))) --> 2
diff --git a/tests/run/enum-Tree.scala b/tests/run/enum-Tree.scala
new file mode 100644
index 000000000..ef5bd7a57
--- /dev/null
+++ b/tests/run/enum-Tree.scala
@@ -0,0 +1,29 @@
+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: Tree[Boolean], thenp: Tree[T], elsep: Tree[T])
+}
+
+object Test {
+  import Tree._
+
+  def eval[T](e: Tree[T]): T = e match {
+    case True => true
+    case False => false
+    case Zero => 0
+    case Succ(f) => eval(f) + 1
+    case Pred(f) => eval(f) - 1
+    case IsZero(f) => eval(f) == 0
+    case If(cond, thenp, elsep) => if (eval(cond)) eval(thenp) else eval(elsep)
+  }
+
+  val data = If(IsZero(Pred(Succ(Zero))), Succ(Succ(Zero)), Pred(Pred(Zero)))
+
+  def main(args: Array[String]) = {
+    println(s"$data --> ${eval(data)}")
+  }
+}
diff --git a/tests/run/enum-approx.scala b/tests/run/enum-approx.scala
new file mode 100644
index 000000000..7811b3909
--- /dev/null
+++ b/tests/run/enum-approx.scala
@@ -0,0 +1,22 @@
+enum class Fun[-T, +U >: Null] {
+  def f: T => U = null
+}
+object Fun {
+  case Identity[T, U >: Null](override val f: T => U) extends Fun[T, U]
+  case ConstNull {
+    override def f = x => null
+  }
+  case ConstNullClass() {
+    override def f = x => null
+  }
+  case ConstNullSimple
+}
+
+object Test {
+  def main(args: Array[String]) = {
+    val x: Null = Fun.ConstNull.f("abc")
+    val y: Null = Fun.ConstNullClass().f("abc")
+    assert(Fun.ConstNullSimple.f == null)
+  }
+}
+
diff --git a/tests/run/enumList2a.check b/tests/run/enumList2a.check
new file mode 100644
index 000000000..1d4812de1
--- /dev/null
+++ b/tests/run/enumList2a.check
@@ -0,0 +1 @@
+Cons(1,Cons(2,Cons(3,Nil)))
diff --git a/tests/run/generic/Color.scala b/tests/run/generic/Color.scala
index ed248295d..7f2a8818c 100644
--- a/tests/run/generic/Color.scala
+++ b/tests/run/generic/Color.scala
@@ -10,12 +10,17 @@ import Shapes._
  */
 sealed trait Color extends Enum
 
-object Color extends EnumValues[Color](3) {
+object Color {
+
+  private val $values = new runtime.EnumValues[Color]
+  def valueOf = $values.fromInt
+  def withName = $values.fromName
+  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 +30,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)
     }
-}
\ No newline at end of file
+}
diff --git a/tests/run/generic/Enum.scala b/tests/run/generic/Enum.scala
deleted file mode 100644
index dbdbfe8eb..000000000
--- a/tests/run/generic/Enum.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-package generic
-
-import Shapes.Singleton
-
-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]]
-}
diff --git a/tests/run/generic/List.scala b/tests/run/generic/List.scala
index 3f3657656..bc01ce63f 100644
--- a/tests/run/generic/List.scala
+++ b/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]
  *  }
diff --git a/tests/run/generic/SearchResult.scala b/tests/run/generic/SearchResult.scala
index 1c86d1b4f..d4380a072 100644
--- a/tests/run/generic/SearchResult.scala
+++ b/tests/run/generic/SearchResult.scala
@@ -11,12 +11,17 @@ import Shapes._
  */
 sealed trait SearchResult extends Enum
 
-object SearchResult extends EnumValues[SearchResult](3) {
+object SearchResult extends {
+
+  private val $values = new runtime.EnumValues[SearchResult]
+  def valueOf = $values.fromInt
+  def withName = $values.fromName
+  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 +36,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 +63,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)
       }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/run/generic/Tree.scala b/tests/run/generic/Tree.scala
index f4e706944..673506b07 100644
--- a/tests/run/generic/Tree.scala
+++ b/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
          }
       }
-}
\ No newline at end of file
+}
diff --git a/tests/run/planets.check b/tests/run/planets.check
new file mode 100644
index 000000000..feb6f737d
--- /dev/null
+++ b/tests/run/planets.check
@@ -0,0 +1,8 @@
+Your weight on MERCURY is 37.775761520093525
+Your weight on SATURN is 106.60155388115666
+Your weight on VENUS is 90.49990998410455
+Your weight on URANUS is 90.51271993894251
+Your weight on EARTH is 100.0
+Your weight on NEPTUNE is 113.83280724696579
+Your weight on MARS is 37.873718403712886
+Your weight on JUPITER is 253.05575254957407
diff --git a/tests/run/planets.scala b/tests/run/planets.scala
new file mode 100644
index 000000000..bcbfd7eeb
--- /dev/null
+++ b/tests/run/planets.scala
@@ -0,0 +1,26 @@
+enum class Planet(mass: Double, radius: Double) {
+  private final val G = 6.67300E-11
+  def surfaceGravity = G * mass / (radius * radius)
+  def surfaceWeight(otherMass: Double) =  otherMass * surfaceGravity
+}
+object Planet {
+  case MERCURY extends Planet(3.303e+23, 2.4397e6)
+  case VENUS   extends Planet(4.869e+24, 6.0518e6)
+  case EARTH   extends Planet(5.976e+24, 6.37814e6)
+  case MARS    extends Planet(6.421e+23, 3.3972e6)
+  case JUPITER extends Planet(1.9e+27,   7.1492e7)
+  case SATURN  extends Planet(5.688e+26, 6.0268e7)
+  case URANUS  extends Planet(8.686e+25, 2.5559e7)
+  case NEPTUNE extends Planet(1.024e+26, 2.4746e7)
+}
+object Test {
+  def main(args: Array[String]) = {
+    import Planet._
+    assert(enumValueNamed("SATURN") == SATURN)
+    assert(enumValue(2) == EARTH)
+    val earthWeight = 100
+    val mass = earthWeight/EARTH.surfaceGravity
+    for (p <- enumValues)
+      println(s"Your weight on $p is ${p.surfaceWeight(mass)}")
+  }
+}