Rename isAll -> isAllOf

Also rename SymDenotaton.is(_, _) to isAllOf

Author: odersky

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

@@ -256,7 +256,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.RefTree =>
-        if (t.symbol.denot.owner.isAll(Flags.JavaEnum)) {
+        if (t.symbol.denot.owner.isAllOf(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)
@@ -477,7 +477,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     // unrelated change.
        ctx.base.settings.YnoGenericSig.value
     || sym.is(Flags.Artifact)
-    || sym.isAll(Flags.LiftedMethod)
+    || sym.isAllOf(Flags.LiftedMethod)
     || sym.is(Flags.Bridge)
   )
 
@@ -689,13 +689,13 @@ 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.isAll(Flags.JavaEnum)
+    def hasEnumFlag: Boolean = sym.isAllOf(Flags.JavaEnum)
     def hasAccessBoundary: Boolean = sym.accessBoundary(defn.RootClass) ne defn.RootClass
     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.isAll(Flags.JavaInterface)) || (sym.is(Flags.Trait))
+      (sym.is(Flags.Abstract)) || (sym.isAllOf(Flags.JavaInterface)) || (sym.is(Flags.Trait))
     def hasModuleFlag: Boolean = sym.is(Flags.Module)
     def isSynchronized: Boolean = sym.is(Flags.Synchronized)
     def isNonBottomSubClass(other: Symbol): Boolean = sym.derivesFrom(other)

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

@@ -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.isAll(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?

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 isAll(fc: FlagConjunction): Boolean = flags.isAll(fc)
+    def isAllOf(fc: FlagConjunction): Boolean = flags.isAllOf(fc)
 
     def | (fs: FlagSet): Modifiers = withFlags(flags | fs)
     def & (fs: FlagSet): Modifiers = withFlags(flags & fs)
@@ -217,7 +217,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       else {
         if (ms.nonEmpty)
           for (m <- ms)
-            assert(flags.isAll(allOf(m.flags)) ||
+            assert(flags.isAllOf(allOf(m.flags)) ||
                    m.isInstanceOf[Mod.Private] && !privateWithin.isEmpty,
                    s"unaccounted modifier: $m in $this when adding $ms")
         copy(mods = ms)

compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -39,7 +39,7 @@ class JavaPlatform extends Platform {
 
   /** Is the SAMType `cls` also a SAM under the rules of the JVM? */
   def isSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
-    cls.isAll(NoInitsTrait) &&
+    cls.isAllOf(NoInitsTrait) &&
     cls.superClass == defn.ObjectClass &&
     cls.directlyInheritedTraits.forall(_.is(NoInits)) &&
     !ExplicitOuter.needsOuterIfReferenced(cls) &&

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

@@ -1152,7 +1152,7 @@ object Denotations {
         case symd: SymDenotation => symd
         case _ => symbol.denot
       }
-      symd.isAll(required) && !symd.isOneOf(excluded)
+      symd.isAllOf(required) && !symd.isOneOf(excluded)
     }
   }
 

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

@@ -64,7 +64,7 @@ object Flags {
     /** Does this flag set have all of the flags in given flag conjunction?
      *  Pre: The intersection of the typeflags of both sets must be non-empty.
      */
-    def isAll(flags: FlagConjunction): Boolean = {
+    def isAllOf(flags: FlagConjunction): Boolean = {
       val fs = bits & flags.bits
       ((fs & KINDFLAGS) != 0 || flags.bits == 0) &&
       (fs >>> TYPESHIFT) == (flags.bits >>> TYPESHIFT)
@@ -74,7 +74,7 @@ object Flags {
      *  and at the same time contain none of the flags in the `butNot` set?
      *  Pre: The intersection of the typeflags of both sets must be non-empty.
      */
-    def isAll(flags: FlagConjunction, butNot: FlagSet): Boolean = isAll(flags) && !is(butNot)
+    def isAllOf(flags: FlagConjunction, butNot: FlagSet): Boolean = isAllOf(flags) && !is(butNot)
 
     def isEmpty: Boolean = (bits & ~KINDFLAGS) == 0
 

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

@@ -207,14 +207,14 @@ 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 isAll(fs: FlagConjunction)(implicit ctx: Context): Boolean =
-      (if (isCurrent(fs.toFlags)) myFlags else flags).isAll(fs)
+    final def isAllOf(fs: FlagConjunction)(implicit ctx: Context): Boolean =
+      (if (isCurrent(fs.toFlags)) 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 is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context): Boolean =
-      (if (isCurrent(fs.toFlags) && isCurrent(butNot)) myFlags else flags).isAll(fs, butNot)
+    final def isAllOf(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context): Boolean =
+      (if (isCurrent(fs.toFlags) && isCurrent(butNot)) myFlags else flags).isAllOf(fs, butNot)
 
     /** The type info, or, if symbol is not yet completed, the completer */
     final def infoOrCompleter: Type = myInfo
@@ -848,7 +848,7 @@ object SymDenotations {
     def isSkolem: Boolean = name == nme.SKOLEM
 
     def isInlineMethod(implicit ctx: Context): Boolean =
-      is(InlineMethod, butNot = Accessor) &&
+      isAllOf(InlineMethod, butNot = Accessor) &&
       !name.isUnapplyName  // unapply methods do not count as inline methods
                            // we need an inline flag on them only do that
                            // reduceProjection gets access to their rhs
@@ -1245,7 +1245,7 @@ object SymDenotations {
     final def accessBoundary(base: Symbol)(implicit ctx: Context): Symbol = {
       val fs = flags
       if (fs.is(Private)) owner
-      else if (fs.isAll(StaticProtected)) defn.RootClass
+      else if (fs.isAllOf(StaticProtected)) defn.RootClass
       else if (privateWithin.exists && !ctx.phase.erasedTypes) privateWithin
       else if (fs.is(Protected)) base
       else defn.RootClass

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

@@ -235,7 +235,7 @@ object Types {
      *  from the ThisType of `symd`'s owner.
      */
     def isArgPrefixOf(symd: SymDenotation)(implicit ctx: Context): Boolean =
-      symd.isAll(ClassTypeParam) && {
+      symd.isAllOf(ClassTypeParam) && {
         this match {
           case tp: ThisType => tp.cls ne symd.owner
           case _ => true
@@ -2149,7 +2149,7 @@ object Types {
       else {
         if (isType) {
           val res =
-            if (currentSymbol.isAll(ClassTypeParam)) argForParam(prefix)
+            if (currentSymbol.isAllOf(ClassTypeParam)) argForParam(prefix)
             else prefix.lookupRefined(name)
           if (res.exists) return res
           if (Config.splitProjections)
@@ -4375,7 +4375,7 @@ object Types {
               //    (x: String): Int
               val approxParams = new ApproximatingTypeMap {
                 def apply(tp: Type): Type = tp match {
-                  case tp: TypeRef if tp.symbol.isAll(ClassTypeParam) && tp.symbol.owner == cls =>
+                  case tp: TypeRef if tp.symbol.isAllOf(ClassTypeParam) && tp.symbol.owner == cls =>
                     tp.info match {
                       case info: AliasingBounds =>
                         mapOver(info.alias)
@@ -4717,7 +4717,7 @@ object Types {
       else pre match {
         case Range(preLo, preHi) =>
           val forwarded =
-            if (tp.symbol.isAll(ClassTypeParam)) expandParam(tp, preHi)
+            if (tp.symbol.isAllOf(ClassTypeParam)) expandParam(tp, preHi)
             else tryWiden(tp, preHi)
           forwarded.orElse(
             range(super.derivedSelect(tp, preLo).loBound, super.derivedSelect(tp, preHi).hiBound))

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

@@ -583,7 +583,7 @@ class ClassfileParser(
           parseExceptions(attrLen)
 
         case tpnme.CodeATTR =>
-          if (sym.owner.isAll(Flags.JavaTrait)) {
+          if (sym.owner.isAllOf(Flags.JavaTrait)) {
             sym.resetFlag(Flags.Deferred)
             sym.owner.resetFlag(Flags.PureInterface)
             ctx.log(s"$sym in ${sym.owner} is a java8+ default method.")

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -120,7 +120,7 @@ object Scala2Unpickler {
       if (tsym.exists) tsym.setFlag(TypeParam)
       else denot.enter(tparam, decls)
     }
-    if (!denot.flagsUNSAFE.isAll(JavaModule)) ensureConstructor(denot.symbol.asClass, decls)
+    if (!denot.flagsUNSAFE.isAllOf(JavaModule)) ensureConstructor(denot.symbol.asClass, decls)
 
     val scalacCompanion = denot.classSymbol.scalacLinkedClass
 
@@ -436,7 +436,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     val owner = readSymbolRef()
 
     var flags = unpickleScalaFlags(readLongNat(), name.isTypeName)
-    if (flags.isAll(DefaultParameter)) {
+    if (flags.isAllOf(DefaultParameter)) {
       // DefaultParameterized flag now on method, not parameter
       //assert(flags.is(Param), s"$name0 in $owner")
       flags = flags &~ DefaultParameterized