Drop EnumCase modifier

Use combination of Enum and Case instead.

Author: odersky

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

@@ -297,8 +297,8 @@ object desugar {
     val isCaseClass  = mods.is(Case) && !mods.is(Module)
     val isCaseObject = mods.is(Case) && mods.is(Module)
     val isImplicit = mods.is(Implicit)
-    val isEnum = mods.hasMod[Mod.Enum] && !mods.is(Module)
-    val isEnumCase = mods.hasMod[Mod.EnumCase]
+    val isEnum = mods.isEnumClass && !mods.is(Module)
+    def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
@@ -641,7 +641,7 @@ object desugar {
     val moduleName = checkNotReservedName(mdef).asTermName
     val impl = mdef.impl
     val mods = mdef.mods
-    lazy val isEnumCase = mods.hasMod[Mod.EnumCase]
+    def isEnumCase = mods.isEnumCase
     if (mods is Package)
       PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
     else if (isEnumCase)
@@ -688,7 +688,7 @@ object desugar {
    */
   def patDef(pdef: PatDef)(implicit ctx: Context): Tree = flatTree {
     val PatDef(mods, pats, tpt, rhs) = pdef
-    if (mods.hasMod[Mod.EnumCase])
+    if (mods.isEnumCase)
       pats map {
         case id: Ident =>
           expandSimpleEnumCase(id.name.asTermName, mods,

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

@@ -33,8 +33,8 @@ object DesugarEnums {
 
   /** 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 tree: MemberDef => tree.mods.isEnumCase
+    case PatDef(mods, _, _, _) => mods.isEnumCase
     case _ => false
   }
 
@@ -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.withMods(cdef.mods.withFlags(cdef.mods.flags | Abstract | Sealed))
+    if (cdef.mods.isEnumClass) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Abstract | Sealed))
     else if (isEnumCase(cdef)) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Final))
     else cdef
 

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

@@ -133,8 +133,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case class Inline() extends Mod(Flags.Inline)
 
     case class Enum() extends Mod(Flags.EmptyFlags)
-
-    case class EnumCase() extends Mod(Flags.EmptyFlags)
   }
 
   /** Modifiers and annotations for definitions
@@ -192,6 +190,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       val cls = implicitly[ClassTag[T]].runtimeClass
       mods.exists(mod => cls.isAssignableFrom(mod.getClass))
     }
+
+    def isEnumCase = hasMod[Mod.Enum] && is(Case)
+    def isEnumClass = hasMod[Mod.Enum] && !is(Case)
   }
 
   @sharable val EmptyModifiers: Modifiers = new Modifiers()

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2270,7 +2270,7 @@ object Parsers {
     /** EnumCase = `case' (id ClassConstr [`extends' ConstrApps] | ids)
      */
     def enumCase(start: Offset, mods: Modifiers): DefTree = {
-      val mods1 = mods.withAddedMod(atPos(in.offset)(Mod.EnumCase())) | Case
+      val mods1 = mods.withAddedMod(atPos(in.offset)(Mod.Enum())) | Case
       accept(CASE)
 
       in.adjustSepRegions(ARROW)

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -855,7 +855,7 @@ trait Checking {
       cls.isAnonymousClass &&
       cls.owner.isTerm &&
       (cls.owner.flagsUNSAFE.is(Case) || cls.owner.name == nme.DOLLAR_NEW)
-    if (!cdef.mods.hasMod[untpd.Mod.EnumCase] && !isEnumAnonCls)
+    if (!cdef.mods.isEnumCase && !isEnumAnonCls)
       ctx.error(em"normal case $cls in ${cls.owner} cannot extend an enum", cdef.pos)
   }
 

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1904,7 +1904,7 @@ class Typer extends Namer
               case mdef1 =>
                 import untpd.modsDeco
                 mdef match {
-                  case mdef: untpd.TypeDef if mdef.mods.hasMod[untpd.Mod.Enum] =>
+                  case mdef: untpd.TypeDef if mdef.mods.isEnumClass =>
                     enumContexts(mdef1.symbol) = ctx
                   case _ =>
                 }