Implement new enum scheme

Implement as is described in the docs. Update docs and tests where necessary.

Author: odersky

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

@@ -305,14 +305,19 @@ object desugar {
     val isCaseObject = mods.is(Case) && mods.is(Module)
     val isImplicit = mods.is(Implicit)
     val isEnum = mods.hasMod[Mod.Enum] && !mods.is(Module)
-    val isEnumCase = isLegalEnumCase(cdef)
+    val isEnumCase = mods.hasMod[Mod.EnumCase]
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
-    // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
-
+      // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
     val originalTparams = constr1.tparams
     val originalVparamss = constr1.vparamss
-    val constrTparams = originalTparams.map(toDefParam)
+    lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParam)
+    val impliedTparams =
+      if (isEnumCase && originalTparams.isEmpty)
+        derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
+      else
+        originalTparams
+    val constrTparams = impliedTparams.map(toDefParam)
     val constrVparamss =
       if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
         if (isCaseClass) ctx.error(CaseClassMissingParamList(cdef), cdef.namePos)
@@ -321,18 +326,34 @@ object desugar {
       else originalVparamss.nestedMap(toDefParam)
     val constr = cpy.DefDef(constr1)(tparams = constrTparams, vparamss = constrVparamss)
 
-    // Add constructor type parameters and evidence implicit parameters
-    // to auxiliary constructors
-    val normalizedBody = impl.body map {
-      case ddef: DefDef if ddef.name.isConstructorName =>
-        decompose(
-          defDef(
-            addEvidenceParams(
-              cpy.DefDef(ddef)(tparams = constrTparams),
-              evidenceParams(constr1).map(toDefParam))))
-      case stat =>
-        stat
+    val (normalizedBody, enumCases, enumCompanionRef) = {
+      // Add constructor type parameters and evidence implicit parameters
+      // to auxiliary constructors; set defaultGetters as a side effect.
+      def expandConstructor(tree: Tree) = tree match {
+        case ddef: DefDef if ddef.name.isConstructorName =>
+          decompose(
+            defDef(
+              addEvidenceParams(
+                cpy.DefDef(ddef)(tparams = constrTparams),
+                evidenceParams(constr1).map(toDefParam))))
+        case stat =>
+          stat
+      }
+      // The Identifiers defined by a case
+      def caseIds(tree: Tree) = tree match {
+        case tree: MemberDef => Ident(tree.name.toTermName) :: Nil
+        case PatDef(_, ids, _, _) => ids
+      }
+      val stats = impl.body.map(expandConstructor)
+      if (isEnum) {
+        val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
+        val enumCompanionRef = new TermRefTree()
+        val enumImport = Import(enumCompanionRef, enumCases.flatMap(caseIds))
+        (enumImport :: enumStats, enumCases, enumCompanionRef)
+      }
+      else (stats, Nil, EmptyTree)
     }
+
     def anyRef = ref(defn.AnyRefAlias.typeRef)
 
     val derivedTparams = constrTparams.map(derivedTypeParam(_))
@@ -365,20 +386,16 @@ object desugar {
     val classTypeRef = appliedRef(classTycon)
 
     // a reference to `enumClass`, with type parameters coming from the case constructor
-    lazy val enumClassTypeRef = enumClass.primaryConstructor.info match {
-      case info: PolyType =>
-        if (constrTparams.isEmpty)
-          interpolatedEnumParent(cdef.pos.startPos)
-        else if ((constrTparams.corresponds(info.paramNames))((param, name) => param.name == name))
-          appliedRef(enumClassRef)
-        else {
-          ctx.error(i"explicit extends clause needed because type parameters of case and enum class differ"
-              , cdef.pos.startPos)
-          appliedTypeTree(enumClassRef, constrTparams map (_ => anyRef))
-        }
-      case _ =>
+    lazy val enumClassTypeRef =
+      if (enumClass.typeParams.isEmpty)
         enumClassRef
-    }
+      else if (originalTparams.isEmpty)
+        appliedRef(enumClassRef)
+      else {
+        ctx.error(i"explicit extends clause needed because both enum case and enum class have type parameters"
+            , cdef.pos.startPos)
+        appliedTypeTree(enumClassRef, constrTparams map (_ => anyRef))
+      }
 
     // new C[Ts](paramss)
     lazy val creatorExpr = New(classTypeRef, constrVparamss nestedMap refOfDef)
@@ -432,6 +449,7 @@ object desugar {
     }
 
     // Case classes and case objects get Product parents
+    // Enum cases get an inferred parent if no parents are given
     var parents1 = parents
     if (isEnumCase && parents.isEmpty)
       parents1 = enumClassTypeRef :: Nil
@@ -477,7 +495,7 @@ object desugar {
             .withMods(companionMods | Synthetic))
       .withPos(cdef.pos).toList
 
-    val companionMeths = defaultGetters ::: eqInstances
+    val companionMembers = defaultGetters ::: eqInstances ::: enumCases
 
     // The companion object definitions, if a companion is needed, Nil otherwise.
     // companion definitions include:
@@ -490,18 +508,17 @@ object desugar {
     // For all other classes, the parent is AnyRef.
     val companions =
       if (isCaseClass) {
-        // The return type of the `apply` method
+        // The return type of the `apply` method, and an (empty or singleton) list
+        // of widening coercions
         val (applyResultTpt, widenDefs) =
           if (!isEnumCase)
             (TypeTree(), Nil)
           else if (parents.isEmpty || enumClass.typeParams.isEmpty)
             (enumClassTypeRef, Nil)
-          else {
-            val tparams = enumClass.typeParams.map(derivedTypeParam)
-            enumApplyResult(cdef, parents, tparams, appliedRef(enumClassRef, tparams))
-          }
+          else
+            enumApplyResult(cdef, parents, derivedEnumParams, appliedRef(enumClassRef, derivedEnumParams))
 
-        val parent =
+        val companionParent =
           if (constrTparams.nonEmpty ||
               constrVparamss.length > 1 ||
               mods.is(Abstract) ||
@@ -523,10 +540,10 @@ object desugar {
           DefDef(nme.unapply, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
             .withMods(synthetic)
         }
-        companionDefs(parent, applyMeths ::: unapplyMeth :: companionMeths)
+        companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)
       }
-      else if (companionMeths.nonEmpty)
-        companionDefs(anyRef, companionMeths)
+      else if (companionMembers.nonEmpty)
+        companionDefs(anyRef, companionMembers)
       else if (isValueClass) {
         constr0.vparamss match {
           case (_ :: Nil) :: _ => companionDefs(anyRef, Nil)
@@ -535,6 +552,13 @@ object desugar {
       }
       else Nil
 
+    enumCompanionRef match {
+      case ref: TermRefTree => // have the enum import watch the companion object
+        val (modVal: ValDef) :: _ = companions
+        ref.watching(modVal)
+      case _ =>
+    }
+
     // For an implicit class C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, .., pMN: TMN), the method
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
     //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =
@@ -567,7 +591,7 @@ object desugar {
     }
 
     val cdef1 = addEnumFlags {
-      val originalTparamsIt = originalTparams.toIterator
+      val originalTparamsIt = impliedTparams.toIterator
       val originalVparamsIt = originalVparamss.toIterator.flatten
       val tparamAccessors = derivedTparams.map(_.withMods(originalTparamsIt.next().mods))
       val caseAccessor = if (isCaseClass) CaseAccessor else EmptyFlags
@@ -607,7 +631,7 @@ object desugar {
     val moduleName = checkNotReservedName(mdef).asTermName
     val impl = mdef.impl
     val mods = mdef.mods
-    lazy val isEnumCase = isLegalEnumCase(mdef)
+    lazy val isEnumCase = mods.hasMod[Mod.EnumCase]
     if (mods is Package)
       PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
     else if (isEnumCase)
@@ -654,7 +678,7 @@ object desugar {
    */
   def patDef(pdef: PatDef)(implicit ctx: Context): Tree = flatTree {
     val PatDef(mods, pats, tpt, rhs) = pdef
-    if (mods.hasMod[Mod.EnumCase] && enumCaseIsLegal(pdef))
+    if (mods.hasMod[Mod.EnumCase])
       pats map {
         case id: Ident =>
           expandSimpleEnumCase(id.name.asTermName, mods,

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

@@ -6,7 +6,6 @@ import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
 import Decorators._
-import reporting.diagnostic.messages.EnumCaseDefinitionInNonEnumOwner
 import collection.mutable.ListBuffer
 import util.Property
 import typer.ErrorReporting._
@@ -23,20 +22,21 @@ object DesugarEnums {
   /** Attachment containing the number of enum cases and the smallest kind that was seen so far. */
   val EnumCaseCount = new Property.Key[(Int, CaseKind.Value)]
 
-  /** the enumeration class that is a companion of the current object */
-  def enumClass(implicit ctx: Context) = ctx.owner.linkedClass
-
-  /** Is this an enum case that's situated in a companion object of an enum class? */
-  def isLegalEnumCase(tree: MemberDef)(implicit ctx: Context): Boolean =
-    tree.mods.hasMod[Mod.EnumCase] && enumCaseIsLegal(tree)
+  /** The enumeration class that belongs to an enum case. This works no matter
+   *  whether the case is still in the enum class or it has been transferred to the
+   *  companion object.
+   */
+  def enumClass(implicit ctx: Context): Symbol = {
+    val cls = ctx.owner
+    if (cls.is(Module)) cls.linkedClass else cls
+  }
 
-  /** Is enum case `tree` situated in a companion object of an enum class? */
-  def enumCaseIsLegal(tree: Tree)(implicit ctx: Context): Boolean = (
-    ctx.owner.is(ModuleClass) && enumClass.derivesFrom(defn.EnumClass)
-    || { ctx.error(EnumCaseDefinitionInNonEnumOwner(ctx.owner), tree.pos)
-         false
-       }
-    )
+  /** Is `tree` an (untyped) enum case? */
+  def isEnumCase(tree: Tree)(implicit ctx: Context): Boolean = tree match {
+    case tree: MemberDef => tree.mods.hasMod[Mod.EnumCase]
+    case PatDef(mods, _, _, _) => mods.hasMod[Mod.EnumCase]
+    case _ => false
+  }
 
   /** A reference to the enum class `E`, possibly followed by type arguments.
    *  Each covariant type parameter is approximated by its lower bound.
@@ -69,7 +69,7 @@ object DesugarEnums {
   /** Add implied flags to an enum class or an enum case */
   def addEnumFlags(cdef: TypeDef)(implicit ctx: Context) =
     if (cdef.mods.hasMod[Mod.Enum]) cdef.withFlags(cdef.mods.flags | Abstract | Sealed)
-    else if (isLegalEnumCase(cdef)) cdef.withFlags(cdef.mods.flags | Final)
+    else if (isEnumCase(cdef)) cdef.withFlags(cdef.mods.flags | Final)
     else cdef
 
   private def valuesDot(name: String) = Select(Ident(nme.DOLLAR_VALUES), name.toTermName)
@@ -193,24 +193,20 @@ object DesugarEnums {
   }
 
   /** Expand a module definition representing a parameterless enum case */
-  def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, pos: Position)(implicit ctx: Context): Tree =
+  def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, pos: Position)(implicit ctx: Context): Tree = {
+    assert(impl.body.isEmpty)
     if (impl.parents.isEmpty)
-      if (impl.body.isEmpty)
-        expandSimpleEnumCase(name, mods, pos)
-      else {
-        val parent = interpolatedEnumParent(pos)
-        expandEnumModule(name, cpy.Template(impl)(parents = parent :: Nil), mods, pos)
-      }
+      expandSimpleEnumCase(name, mods, pos)
     else {
       def toStringMeth =
         DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), Literal(Constant(name.toString)))
           .withFlags(Override)
       val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
-      val impl1 = cpy.Template(impl)(body =
-        impl.body ++ List(tagMeth, toStringMeth) ++ registerCall)
+      val impl1 = cpy.Template(impl)(body = List(tagMeth, toStringMeth) ++ registerCall)
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withPos(pos)
     }
+  }
 
   /** Expand a simple enum case */
   def expandSimpleEnumCase(name: TermName, mods: Modifiers, pos: Position)(implicit ctx: Context): Tree =

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1783,16 +1783,6 @@ object messages {
       hl"""A class marked with the ${"final"} keyword cannot be extended"""
   }
 
-  case class EnumCaseDefinitionInNonEnumOwner(owner: Symbol)(implicit ctx: Context)
-    extends Message(EnumCaseDefinitionInNonEnumOwnerID) {
-      val kind = "Syntax"
-      val msg = em"case not allowed here, since owner ${owner} is not an ${"enum"} object"
-      val explanation =
-        hl"""${"enum"} cases are only allowed within the companion ${"object"} of an ${"enum class"}.
-            |If you want to create an ${"enum"} case, make sure the corresponding ${"enum class"} exists
-            |and has the ${"enum"} keyword."""
-  }
-
   case class ExpectedTypeBoundOrEquals(found: Token)(implicit ctx: Context)
     extends Message(ExpectedTypeBoundOrEqualsID) {
     val kind = "Syntax"

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -986,19 +986,6 @@ class ErrorMessagesTests extends ErrorMessagesTest {
     assertEquals(parent.show, "class A")
   }
 
-  @Test def enumCaseDefinitionInNonEnumOwner =
-    checkMessagesAfter("frontend") {
-      """object Qux {
-        |  case Foo
-        |}
-      """.stripMargin
-    }.expect { (ictx, messages) =>
-      implicit val ctx: Context = ictx
-      assertMessageCount(1, messages)
-      val EnumCaseDefinitionInNonEnumOwner(owner) :: Nil = messages
-      assertEquals("object Qux", owner.show)
-    }
-
   @Test def tailrecNotApplicableNeitherPrivateNorFinal =
     checkMessagesAfter("tailrec") {
     """

docs/docs/reference/enums/desugarEnums.md

@@ -36,9 +36,13 @@ map into case classes or vals.
 
     expands to a `sealed` `abstract` class that extends the `scala.Enum` trait and
     an associated companion object that contains the defined cases, expanded according
-    to rules (2 - 8).
+    to rules (2 - 8). The enum trait starts with a compiler-generated import that imports
+    the names `<caseIds>` of all cases so that they can be used without prefix in the trait.
 
-        sealed abstract class E ... extends <parents> with scala.Enum { <defs> }
+        sealed abstract class E ... extends <parents> with scala.Enum {
+          import E.{ <caseIds> }
+          <defs>
+        }
         object E { <cases> }
 
 2. A simple case consisting of a comma-separated list of enum names

tests/run/enum-List3.scala renamed to tests/neg/enum-List3.scala

@@ -1,5 +1,5 @@
 enum List[+T] {
-  case Cons[T](x: T, xs: List[T])
+  case Cons[T](x: T, xs: List[T]) // error: missing extends
   case Nil extends List[Nothing]
 }
 object Test {

tests/neg/enums.scala

@@ -1,12 +1,8 @@
 package enums
 
 enum List[+T] {
-  case Cons[T](x: T, xs: List[T]) // ok
-  case Snoc[U](xs: List[U], x: U) // error: different type parameters
-}
-
-enum class X {
-  case Y // error: case not allowed here
+  case Cons[T](x: T, xs: List[T]) // error: missing extends
+  case Snoc[U](xs: List[U], x: U) // error: missing extends
 }
 
 enum E1[T] {
@@ -22,7 +18,7 @@ enum E3[-T <: Ordered[T]] {
 }
 
 enum Option[+T] {
-  case Some[T](x: T)
+  case Some(x: T)
   case None
 }
 

tests/patmat/enum-Tree.scala

@@ -5,7 +5,7 @@ enum Tree[T] {
   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]) extends Tree[T]
+  case If[X](cond: Tree[Boolean], thenp: Tree[X], elsep: Tree[X]) extends Tree[X]
 }
 
 object Test {

tests/pos/i3460.scala

@@ -1,7 +1,7 @@
-enum class Ducks
-
-object Ducks {
+enum Ducks {
   case Dewey
+}
 
+object Ducks {
   def wooohoo: Int = 1
 }

tests/pos/objXfun.scala

@@ -2,7 +2,6 @@ object Foo extends (Int => Int) { // OK
   def apply(x: Int) = x
 }
 
-enum class E(x: Int)  // used to generate Int => new E(x) as the parent of object E --> crash
-object E {
+enum E(x: Int) { // used to generate Int => new E(x) as the parent of object E --> crash
   case C(x: Int) extends E(x)
 }