Fix rebase breakage

Author: odersky

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

@@ -286,7 +286,7 @@ object DesugarEnums {
       val toStringDef = toStringMethLit(name.toString)
       val impl1 = cpy.Template(impl)(body = List(ordinalDef, toStringDef) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
-      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | EnumValue)
+      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | EnumValue.toFlags)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }
   }
@@ -302,7 +302,7 @@ object DesugarEnums {
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Simple)
       val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
-      val vdef = ValDef(name, enumClassRef, creator).withMods(mods | EnumValue)
+      val vdef = ValDef(name, enumClassRef, creator).withMods(mods | EnumValue.toFlags)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }
 }

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

@@ -611,9 +611,6 @@ object Flags {
   /** Labeled `private`, or `final` */
   final val EffectivelyFinalFlags: FlagSet = Private | Final
 
-  /** An enum case */
-  final val EnumCase: FlagSet = Enum | Case
-
   /** A private method */
   final val PrivateMethod: FlagConjunction = allOf(Private, Method)
 
@@ -637,7 +634,6 @@ object Flags {
 
   /** An enum case */
   final val EnumCase: FlagConjunction = allOf(Enum, Case)
-  final val EnumCaseVal: FlagConjunction = allOf(Enum, CaseVal)
 
   /** A term parameter or parameter accessor */
   final val TermParamOrAccessor: FlagSet = Param | ParamAccessor

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

@@ -2757,7 +2757,7 @@ object Parsers {
     /** EnumCase = `case' (id ClassConstr [`extends' ConstrApps] | ids)
      */
     def enumCase(start: Offset, mods: Modifiers): DefTree = {
-      val mods1 = mods | EnumCase
+      val mods1 = mods | EnumCase.toFlags
       in.skipCASE()
 
       atSpan(start, nameStart) {

compiler/src/dotty/tools/dotc/transform/CompleteJavaEnums.scala

@@ -112,7 +112,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context): ValDef = {
     val sym = tree.symbol
-    if ((sym.is(EnumValue) || sym.name == nme.DOLLAR_VALUES) && sym.owner.linkedClass.derivesFromJavaEnum)
+    if ((sym.isAll(EnumValue) || sym.name == nme.DOLLAR_VALUES) && sym.owner.linkedClass.derivesFromJavaEnum)
       sym.addAnnotation(Annotations.Annotation(defn.ScalaStaticAnnot))
     tree
   }
@@ -147,7 +147,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
         parents = addEnumConstrArgs(defn.JavaEnumClass, templ.parents, addedSyms.map(ref)),
         body = params ++ addedDefs ++ rest)
     }
-    else if (cls.isAnonymousClass && cls.owner.is(EnumCase) && cls.owner.owner.linkedClass.derivesFromJavaEnum) {
+    else if (cls.isAnonymousClass && cls.owner.isAll(EnumCase) && cls.owner.owner.linkedClass.derivesFromJavaEnum) {
       def rhsOf(name: TermName) =
         templ.body.collect {
           case mdef: DefDef if mdef.name == name => mdef.rhs

compiler/src/dotty/tools/dotc/transform/LazyVals.scala

@@ -74,7 +74,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else {
       val isField = sym.owner.isClass
       if (isField) {
-        if (sym.is(SyntheticModule))
+        if (sym.isAll(SyntheticModule))
           transformSyntheticModule(tree)
         else if (sym.isThreadUnsafe) {
           if (sym.is(Module)) {

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

@@ -893,7 +893,7 @@ trait Implicits { self: Typer =>
             }
             else if (mirroredType.classSymbol.isGenericProduct) {
               val cls = mirroredType.classSymbol
-              val accessors = cls.caseAccessors.filterNot(_.is(PrivateLocal))
+              val accessors = cls.caseAccessors.filterNot(_.isAll(PrivateLocal))
               val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
               val (monoType, elemsType) = mirroredType match {
                 case mirroredType: HKTypeLambda =>