Drop FlagConjunction

Author: odersky

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 => _}
@@ -881,7 +881,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/dotc/ast/untpd.scala

@@ -187,7 +187,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def is(fs: FlagSet, butNot: FlagSet): Boolean = flags.is(fs, butNot = butNot)
     def isOneOf(fs: FlagSet): Boolean = flags.isOneOf(fs)
     def isOneOf(fs: FlagSet, butNot: FlagSet): Boolean = flags.isOneOf(fs, butNot = butNot)
-    def isAllOf(fc: FlagConjunction): Boolean = flags.isAllOf(fc)
+    def isAllOf(fc: FlagSet): Boolean = flags.isAllOf(fc)
 
     def | (fs: FlagSet): Modifiers = withFlags(flags | fs)
     def & (fs: FlagSet): Modifiers = withFlags(flags & fs)

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

@@ -113,7 +113,7 @@ object Denotations {
     /** Keep only those denotations in this group that have all of the flags in `required`,
      *  but none of the flags in `excluded`.
      */
-    def filterWithFlags(required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): PreDenotation
+    def filterWithFlags(required: FlagSet, excluded: FlagSet)(implicit ctx: Context): PreDenotation
 
     private[this] var cachedPrefix: Type = _
     private[this] var cachedAsSeenFrom: AsSeenFromResult = _
@@ -260,7 +260,7 @@ object Denotations {
      *  flags and no `excluded` flag, and produce a denotation that contains the type of the member
      *  as seen from given prefix `pre`.
      */
-    def findMember(name: Name, pre: Type, required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): Denotation =
+    def findMember(name: Name, pre: Type, required: FlagSet, excluded: FlagSet)(implicit ctx: Context): Denotation =
       info.findMember(name, pre, required, excluded)
 
     /** If this denotation is overloaded, filter with given predicate.
@@ -1108,7 +1108,7 @@ object Denotations {
       if (p(this)) this else NoDenotation
     final def filterDisjoint(denots: PreDenotation)(implicit ctx: Context): SingleDenotation =
       if (denots.exists && denots.matches(this)) NoDenotation else this
-    def filterWithFlags(required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): SingleDenotation =
+    def filterWithFlags(required: FlagSet, excluded: FlagSet)(implicit ctx: Context): SingleDenotation =
       if (required.isEmpty && excluded.isEmpty || compatibleWith(required, excluded)) this else NoDenotation
 
     type AsSeenFromResult = SingleDenotation
@@ -1124,7 +1124,7 @@ object Denotations {
 
     /** Does this denotation have all the `required` flags but none of the `excluded` flags?
      */
-    private def compatibleWith(required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): Boolean = {
+    private def compatibleWith(required: FlagSet, excluded: FlagSet)(implicit ctx: Context): Boolean = {
       val symd: SymDenotation = this match {
         case symd: SymDenotation => symd
         case _ => symbol.denot
@@ -1214,7 +1214,7 @@ object Denotations {
       derivedUnion(denot1 filterWithPredicate p, denot2 filterWithPredicate p)
     def filterDisjoint(denot: PreDenotation)(implicit ctx: Context): PreDenotation =
       derivedUnion(denot1 filterDisjoint denot, denot2 filterDisjoint denot)
-    def filterWithFlags(required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): PreDenotation =
+    def filterWithFlags(required: FlagSet, excluded: FlagSet)(implicit ctx: Context): PreDenotation =
       derivedUnion(denot1.filterWithFlags(required, excluded), denot2.filterWithFlags(required, excluded))
     protected def derivedUnion(denot1: PreDenotation, denot2: PreDenotation) =
       if ((denot1 eq this.denot1) && (denot2 eq this.denot2)) this

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

@@ -135,10 +135,6 @@ object Flags {
 
   def termFlagSet(x: Long) = FlagSet(TERMS | x)
 
-  type FlagConjunction = FlagSet
-  def FlagConjunction(bits: Long) = FlagSet(bits)
-  def termFlagConjunction(x: Long) = FlagConjunction(TERMS | x)
-
   private final val TYPESHIFT = 2
   private final val TERMindex = 0
   private final val TYPEindex = 1
@@ -196,8 +192,6 @@ object Flags {
   /** The empty flag set */
   final val EmptyFlags: FlagSet = FlagSet(0)
 
-  final val EmptyFlagConjunction = FlagConjunction(0)
-
   /** The undefined flag set */
   final val UndefinedFlags: FlagSet = FlagSet(~KINDFLAGS)
 
@@ -589,28 +583,28 @@ object Flags {
   final val EffectivelyFinalFlags: FlagSet = Private | Final
 
   /** A private method */
-  final val PrivateMethod: FlagConjunction = Private | Method
+  final val PrivateMethod: FlagSet = Private | Method
 
   /** A private accessor */
-  final val PrivateAccessor: FlagConjunction = Private | Accessor
+  final val PrivateAccessor: FlagSet = Private | Accessor
 
   /** An inline method */
-  final val InlineMethod: FlagConjunction = Inline | Method
+  final val InlineMethod: FlagSet = Inline | Method
 
   /** An inline by-name parameter proxy */
-  final val InlineByNameProxy: FlagConjunction = InlineProxy | Method
+  final val InlineByNameProxy: FlagSet = InlineProxy | Method
 
   /** An inline parameter */
-  final val InlineParam: FlagConjunction = Inline | Param
+  final val InlineParam: FlagSet = Inline | Param
 
   /** An extension method */
   final val ExtensionMethod = Extension | Method
 
   /** An implied method */
-  final val SyntheticImpliedMethod: FlagConjunction = Synthetic | Implied | Method
+  final val SyntheticImpliedMethod: FlagSet = Synthetic | Implied | Method
 
   /** An enum case */
-  final val EnumCase: FlagConjunction = Enum | Case
+  final val EnumCase: FlagSet = Enum | Case
 
   /** A term parameter or parameter accessor */
   final val TermParamOrAccessor: FlagSet = Param | ParamAccessor
@@ -637,10 +631,10 @@ object Flags {
   final val FinalOrSealed: FlagSet = Final | Sealed
 
   /** A covariant type parameter instance */
-  final val LocalCovariant: FlagConjunction = Local | Covariant
+  final val LocalCovariant: FlagSet = Local | Covariant
 
   /** A contravariant type parameter instance */
-  final val LocalContravariant: FlagConjunction = Local | Contravariant
+  final val LocalContravariant: FlagSet = Local | Contravariant
 
   /** Has defined or inherited default parameters */
   final val HasDefaultParamsFlags: FlagSet = DefaultParameterized | InheritedDefaultParams
@@ -649,74 +643,74 @@ object Flags {
   final val ValidForeverFlags: FlagSet = Package | Permanent | Scala2ExistentialCommon
 
   /** A type parameter of a class or trait */
-  final val ClassTypeParam: FlagConjunction = TypeParam | Private
+  final val ClassTypeParam: FlagSet = TypeParam | Private
 
   /** Is a default parameter in Scala 2*/
-  final val DefaultParameter: FlagConjunction = Param | DefaultParameterized
+  final val DefaultParameter: FlagSet = Param | DefaultParameterized
 
   /** A trait that does not need to be initialized */
-  final val NoInitsTrait: FlagConjunction = Trait | NoInits
+  final val NoInitsTrait: FlagSet = Trait | NoInits
 
   /** A Java interface, potentially with default methods */
-  final val JavaTrait: FlagConjunction = JavaDefined | Trait | NoInits
+  final val JavaTrait: FlagSet = JavaDefined | Trait | NoInits
 
     /** A Java interface */ // TODO when unpickling, reconstitute from context
-  final val JavaInterface: FlagConjunction = JavaDefined | Trait
+  final val JavaInterface: FlagSet = JavaDefined | Trait
 
   /** A Java companion object */
-  final val JavaModule: FlagConjunction = JavaDefined | Module
+  final val JavaModule: FlagSet = JavaDefined | Module
 
   /** A Java companion object */
-  final val JavaProtected: FlagConjunction = JavaDefined | Protected
+  final val JavaProtected: FlagSet = JavaDefined | Protected
 
   /** A Java enum */
-  final val JavaEnum: FlagConjunction = JavaDefined | Enum
+  final val JavaEnum: FlagSet = JavaDefined | Enum
 
   /** A Java enum trait */
-  final val JavaEnumTrait: FlagConjunction = JavaDefined | Enum
+  final val JavaEnumTrait: FlagSet = JavaDefined | Enum
 
   /** A Java enum value */
-  final val JavaEnumValue: FlagConjunction = StableRealizable | JavaStatic | JavaDefined | Enum
+  final val JavaEnumValue: FlagSet = StableRealizable | JavaStatic | JavaDefined | Enum
 
   /** An enum value */
-  final val EnumValue: FlagConjunction = (StableRealizable | JavaStatic | Enum)
+  final val EnumValue: FlagSet = StableRealizable | JavaStatic | Enum
 
   /** Labeled private[this] */
-  final val PrivateLocal: FlagConjunction = Private | Local
+  final val PrivateLocal: FlagSet = Private | Local
 
   /** A private[this] parameter accessor */
-  final val PrivateLocalParamAccessor: FlagConjunction = Private | Local | ParamAccessor
+  final val PrivateLocalParamAccessor: FlagSet = Private | Local | ParamAccessor
 
   /** A parameter forwarder */
-  final val ParamForwarder: FlagConjunction = Method | StableRealizable | ParamAccessor
+  final val ParamForwarder: FlagSet = Method | StableRealizable | ParamAccessor
 
   /** A private[this] parameter */
-  final val PrivateLocalParam: FlagConjunction = Private | Local | Param
+  final val PrivateLocalParam: FlagSet = Private | Local | Param
 
   /** A private parameter accessor */
-  final val PrivateParamAccessor: FlagConjunction = Private | ParamAccessor
+  final val PrivateParamAccessor: FlagSet = Private | ParamAccessor
 
   /** A local parameter */
-  final val ParamAndLocal: FlagConjunction = Param | Local
+  final val ParamAndLocal: FlagSet = Param | Local
 
   /** Labeled protected[this] */
-  final val ProtectedLocal: FlagConjunction = Protected | Local
+  final val ProtectedLocal: FlagSet = Protected | Local
 
-  final val LiftedMethod: FlagConjunction = Lifted | Method
+  final val LiftedMethod: FlagSet = Lifted | Method
 
   /** Java symbol which is `protected` and `static` */
-  final val StaticProtected: FlagConjunction = JavaDefined | Protected | JavaStatic
+  final val StaticProtected: FlagSet = JavaDefined | Protected | JavaStatic
 
-  final val Scala2Trait: FlagConjunction = Scala2x | Trait
+  final val Scala2Trait: FlagSet = Scala2x | Trait
 
-  final val AbstractFinal: FlagConjunction = Abstract | Final
-  final val AbstractSealed: FlagConjunction = Abstract | Sealed
-  final val AbstractAndOverride: FlagConjunction = Abstract | Override
+  final val AbstractFinal: FlagSet = Abstract | Final
+  final val AbstractSealed: FlagSet = Abstract | Sealed
+  final val AbstractAndOverride: FlagSet = Abstract | Override
 
-  final val SyntheticArtifact: FlagConjunction = Synthetic | Artifact
-  final val SyntheticModule: FlagConjunction = Synthetic | Module
-  final val SyntheticTermParam: FlagConjunction = Synthetic | TermParam
-  final val SyntheticTypeParam: FlagConjunction = Synthetic | TypeParam
-  final val SyntheticCase: FlagConjunction = Synthetic | Case
-  final val SyntheticOpaque: FlagConjunction = Synthetic | Opaque
+  final val SyntheticArtifact: FlagSet = Synthetic | Artifact
+  final val SyntheticModule: FlagSet = Synthetic | Module
+  final val SyntheticTermParam: FlagSet = Synthetic | TermParam
+  final val SyntheticTypeParam: FlagSet = Synthetic | TypeParam
+  final val SyntheticCase: FlagSet = Synthetic | Case
+  final val SyntheticOpaque: FlagSet = Synthetic | Opaque
 }

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

@@ -207,13 +207,13 @@ object SymDenotations {
       (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).isOneOf(fs, butNot)
 
     /** Has this denotation all of the flags in `fs` set? */
-    final def isAllOf(fs: FlagConjunction)(implicit ctx: Context): Boolean =
+    final def isAllOf(fs: FlagSet)(implicit ctx: Context): Boolean =
       (if (isCurrent(fs)) myFlags else flags).isAllOf(fs)
 
     /** Has this denotation all of the flags in `fs` set, whereas none of the flags
      *  in `butNot` are set?
      */
-    final def isAllOf(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context): Boolean =
+    final def isAllOf(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context): Boolean =
       (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).isAllOf(fs, butNot)
 
     /** The type info, or, if symbol is not yet completed, the completer */
@@ -1758,7 +1758,7 @@ object SymDenotations {
       else collect(ownDenots, classParents)
     }
 
-    override final def findMember(name: Name, pre: Type, required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): Denotation = {
+    override final def findMember(name: Name, pre: Type, required: FlagSet, excluded: FlagSet)(implicit ctx: Context): Denotation = {
       val raw = if (excluded.is(Private)) nonPrivateMembersNamed(name) else membersNamed(name)
       raw.filterWithFlags(required, excluded).asSeenFrom(pre).toDenot(pre)
     }

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

@@ -514,7 +514,7 @@ object Types {
      */
     @tailrec final def findDecl(name: Name, excluded: FlagSet)(implicit ctx: Context): Denotation = this match {
       case tp: ClassInfo =>
-        tp.decls.denotsNamed(name).filterWithFlags(EmptyFlagConjunction, excluded).toDenot(NoPrefix)
+        tp.decls.denotsNamed(name).filterWithFlags(EmptyFlags, excluded).toDenot(NoPrefix)
       case tp: TypeProxy =>
         tp.underlying.findDecl(name, excluded)
       case err: ErrorType =>
@@ -525,16 +525,16 @@ object Types {
 
     /** The member of this type with the given name  */
     final def member(name: Name)(implicit ctx: Context): Denotation = /*>|>*/ track("member") /*<|<*/ {
-      memberBasedOnFlags(name, required = EmptyFlagConjunction, excluded = EmptyFlags)
+      memberBasedOnFlags(name, required = EmptyFlags, excluded = EmptyFlags)
     }
 
     /** The non-private member of this type with the given name. */
     final def nonPrivateMember(name: Name)(implicit ctx: Context): Denotation = track("nonPrivateMember") {
-      memberBasedOnFlags(name, required = EmptyFlagConjunction, excluded = Flags.Private)
+      memberBasedOnFlags(name, required = EmptyFlags, excluded = Flags.Private)
     }
 
     /** The member with given `name` and required and/or excluded flags */
-    final def memberBasedOnFlags(name: Name, required: FlagConjunction = EmptyFlagConjunction, excluded: FlagSet = EmptyFlags)(implicit ctx: Context): Denotation = {
+    final def memberBasedOnFlags(name: Name, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(implicit ctx: Context): Denotation = {
       // We need a valid prefix for `asSeenFrom`
       val pre = this match {
         case tp: ClassInfo => tp.appliedRef
@@ -547,7 +547,7 @@ object Types {
      *  flags and no `excluded` flag and produce a denotation that contains
      *  the type of the member as seen from given prefix `pre`.
      */
-    final def findMember(name: Name, pre: Type, required: FlagConjunction = EmptyFlagConjunction, excluded: FlagSet = EmptyFlags)(implicit ctx: Context): Denotation = {
+    final def findMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(implicit ctx: Context): Denotation = {
       @tailrec def go(tp: Type): Denotation = tp match {
         case tp: TermRef =>
           go (tp.underlying match {
@@ -808,7 +808,7 @@ object Types {
     }
 
     /** The set of members of this type that have all of `required` flags but none of `excluded` flags set. */
-    final def membersBasedOnFlags(required: FlagConjunction, excluded: FlagSet)(implicit ctx: Context): Seq[SingleDenotation] = track("membersBasedOnFlags") {
+    final def membersBasedOnFlags(required: FlagSet, excluded: FlagSet)(implicit ctx: Context): Seq[SingleDenotation] = track("membersBasedOnFlags") {
       memberDenots(takeAllFilter,
         (name, buf) => buf ++= memberBasedOnFlags(name, required, excluded).alternatives)
     }

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

@@ -629,8 +629,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     /** does the companion object of the given symbol have custom unapply */
     def hasCustomUnapply(sym: Symbol): Boolean = {
       val companion = sym.companionModule
-      companion.findMember(nme.unapply, NoPrefix, required = EmptyFlagConjunction, excluded = Synthetic).exists ||
-        companion.findMember(nme.unapplySeq, NoPrefix, required = EmptyFlagConjunction, excluded = Synthetic).exists
+      companion.findMember(nme.unapply, NoPrefix, required = EmptyFlags, excluded = Synthetic).exists ||
+        companion.findMember(nme.unapplySeq, NoPrefix, required = EmptyFlags, excluded = Synthetic).exists
     }
 
     def doShow(s: Space, mergeList: Boolean = false): String = s match {

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

@@ -45,7 +45,7 @@ trait NamerContextOps { this: Context =>
 
   /** The denotation with the given `name` and all `required` flags in current context
    */
-  def denotNamed(name: Name, required: FlagConjunction = EmptyFlagConjunction): Denotation =
+  def denotNamed(name: Name, required: FlagSet = EmptyFlags): Denotation =
     if (owner.isClass)
       if (outer.owner == owner) { // inner class scope; check whether we are referring to self
         if (scope.size == 1) {

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

@@ -53,7 +53,7 @@ trait TypeAssigner {
     def addRefinement(parent: Type, decl: Symbol) = {
       val inherited =
         parentType.findMember(decl.name, cls.thisType,
-          required = EmptyFlagConjunction, excluded = Private)
+          required = EmptyFlags, excluded = Private)
           .suchThat(decl.matches(_))
       val inheritedInfo = inherited.info
       val isPolyFunctionApply = decl.name == nme.apply && (parent <:< defn.PolyFunctionType)

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

@@ -122,7 +122,7 @@ class Typer extends Namer
    *   @param required   flags the result's symbol must have
    *   @param posd       indicates position to use for error reporting
    */
-  def findRef(name: Name, pt: Type, required: FlagConjunction, posd: Positioned)(implicit ctx: Context): Type = {
+  def findRef(name: Name, pt: Type, required: FlagSet, posd: Positioned)(implicit ctx: Context): Type = {
     val refctx = ctx
     val noImports = ctx.mode.is(Mode.InPackageClauseName)
 
@@ -394,7 +394,7 @@ class Typer extends Namer
       unimported = Set.empty
       foundUnderScala2 = NoType
       try {
-        var found = findRef(name, pt, EmptyFlagConjunction, tree.posd)
+        var found = findRef(name, pt, EmptyFlags, tree.posd)
         if (foundUnderScala2.exists && !(foundUnderScala2 =:= found)) {
           ctx.migrationWarning(
             ex"""Name resolution will change.