Refactor FlagSet

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

@@ -3,7 +3,7 @@ package dotty.tools.backend.jvm
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc
-import dotty.tools.dotc.core.Flags.{termFlagSet, termFlagConjunction}
+import dotty.tools.dotc.core.Flags.{termFlagSet}
 import dotty.tools.dotc.transform.{Erasure, GenericSignatures}
 import dotty.tools.dotc.transform.SymUtils._
 import java.io.{File => _}
@@ -256,12 +256,12 @@ 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.RefTree =>
-        if (t.symbol.denot.owner.is(Flags.JavaEnum)) {
+        if (t.symbol.denot.owner.isAllOf(Flags.JavaEnumTrait)) {
           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)
         } else {
-            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flags}")
+            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flagsString}")
             assert(toDenot(t.symbol).name.is(DefaultGetterName),
               s"${toDenot(t.symbol).name.debugString}") // this should be default getter. do not emit.
         }
@@ -477,7 +477,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     // unrelated change.
        ctx.base.settings.YnoGenericSig.value
     || sym.is(Flags.Artifact)
-    || sym.is(Flags.LiftedMethod)
+    || sym.isAllOf(Flags.LiftedMethod)
     || sym.is(Flags.Bridge)
   )
 
@@ -658,50 +658,49 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isConstructor: Boolean = toDenot(sym).isConstructor
     def isExpanded: Boolean = sym.name.is(ExpandedName)
     def isAnonymousFunction: Boolean = toDenot(sym).isAnonymousFunction
-    def isMethod: Boolean = sym is Flags.Method
-    def isPublic: Boolean =  sym.flags.is(Flags.EmptyFlags, Flags.Private | Flags.Protected)
-    def isSynthetic: Boolean = sym is Flags.Synthetic
-    def isPackageClass: Boolean = sym is Flags.PackageClass
-    def isModuleClass: Boolean = sym is Flags.ModuleClass
-    def isModule: Boolean = sym is Flags.Module
+    def isMethod: Boolean = sym.is(Flags.Method)
+    def isPublic: Boolean = !sym.flags.isOneOf(Flags.Private | Flags.Protected)
+    def isSynthetic: Boolean = sym.is(Flags.Synthetic)
+    def isPackageClass: Boolean = sym.is(Flags.PackageClass)
+    def isModuleClass: Boolean = sym.is(Flags.ModuleClass)
+    def isModule: Boolean = sym.is(Flags.Module)
     def isStrictFP: Boolean = false // todo: implement
-    def isLabel: Boolean = sym is Flags.Label
-    def hasPackageFlag: Boolean = sym is Flags.Package
-    def isInterface: Boolean = (sym is Flags.PureInterface) || (sym is Flags.Trait)
+    def isLabel: Boolean = sym.is(Flags.Label)
+    def hasPackageFlag: Boolean = sym.is(Flags.Package)
+    def isInterface: Boolean = (sym.is(Flags.PureInterface)) || (sym.is(Flags.Trait))
     def isGetter: Boolean = toDenot(sym).isGetter
     def isSetter: Boolean = toDenot(sym).isSetter
     def isGetClass: Boolean = sym eq defn.Any_getClass
-    def isJavaDefined: Boolean = sym is Flags.JavaDefined
-    def isJavaDefaultMethod: Boolean = !((sym is Flags.Deferred)  || toDenot(sym).isClassConstructor)
-    def isDeferred: Boolean = sym is Flags.Deferred
-    def isPrivate: Boolean = sym is Flags.Private
+    def isJavaDefined: Boolean = sym.is(Flags.JavaDefined)
+    def isJavaDefaultMethod: Boolean = !((sym.is(Flags.Deferred))  || toDenot(sym).isClassConstructor)
+    def isDeferred: Boolean = sym.is(Flags.Deferred)
+    def isPrivate: Boolean = sym.is(Flags.Private)
     def getsJavaFinalFlag: Boolean =
-      isFinal &&  !toDenot(sym).isClassConstructor && !(sym is Flags.Mutable) &&  !(sym.enclosingClass is Flags.Trait)
+      isFinal &&  !toDenot(sym).isClassConstructor && !(sym.is(Flags.Mutable)) &&  !(sym.enclosingClass.is(Flags.Trait))
 
     def getsJavaPrivateFlag: Boolean =
       isPrivate //|| (sym.isPrimaryConstructor && sym.owner.isTopLevelModuleClass)
 
-    def isFinal: Boolean = sym is Flags.Final
+    def isFinal: Boolean = sym.is(Flags.Final)
     def isStaticMember: Boolean = (sym ne NoSymbol) &&
-      ((sym is Flags.JavaStatic) || toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot))
+      (sym.is(Flags.JavaStatic) || toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot))
       // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
     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.JavaEnum
+    def isBridge: Boolean = sym.is(Flags.Bridge)
+    def isArtifact: Boolean = sym.is(Flags.Artifact)
+    def hasEnumFlag: Boolean = sym.isAllOf(Flags.JavaEnumTrait)
     def hasAccessBoundary: Boolean = sym.accessBoundary(defn.RootClass) ne defn.RootClass
-    def isVarargsMethod: Boolean = sym is Flags.JavaVarargs
+    def isVarargsMethod: Boolean = sym.is(Flags.JavaVarargs)
     def isDeprecated: Boolean = false
-    def isMutable: Boolean = sym is Flags.Mutable
-    def hasAbstractFlag: Boolean =
-      (sym is Flags.Abstract) || (sym is Flags.JavaInterface) || (sym is Flags.Trait)
-    def hasModuleFlag: Boolean = sym is Flags.Module
-    def isSynchronized: Boolean = sym is Flags.Synchronized
+    def isMutable: Boolean = sym.is(Flags.Mutable)
+    def hasAbstractFlag: Boolean = sym.isOneOf(Flags.AbstractOrTrait)
+    def hasModuleFlag: Boolean = sym.is(Flags.Module)
+    def isSynchronized: Boolean = sym.is(Flags.Synchronized)
     def isNonBottomSubClass(other: Symbol): Boolean = sym.derivesFrom(other)
     def hasAnnotation(ann: Symbol): Boolean = toDenot(sym).hasAnnotation(ann)
     def shouldEmitForwarders: Boolean =
-      (sym is Flags.Module) && sym.isStatic
+      (sym.is(Flags.Module)) && sym.isStatic
     def isJavaEntryPoint: Boolean = CollectEntryPoints.isJavaEntryPoint(sym)
     def isEnum = sym.is(Flags.Enum)
 
@@ -713,7 +712,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
      * for such objects will get a MODULE$ flag and a corresponding static initializer.
      */
     def isStaticModuleClass: Boolean =
-      (sym is Flags.Module) && {
+      (sym.is(Flags.Module)) && {
         // scalac uses atPickling here
         // this would not work if modules are created after pickling
         // for example by specialization
@@ -736,7 +735,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def superClass: Symbol =  {
       val t = toDenot(sym).asClass.superClass
       if (t.exists) t
-      else if (sym is Flags.ModuleClass) {
+      else if (sym.is(Flags.ModuleClass)) {
         // workaround #371
 
         println(s"Warning: mocking up superclass for $sym")
@@ -749,7 +748,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def linkedClass: Symbol = toDenot(sym)(ctx).linkedClass(ctx) //exitingPickler(sym.linkedClassOfClass)
     def companionClass: Symbol = toDenot(sym).companionClass
     def companionModule: Symbol = toDenot(sym).companionModule
-    def companionSymbol: Symbol = if (sym is Flags.Module) companionClass else companionModule
+    def companionSymbol: Symbol = if (sym.is(Flags.Module)) companionClass else companionModule
     def moduleClass: Symbol = toDenot(sym).moduleClass
     def enclosingClassSym: Symbol = {
       if (this.isClass) {
@@ -859,7 +858,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   implicit def typeHelper(tp: Type): TypeHelper = new TypeHelper {
     def member(string: Name): Symbol = tp.member(string.toTermName).symbol
 
-    def isFinalType: Boolean = tp.typeSymbol is Flags.Final //in scalac checks for type parameters. Why? Aren't they gone by backend?
+    def isFinalType: Boolean = tp.typeSymbol.is(Flags.Final) //in scalac checks for type parameters. Why? Aren't they gone by backend?
 
     def underlying: Type = tp match {
       case t: TypeProxy => t.underlying
@@ -881,7 +880,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def =:=(other: Type): Boolean = tp =:= other
 
     def membersBasedOnFlags(excludedFlags: Flags, requiredFlags: Flags): List[Symbol] =
-      tp.membersBasedOnFlags(termFlagConjunction(requiredFlags), termFlagSet(excludedFlags)).map(_.symbol).toList
+      tp.membersBasedOnFlags(termFlagSet(requiredFlags), termFlagSet(excludedFlags)).map(_.symbol).toList
 
     def resultType: Type = tp.resultType
 

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -447,7 +447,7 @@ class JSCodeGen()(implicit ctx: Context) {
         "genClassFields called with a ClassDef other than the current one")
 
     // Term members that are neither methods nor modules are fields
-    classSym.info.decls.filter(f => !f.is(Method | Module) && f.isTerm).map({ f =>
+    classSym.info.decls.filter(f => !f.isOneOf(Method | Module) && f.isTerm).map({ f =>
       implicit val pos = f.span
 
       val name =
@@ -540,7 +540,7 @@ class JSCodeGen()(implicit ctx: Context) {
       implicit pos: SourcePosition): Option[js.Tree] = {
     val ctors =
       if (sym.is(Abstract)) Nil
-      else sym.info.member(nme.CONSTRUCTOR).alternatives.map(_.symbol).filter(m => !m.is(Private | Protected))
+      else sym.info.member(nme.CONSTRUCTOR).alternatives.map(_.symbol).filter(m => !m.isOneOf(Private | Protected))
 
     if (ctors.isEmpty) {
       None

compiler/src/dotty/tools/backend/sjs/JUnitBootstrappers.scala

@@ -128,7 +128,7 @@ class JUnitBootstrappers extends MiniPhase {
 
     def isTestClass(sym: Symbol): Boolean = {
       sym.isClass &&
-      !sym.is(ModuleClass | Abstract | Trait) &&
+      !sym.isOneOf(ModuleClass | Abstract | Trait) &&
       hasTests(sym.asClass)
     }
 

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

@@ -90,10 +90,10 @@ object desugar {
      *  in apply/unapply methods.
      */
     override def ensureCompletions(implicit ctx: Context): Unit =
-      if (!(ctx.owner is Package))
+      if (!ctx.owner.is(Package))
         if (ctx.owner.isClass) {
           ctx.owner.ensureCompleted()
-          if (ctx.owner is ModuleClass)
+          if (ctx.owner.is(ModuleClass))
             ctx.owner.linkedClass.ensureCompleted()
         }
         else ensureCompletions(ctx.outer)
@@ -159,7 +159,7 @@ object desugar {
     val vdef @ ValDef(name, tpt, rhs) = transformQuotedPatternName(vdef0)
     val mods = vdef.mods
     val setterNeeded =
-      (mods is Mutable) && ctx.owner.isClass && (!(mods is PrivateLocal) || (ctx.owner is Trait))
+      mods.is(Mutable) && ctx.owner.isClass && (!mods.isAllOf(PrivateLocal) || ctx.owner.is(Trait))
     if (setterNeeded) {
       // TODO: copy of vdef as getter needed?
       // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?
@@ -174,15 +174,15 @@ object desugar {
         vparamss = (setterParam :: Nil) :: Nil,
         tpt      = TypeTree(defn.UnitType),
         rhs      = setterRhs
-      ).withMods((mods | Accessor) &~ (CaseAccessor | ImplicitOrGiven | Lazy))
+      ).withMods((mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
       Thicket(vdef, setter)
     }
     else vdef
   }
 
   def makeImplicitParameters(tpts: List[Tree], implicitFlag: FlagSet, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
-       val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
+       val paramFlags: FlagSet = if (forPrimaryConstructor) LocalParamAccessor else Param
        val epname = EvidenceParamName.fresh()
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
     }
@@ -323,7 +323,7 @@ object desugar {
         meth
       case evidenceParams =>
         val vparamss1 = meth.vparamss.reverse match {
-          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods is ImplicitOrGiven =>
+          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods.isOneOf(GivenOrImplicit) =>
             ((evidenceParams ++ vparams) :: rvparamss).reverse
           case _ =>
             meth.vparamss :+ evidenceParams
@@ -334,7 +334,7 @@ object desugar {
   /** The implicit evidence parameters of `meth`, as generated by `desugar.defDef` */
   private def evidenceParams(meth: DefDef)(implicit ctx: Context): List[ValDef] =
     meth.vparamss.reverse match {
-      case (vparams @ (vparam :: _)) :: _ if vparam.mods is ImplicitOrGiven =>
+      case (vparams @ (vparam :: _)) :: _ if vparam.mods.isOneOf(GivenOrImplicit) =>
         vparams.dropWhile(!_.name.is(EvidenceParamName))
       case _ =>
         Nil
@@ -345,7 +345,7 @@ object desugar {
   private def toDefParam(tparam: TypeDef): TypeDef =
     tparam.withMods(tparam.rawMods & EmptyFlags | Param)
   private def toDefParam(vparam: ValDef): ValDef =
-    vparam.withMods(vparam.rawMods & (ImplicitOrGiven | Erased) | Param)
+    vparam.withMods(vparam.rawMods & (GivenOrImplicit | Erased) | Param)
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -413,7 +413,7 @@ object desugar {
         if (isCaseClass && originalTparams.isEmpty)
           ctx.error(CaseClassMissingParamList(cdef), namePos)
         ListOfNil
-      } else if (isCaseClass && originalVparamss.head.exists(_.mods.is(ImplicitOrGiven))) {
+      } else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(GivenOrImplicit))) {
           ctx.error("Case classes should have a non-implicit parameter list", namePos)
         ListOfNil
       }
@@ -444,7 +444,7 @@ object desugar {
         if (enumCases.isEmpty)
           ctx.error("Enumerations must constain at least one case", namePos)
         val enumCompanionRef = new TermRefTree()
-        val enumImport = Import(importImplied = false, enumCompanionRef, enumCases.flatMap(caseIds))
+        val enumImport = Import(importDelegate = false, enumCompanionRef, enumCases.flatMap(caseIds))
         (enumImport :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)
@@ -508,7 +508,7 @@ object desugar {
     // new C[Ts](paramss)
     lazy val creatorExpr = {
       val vparamss = constrVparamss match {
-        case (vparam :: _) :: _ if vparam.mods.is(ImplicitOrGiven) => // add a leading () to match class parameters
+        case (vparam :: _) :: _ if vparam.mods.isOneOf(GivenOrImplicit) => // add a leading () to match class parameters
           Nil :: constrVparamss
         case _ =>
           constrVparamss
@@ -658,7 +658,7 @@ object desugar {
         def widenedCreatorExpr =
           (creatorExpr /: widenDefs)((rhs, meth) => Apply(Ident(meth.name), rhs :: Nil))
         val applyMeths =
-          if (mods is Abstract) Nil
+          if (mods.is(Abstract)) Nil
           else {
             val copiedFlagsMask = DefaultParameterized | (copiedAccessFlags & Private)
             val appMods = {
@@ -703,9 +703,9 @@ object desugar {
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
     //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =
     val implicitWrappers =
-      if (!mods.is(ImplicitOrImplied))
+      if (!mods.isOneOf(DelegateOrImplicit))
         Nil
-      else if (ctx.owner is Package) {
+      else if (ctx.owner.is(Package)) {
         ctx.error(TopLevelImplicitClass(cdef), cdef.sourcePos)
         Nil
       }
@@ -717,7 +717,7 @@ object desugar {
         ctx.error(ImplicitCaseClass(cdef), cdef.sourcePos)
         Nil
       }
-      else if (arity != 1 && !mods.is(Implied)) {
+      else if (arity != 1 && !mods.is(Delegate)) {
         ctx.error(ImplicitClassPrimaryConstructorArity(), cdef.sourcePos)
         Nil
       }
@@ -731,7 +731,7 @@ object desugar {
         // implicit wrapper is typechecked in same scope as constructor, so
         // we can reuse the constructor parameters; no derived params are needed.
         DefDef(className.toTermName, constrTparams, defParamss, classTypeRef, creatorExpr)
-          .withMods(companionMods | mods.flags.toTermFlags & ImplicitOrImplied | Synthetic | Final)
+          .withMods(companionMods | mods.flags.toTermFlags & DelegateOrImplicit | Synthetic | Final)
           .withSpan(cdef.span) :: Nil
       }
 
@@ -792,7 +792,7 @@ object desugar {
     if (mods.is(Final) && !mods.is(Synthetic))
       ctx.warning(em"${hl("final")} modifier is redundant for objects", flagSourcePos(Final))
 
-    if (mods is Package)
+    if (mods.is(Package))
       PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
     else if (isEnumCase) {
       typeParamIsReferenced(enumClass.typeParams, Nil, Nil, impl.parents)
@@ -982,7 +982,7 @@ object desugar {
           val restDefs =
             for (((named, tpt), n) <- vars.zipWithIndex if named.name != nme.WILDCARD)
             yield
-              if (mods is Lazy) derivedDefDef(original, named, tpt, selector(n), mods &~ Lazy)
+              if (mods.is(Lazy)) derivedDefDef(original, named, tpt, selector(n), mods &~ Lazy)
               else derivedValDef(original, named, tpt, selector(n), mods)
           flatTree(firstDef :: restDefs)
       }
@@ -1016,9 +1016,9 @@ object desugar {
     case tree: MemberDef =>
       var tested: MemberDef = tree
       def fail(msg: String) = ctx.error(msg, tree.sourcePos)
-      def checkApplicable(flag: FlagSet, test: MemberDefTest): Unit =
+      def checkApplicable(flag: Flag, test: MemberDefTest): Unit =
         if (tested.mods.is(flag) && !test.applyOrElse(tree, (md: MemberDef) => false)) {
-          fail(i"modifier `$flag` is not allowed for this definition")
+          fail(i"modifier `${flag.flagsString}` is not allowed for this definition")
           tested = tested.withMods(tested.mods.withoutFlags(flag))
         }
       checkApplicable(Opaque, legalOpaque)
@@ -1109,8 +1109,8 @@ object desugar {
     def needsObject(stat: Tree) = stat match {
       case _: ValDef | _: PatDef | _: DefDef | _: Export => true
       case stat: ModuleDef =>
-        stat.mods.is(ImplicitOrImplied) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
-      case stat: TypeDef => !stat.isClassDef || stat.mods.is(ImplicitOrImplied)
+        stat.mods.isOneOf(DelegateOrImplicit) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+      case stat: TypeDef => !stat.isClassDef || stat.mods.isOneOf(DelegateOrImplicit)
       case _ => false
     }
     val (nestedStats, topStats) = pdef.stats.partition(needsObject)