One of those annoying patches for which I apolo...

One of those annoying patches for which I apologize in advance. It's a
step toward a better world. Almost all the changes herein are simple
transformations of "x hasFlag FOO" to "x.isFoo", with the remainder
minor cleanups. It's too big to review, so let's say no review:
but I'm still all ears for input on the issues mostly outlined in
HasFlags.scala.

8 files changed, 37 insertions, 37 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index cd10434b3a..432640c37d 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -121,7 +121,7 @@ abstract class GenICode extends SubComponent  {
         addMethodParams(ctx1, vparamss)
         m.native = m.symbol.hasAnnotation(definitions.NativeAttr)
 
-        if (!m.isDeferred && !m.native) {
+        if (!m.isAbstractMethod && !m.native) {
           ctx1 = genLoad(rhs, ctx1, m.returnType);
 
           // reverse the order of the local variables, to match the source-order
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala b/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala
index 53205e26ca..78862a90cb 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala
@@ -120,7 +120,7 @@ abstract class ICodeCheckers {
     def check(m: IMethod) {
       logChecker("\n** Checking method " + m)
       method = m
-      if (!m.isDeferred)
+      if (!m.isAbstractMethod)
         check(m.code)
     }
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
index 8001c30efd..6392131e58 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
@@ -190,10 +190,8 @@ trait Members { self: ICodes =>
     def addHandler(e: ExceptionHandler) = exh ::= e
 
     /** Is this method deferred ('abstract' in Java sense)?
-     *  This differs from sym.isDeferred because the symbol only examines the
-     *  flag, which may not be set in the other covered cases.
      */
-    def isDeferred = (symbol hasFlag DEFERRED) || symbol.owner.isInterface || native
+    def isAbstractMethod = symbol.isDeferred || symbol.owner.isInterface || native
 
     def isStatic: Boolean = symbol.isStaticMember
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Printers.scala b/src/compiler/scala/tools/nsc/backend/icode/Printers.scala
index 7b76183c58..4fbec28fdf 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Printers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Printers.scala
@@ -81,7 +81,7 @@ trait Printers { self: ICodes =>
       print("("); printList(printParam)(m.params, ", "); print(")");
       print(": "); print(m.symbol.info.resultType)
 
-      if (!m.isDeferred) {
+      if (!m.isAbstractMethod) {
         println(" {")
         println("locals: " + m.locals.mkString("", ", ", ""))
         println("startBlock: " + m.code.startBlock)
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
index 1c484c7d8e..b026921ca6 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
@@ -7,8 +7,7 @@
 package scala.tools.nsc
 package backend.icode.analysis
 
-import scala.collection.mutable.{Map, HashMap}
-import scala.tools.nsc.symtab.Flags.DEFERRED
+import scala.collection.mutable.{ Map, HashMap }
 
 /** A modified copy-propagation like analysis. It
  *  is augmented with a record-like value which is used
@@ -508,9 +507,9 @@ abstract class CopyPropagation {
      */
     final def invalidateRecords(state: copyLattice.State) {
       def shouldRetain(sym: Symbol): Boolean = {
-        if (sym.hasFlag(symtab.Flags.MUTABLE))
+        if (sym.isMutable)
           log("dropping binding for " + sym.fullName)
-        !sym.hasFlag(symtab.Flags.MUTABLE)
+        !sym.isMutable
       }
       state.stack = state.stack map { v => v match {
         case Record(cls, bindings) =>
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 230dea2f3b..60c186cb27 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -68,8 +68,8 @@ abstract class GenJVM extends SubComponent {
 
   /** Return the suffix of a class name */
   def moduleSuffix(sym: Symbol) =
-    if (sym.hasFlag(Flags.MODULE) && !sym.isMethod &&
-       !sym.isImplClass && !sym.hasFlag(Flags.JAVA)) "$"
+    if (sym.hasModuleFlag && !sym.isMethod &&
+       !sym.isImplClass && !sym.isJavaDefined) "$"
     else "";
 
 
@@ -260,12 +260,12 @@ abstract class GenJVM extends SubComponent {
         // it must be a top level class (name contains no $s)
         def isCandidateForForwarders(sym: Symbol): Boolean =
           atPhase (currentRun.picklerPhase.next) {
-            !(sym.name.toString contains '$') && (sym hasFlag Flags.MODULE) && !sym.isImplClass && !sym.isNestedClass
+            !(sym.name.toString contains '$') && sym.hasModuleFlag && !sym.isImplClass && !sym.isNestedClass
           }
 
         val lmoc = c.symbol.companionModule
         // add static forwarders if there are no name conflicts; see bugs #363 and #1735
-        if (lmoc != NoSymbol && !c.symbol.hasFlag(Flags.INTERFACE)) {
+        if (lmoc != NoSymbol && !c.symbol.isInterface) {
           if (isCandidateForForwarders(lmoc) && !settings.noForwarders.value) {
             log("Adding static forwarders from '%s' to implementations in '%s'".format(c.symbol, lmoc))
             addForwarders(jclass, lmoc.moduleClass)
@@ -394,7 +394,7 @@ abstract class GenJVM extends SubComponent {
      *   .initialize: if 'annot' is read from pickle, atp might be un-initialized
      */
     private def shouldEmitAnnotation(annot: AnnotationInfo) =
-      (annot.atp.typeSymbol.initialize.hasFlag(Flags.JAVA) &&
+      (annot.atp.typeSymbol.initialize.isJavaDefined &&
        annot.atp.typeSymbol.isNonBottomSubClass(ClassfileAnnotationClass) &&
        annot.args.isEmpty)
 
@@ -491,10 +491,16 @@ abstract class GenJVM extends SubComponent {
       nannots
     }
 
+    private def noGenericSignature(sym: Symbol) = (
+      sym.isSynthetic ||
+      sym.isLiftedMethod ||
+      (sym hasFlag Flags.EXPANDEDNAME) ||
+      // @M don't generate java generics sigs for (members of) implementation classes, as they are monomorphic (TODO: ok?)
+      (sym.ownerChain exists (_.isImplClass))
+    )
     def addGenericSignature(jmember: JMember, sym: Symbol, owner: Symbol) {
-      if (!sym.hasFlag(Flags.EXPANDEDNAME | Flags.SYNTHETIC)
-          && !(sym.isMethod && sym.hasFlag(Flags.LIFTED))
-          && !(sym.ownerChain exists (_.isImplClass))) {  // @M don't generate java generics sigs for (members of) implementation classes, as they are monomorphic (TODO: ok?)
+      if (noGenericSignature(sym)) ()
+      else {
         val memberTpe = atPhase(currentRun.erasurePhase)(owner.thisType.memberInfo(sym))
         // println("addGenericSignature sym: " + sym.fullName + " : " + memberTpe + " sym.info: " + sym.info)
         // println("addGenericSignature: "+ (sym.ownerChain map (x => (x.name, x.isImplClass))))
@@ -576,7 +582,7 @@ abstract class GenJVM extends SubComponent {
           if (outerName.endsWith("$") && isTopLevelModule(innerSym.rawowner))
             outerName = outerName dropRight 1
           var flags = javaFlags(innerSym)
-          if (innerSym.rawowner.hasFlag(Flags.MODULE))
+          if (innerSym.rawowner.hasModuleFlag)
             flags |= ACC_STATIC
 
           innerClassesAttr.addEntry(javaName(innerSym),
@@ -593,7 +599,7 @@ abstract class GenJVM extends SubComponent {
       }
 
     def isStaticModule(sym: Symbol): Boolean = {
-      sym.isModuleClass && !sym.isImplClass && !sym.hasFlag(Flags.LIFTED)
+      sym.isModuleClass && !sym.isImplClass && !sym.isLifted
     }
 
     def genField(f: IField) {
@@ -722,7 +728,7 @@ abstract class GenJVM extends SubComponent {
 
     private def isClosureApply(sym: Symbol): Boolean = {
       (sym.name == nme.apply) &&
-      sym.owner.hasFlag(Flags.SYNTHETIC) &&
+      sym.owner.isSynthetic &&
       sym.owner.tpe.parents.exists { t =>
         val TypeRef(_, sym, _) = t;
         FunctionClass contains sym
@@ -883,7 +889,7 @@ abstract class GenJVM extends SubComponent {
 
       addRemoteException(mirrorMethod, m)
       // only add generic signature if the method is concrete; bug #1745
-      if (!m.hasFlag(Flags.DEFERRED))
+      if (!m.isDeferred)
         addGenericSignature(mirrorMethod, m, module)
 
       val (throws, others) = splitAnnotations(m.annotations, ThrowsClass)
@@ -1125,7 +1131,6 @@ abstract class GenJVM extends SubComponent {
 
           case LOAD_FIELD(field, isStatic) =>
             var owner = javaName(field.owner)
-//            if (field.owner.hasFlag(Flags.MODULE)) owner = owner + "$";
             if (settings.debug.value)
               log("LOAD_FIELD with owner: " + owner +
                   " flags: " + Flags.flagsToString(field.owner.flags))
@@ -1162,7 +1167,7 @@ abstract class GenJVM extends SubComponent {
             jcode.emitASTORE_0()
 
           case STORE_FIELD(field, isStatic) =>
-            val owner = javaName(field.owner) // + (if (field.owner.hasFlag(Flags.MODULE)) "$" else "");
+            val owner = javaName(field.owner)
             if (isStatic)
               jcode.emitPUTSTATIC(owner,
                                   javaName(field),
@@ -1648,8 +1653,7 @@ abstract class GenJVM extends SubComponent {
      *  Synthetic locals are skipped. All variables are method-scoped.
      */
     private def genLocalVariableTable(m: IMethod, jcode: JCode) {
-      var vars = m.locals.filter(l => !l.sym.hasFlag(Flags.SYNTHETIC))
-
+      var vars = m.locals filterNot (_.sym.isSynthetic)
       if (vars.length == 0) return
 
       val pool = jclass.getConstantPool()
@@ -1839,7 +1843,7 @@ abstract class GenJVM extends SubComponent {
 
       mkFlags(
         if (isConsideredPrivate) ACC_PRIVATE else ACC_PUBLIC,
-        if (sym.isDeferred || sym.hasFlag(Flags.ABSTRACT)) ACC_ABSTRACT else 0,
+        if (sym.isDeferred || sym.hasAbstractFlag) ACC_ABSTRACT else 0,
         if (sym.isInterface) ACC_INTERFACE else 0,
         if (sym.isFinal && !sym.enclClass.isInterface && !sym.isClassConstructor) ACC_FINAL else 0,
         if (sym.isStaticMember) ACC_STATIC else 0,
@@ -1858,9 +1862,8 @@ abstract class GenJVM extends SubComponent {
       if (sym.isTrait) sym.info // needed so that the type is up to date
                                 // (erasure may add lateINTERFACE to traits)
 
-      sym.hasFlag(Flags.INTERFACE) ||
-      (sym.hasFlag(Flags.JAVA) &&
-       sym.isNonBottomSubClass(ClassfileAnnotationClass))
+      sym.isInterface ||
+      (sym.isJavaDefined && sym.isNonBottomSubClass(ClassfileAnnotationClass))
     }
 
 
diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
index 87c9b929b5..ad60524485 100644
--- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
+++ b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
@@ -307,7 +307,7 @@ abstract class GenMSIL extends SubComponent {
         log("creating annotations: " + annotations + " for member : " + member)
       for (annot@ AnnotationInfo(typ, annArgs, nvPairs) <- annotations ;
            if annot.isConstant)
-           //!typ.typeSymbol.hasFlag(Flags.JAVA)
+           //!typ.typeSymbol.isJavaDefined
       {
 //        assert(consts.length <= 1,
 //               "too many constant arguments for annotations; "+consts.toString())
@@ -1629,9 +1629,9 @@ abstract class GenMSIL extends SubComponent {
      * not exist in the classpath: the type checker will be very confused.
      */
     def msilName(sym: Symbol): String = {
-      val suffix: String = if (sym.hasFlag(Flags.MODULE) && !sym.isMethod &&
+      val suffix: String = if (sym.hasModuleFlag && !sym.isMethod &&
                                !sym.isImplClass &&
-                               !sym.hasFlag(Flags.JAVA)) "$" else ""
+                               !sym.isJavaDefined) "$" else ""
       // Flags.JAVA: "symbol was not defined by a scala-class" (java, or .net-class)
 
       if (sym == definitions.NothingClass)
@@ -1688,7 +1688,7 @@ abstract class GenMSIL extends SubComponent {
           mf = mf | MethodAttributes.Virtual
           if (sym.isFinal && !getType(sym.owner).IsInterface)
             mf = mf | MethodAttributes.Final
-          if (sym.hasFlag(Flags.DEFERRED) || getType(sym.owner).IsInterface)
+          if (sym.isDeferred || getType(sym.owner).IsInterface)
             mf = mf | MethodAttributes.Abstract
         }
       }
@@ -2049,8 +2049,8 @@ abstract class GenMSIL extends SubComponent {
       val iclass = classes(sym)
 
       for (m <- sym.tpe.nonPrivateMembers
-           if m.owner != definitions.ObjectClass && !m.hasFlag(Flags.PROTECTED) &&
-           m.isMethod && !m.isClassConstructor && !m.isStaticMember && !m.hasFlag(Flags.CASE))
+           if m.owner != definitions.ObjectClass && !m.isProtected &&
+           m.isMethod && !m.isClassConstructor && !m.isStaticMember && !m.isCase)
         {
           if (settings.debug.value)
             log("   Mirroring method: " + m)
diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
index 224893d60b..43eebcb0ad 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
@@ -274,7 +274,7 @@ abstract class DeadCodeElimination extends SubComponent {
     lazy val RuntimePackage = definitions.getModule("scala.runtime")
     /** Is 'sym' a side-effecting method? TODO: proper analysis.  */
     private def isSideEffecting(sym: Symbol): Boolean = {
-      !((sym.isGetter && !sym.hasFlag(Flags.LAZY))
+      !((sym.isGetter && !sym.isLazy)
        || (sym.isConstructor
            && !(sym.owner == method.symbol.owner && method.symbol.isConstructor) // a call to another constructor
            && sym.owner.owner == RuntimePackage.moduleClass)