Liberate Enum flag so that it can be used for Scala enums as well.

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -258,7 +258,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
       case t: TypeApply if (t.fun.symbol == Predef_classOf) =>
         av.visit(name, t.args.head.tpe.classSymbol.denot.info.toTypeKind(bcodeStore)(innerClasesStore).toASMType)
       case t: tpd.Select =>
-        if (t.symbol.denot.owner.is(Flags.Enum)) {
+        if (t.symbol.denot.owner.is(Flags.JavaEnum)) {
           val edesc = innerClasesStore.typeDescriptor(t.tpe.asInstanceOf[bcodeStore.int.Type]) // the class descriptor of the enumeration class.
           val evalue = t.symbol.name.mangledString // value the actual enumeration value.
           av.visitEnum(name, edesc, evalue)
@@ -710,7 +710,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isBottomClass: Boolean = (sym ne defn.NullClass) && (sym ne defn.NothingClass)
     def isBridge: Boolean = sym is Flags.Bridge
     def isArtifact: Boolean = sym is Flags.Artifact
-    def hasEnumFlag: Boolean = sym is Flags.Enum
+    def hasEnumFlag: Boolean = sym is Flags.JavaEnum
     def hasAccessBoundary: Boolean = sym.accessBoundary(defn.RootClass) ne defn.RootClass
     def isVarargsMethod: Boolean = sym is Flags.JavaVarargs
     def isDeprecated: Boolean = false

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -620,6 +620,15 @@ object Flags {
   /** A Java companion object */
   final val JavaProtected = allOf(JavaDefined, Protected)
 
+  /** A Java enum */
+  final val JavaEnum = allOf(JavaDefined, Enum)
+
+  /** A Java enum trait */
+  final val JavaEnumTrait = allOf(JavaDefined, Enum)
+
+  /** A Java enum value */
+  final val JavaEnumValue = allOf(Stable, JavaStatic, JavaDefined, Enum)
+
   /** Labeled private[this] */
   final val PrivateLocal = allOf(Private, Local)
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -186,8 +186,8 @@ class ClassfileParser(
     if (isEnum) {
       instanceScope.toList.map(_.ensureCompleted())
       staticScope.toList.map(_.ensureCompleted())
-      classRoot.setFlag(Flags.Enum)
-      moduleRoot.setFlag(Flags.Enum)
+      classRoot.setFlag(Flags.JavaEnum)
+      moduleRoot.setFlag(Flags.JavaEnum)
     }
 
     result

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

@@ -842,7 +842,7 @@ object JavaParsers {
         List(Literal(Constant(null)),Literal(Constant(0))))
       val enumclazz = atPos(start, nameOffset) {
         TypeDef(name,
-          makeTemplate(superclazz :: interfaces, body, List(), true)).withMods(mods | Flags.Enum)
+          makeTemplate(superclazz :: interfaces, body, List(), true)).withMods(mods | Flags.JavaEnum)
       }
       addCompanionObject(consts ::: statics ::: predefs, enumclazz)
     }
@@ -861,7 +861,7 @@ object JavaParsers {
           skipAhead()
           accept(RBRACE)
         }
-        ValDef(name.toTermName, enumType, unimplementedExpr).withMods(Modifiers(Flags.Enum | Flags.Stable | Flags.JavaDefined | Flags.JavaStatic))
+        ValDef(name.toTermName, enumType, unimplementedExpr).withMods(Modifiers(Flags.JavaEnum | Flags.Stable | Flags.JavaDefined | Flags.JavaStatic))
       }
     }
 

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -460,7 +460,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         )
       case tp if tp.isRef(defn.UnitClass) =>
         Typ(ConstantType(Constant(())), true) :: Nil
-      case tp if tp.classSymbol.is(Enum) =>
+      case tp if tp.classSymbol.is(JavaEnum) =>
         children.map(sym => Typ(sym.termRef, true))
       case tp =>
         val parts = children.map { sym =>
@@ -730,7 +730,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       }) ||
       tp.isRef(defn.BooleanClass) ||
       tp.isRef(defn.UnitClass) ||
-      tp.classSymbol.is(allOf(Enum, Sealed))  // Enum value doesn't have Sealed flag
+      tp.classSymbol.is(JavaEnumTrait)
 
     debug.println(s"decomposable: ${tp.show} = $res")
 
@@ -874,7 +874,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           isCheckable(and.tp1) || isCheckable(and.tp2)
         }) ||
         tpw.isRef(defn.BooleanClass) ||
-        tpw.typeSymbol.is(Enum) ||
+        tpw.typeSymbol.is(JavaEnum) ||
         canDecompose(tpw) ||
         (defn.isTupleType(tpw) && tpw.argInfos.exists(isCheckable(_)))
       }

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

@@ -494,7 +494,7 @@ class Namer { typer: Typer =>
     // We don't check for clazz.superClass == JavaEnumClass, because this causes a illegal
     // cyclic reference error. See the commit message for details.
     //  if (ctx.compilationUnit.isJava) ctx.owner.companionClass.is(Enum) else ctx.owner.is(Enum)
-    vd.mods.is(allOf(Enum,  Stable, JavaStatic, JavaDefined)) // && ownerHasEnumFlag
+    vd.mods.is(JavaEnumValue) // && ownerHasEnumFlag
   }
 
   /** Add java enum constants */