diff options
author | Paul Phillips <paulp@improving.org> | 2010-11-02 16:49:45 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2010-11-02 16:49:45 +0000 |
commit | 8e320487627e85cce44a4eab0d77d28fd0904d50 (patch) | |
tree | 4ec432f0c3566e5b4d70aebe1bc9266cf006efd0 /src | |
parent | 543d70e30c153522eedb986755ae3a5de8d820c6 (diff) | |
download | scala-8e320487627e85cce44a4eab0d77d28fd0904d50.tar.gz scala-8e320487627e85cce44a4eab0d77d28fd0904d50.tar.bz2 scala-8e320487627e85cce44a4eab0d77d28fd0904d50.zip |
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.
Diffstat (limited to 'src')
53 files changed, 333 insertions, 341 deletions
diff --git a/src/attic/scala/tools/nsc/models/Models.scala b/src/attic/scala/tools/nsc/models/Models.scala index 7365709b25..e30b8bac02 100644 --- a/src/attic/scala/tools/nsc/models/Models.scala +++ b/src/attic/scala/tools/nsc/models/Models.scala @@ -84,7 +84,7 @@ abstract class Models { } } else { val ddef = tree.asInstanceOf[ValOrDefDef]; - if (ddef.mods.hasFlag(symtab.Flags.MUTABLE)) VAR; + if (ddef.mods.isMutable) VAR; else VAL; } } diff --git a/src/attic/scala/tools/nsc/models/SemanticTokens.scala b/src/attic/scala/tools/nsc/models/SemanticTokens.scala index ab75bbbcfc..badbcecd77 100644 --- a/src/attic/scala/tools/nsc/models/SemanticTokens.scala +++ b/src/attic/scala/tools/nsc/models/SemanticTokens.scala @@ -234,7 +234,7 @@ class SemanticTokens(val compiler: Global) { build(tree.impl.parents) build(tree.impl.body) case tree: ValOrDefDef => - if (!tree.symbol.hasFlag(Flags.ACCESSOR) || tree.symbol.hasFlag(DEFERRED)) { + if (!tree.symbol.hasAccessorFlag || tree.symbol.isDeferred) { // MO: I added !tree.symbol.hasFlag(DEFERRED) in a refactoring where // getters now can be abstract whereas before they could not. // Adding the condition thus keeps the old behavior. @@ -244,9 +244,9 @@ class SemanticTokens(val compiler: Global) { eatKeywords(unit.source.asInstanceOf[BatchSourceFile], tree.pos.point); if (false) Console.err.println("VALDEF: tree=" + tree + " sym=" + tree.symbol + " pos0=" + tree.symbol.pos + " alias=" + tree.symbol.alias + " pos1=" + - pos + " pos2=" + tree.pos.dbgString + " " + tree.symbol.hasFlag(Flags.SYNTHETIC)); + pos + " pos2=" + tree.pos.dbgString + " " + tree.symbol.isSynthetic); - if (pos != -1 && !tree.hasFlag(Flags.SYNTHETIC)) + if (pos != -1 && !tree.isSynthetic) buildDef(tree.symbol, pos); } @@ -496,7 +496,7 @@ class SemanticTokens(val compiler: Global) { def buildDef(term: Symbol, pos: Int) = buildSym(term, pos, true, null) def buildSym(term: Symbol, pos: Int, isDef: Boolean, tpe: Type): Unit = - if (term.hasFlag(Flags.ACCESSOR)) + if (term.hasAccessorFlag) buildSym(analyzer.underlying(term), pos, isDef, tpe) else if (pos == -1) { //Console.err.println("NOPOS: " + term) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 2f9b63eead..12fbad6adb 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -959,7 +959,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable private def writeICode() { val printer = new icodes.TextPrinter(null, icodes.linearizer) icodes.classes.values.foreach((cls) => { - val suffix = if (cls.symbol hasFlag Flags.MODULE) "$.icode" else ".icode" + val suffix = if (cls.symbol.hasModuleFlag) "$.icode" else ".icode" var file = getFile(cls.symbol, suffix) // if (file.exists()) // file = new File(file.getParentFile(), file.getName() + "1") diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala index a28bb7d17d..17f543f8e3 100644 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ b/src/compiler/scala/tools/nsc/Interpreter.scala @@ -674,7 +674,7 @@ class Interpreter(val settings: Settings, out: PrintWriter) { } def boundNames: List[Name] = Nil val definesImplicit = cond(member) { - case tree: MemberDef => tree.mods hasFlag Flags.IMPLICIT + case tree: MemberDef => tree.mods.isImplicit } def generatesValue: Option[Name] = None @@ -690,7 +690,6 @@ class Interpreter(val settings: Settings, out: PrintWriter) { val maxStringElements = 1000 // no need to mkString billions of elements lazy val ValDef(mods, vname, _, _) = member lazy val prettyName = NameTransformer.decode(vname) - lazy val isLazy = mods hasFlag Flags.LAZY override lazy val boundNames = List(vname) override def generatesValue = Some(vname) @@ -702,7 +701,7 @@ class Interpreter(val settings: Settings, out: PrintWriter) { lazy val extractor = "scala.runtime.ScalaRunTime.stringOf(%s, %s)".format(req fullPath vname, maxStringElements) // if this is a lazy val we avoid evaluating it here - val resultString = if (isLazy) codegenln(false, "<lazy>") else extractor + val resultString = if (mods.isLazy) codegenln(false, "<lazy>") else extractor val codeToPrint = """ + "%s: %s = " + %s""".format(prettyName, string2code(req typeOf vname), resultString) @@ -752,7 +751,7 @@ class Interpreter(val settings: Settings, out: PrintWriter) { private class ClassHandler(classdef: ClassDef) extends MemberHandler(classdef) { lazy val ClassDef(mods, name, _, _) = classdef override lazy val boundNames = - name :: (if (mods hasFlag Flags.CASE) List(name.toTermName) else Nil) + name :: (if (mods.isCase) List(name.toTermName) else Nil) override def resultExtractionCode(req: Request, code: PrintWriter) = code print codegenln("defined %s %s".format(classdef.keyword, name)) diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala index 79ac89e360..01ab14ae9f 100755 --- a/src/compiler/scala/tools/nsc/ast/DocComments.scala +++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala @@ -65,7 +65,7 @@ trait DocComments { self: SymbolTable => */ def expandedDocComment(sym: Symbol, site: Symbol, docStr: String = ""): String = { // when parsing a top level class or module, use the (module-)class itself to look up variable definitions - val site1 = if ((sym.isModule || sym.isClass) && (site hasFlag Flags.PACKAGE)) sym + val site1 = if ((sym.isModule || sym.isClass) && site.hasPackageFlag) sym else site expandVariables(cookedDocComment(sym, docStr), sym, site1) } diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala index 458b87fde4..37c87633e2 100644 --- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala @@ -145,7 +145,7 @@ abstract class NodePrinters { if ((infolevel > InfoLevel.Normal) && !(sym.owner eq definitions.ScalaPackageClass) && !sym.isModuleClass && !sym.isPackageClass && - !sym.hasFlag(JAVA)) { + !sym.isJavaDefined) { val members = for (m <- tree.tpe.decls.toList) yield m.toString() + ": " + m.tpe + ", " buf.append(", tpe.decls=" + members) diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala index a315a81bab..4ca3849553 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala @@ -48,8 +48,8 @@ abstract class TreeInfo { case EmptyTree => true case Import(_, _) => true case TypeDef(_, _, _, _) => true - case DefDef(mods, _, _, _, _, __) => mods.hasFlag(DEFERRED) - case ValDef(mods, _, _, _) => mods.hasFlag(DEFERRED) + case DefDef(mods, _, _, _, _, __) => mods.isDeferred + case ValDef(mods, _, _, _) => mods.isDeferred case DocDef(_, definition) => isInterfaceMember(definition) case _ => false } @@ -64,7 +64,7 @@ abstract class TreeInfo { | DefDef(_, _, _, _, _, _) => true case ValDef(mods, _, _, rhs) => - !mods.hasFlag(MUTABLE) && isPureExpr(rhs) + !mods.isMutable && isPureExpr(rhs) case DocDef(_, definition) => isPureDef(definition) case _ => diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala index 19a7ebbe44..9f2b8b4cbd 100644 --- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala @@ -154,7 +154,7 @@ trait TreePrinters { trees: SymbolTable => printAnnotations(tree) printModifiers(tree, mods) val word = - if (mods.isTrait) "trait" + if (mods.hasTraitFlag) "trait" else if (ifSym(tree, _.isModuleClass)) "object" else "class" diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 1732bb73a3..b3aaf02195 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -10,7 +10,7 @@ package ast.parser import scala.collection.mutable.ListBuffer import util.{ OffsetPosition } -import symtab.Flags +import scala.reflect.generic.{ ModifierFlags => Flags } import Tokens._ //todo verify when stableId's should be just plain qualified type ids @@ -1677,12 +1677,12 @@ self => /* -------- MODIFIERS and ANNOTATIONS ------------------------------------------- */ /** Drop `private' modifier when followed by a qualifier. - * Conract `abstract' and `override' to ABSOVERRIDE + * Contract `abstract' and `override' to ABSOVERRIDE */ private def normalize(mods: Modifiers): Modifiers = - if ((mods hasFlag Flags.PRIVATE) && mods.privateWithin != nme.EMPTY.toTypeName) + if (mods.isPrivate && mods.hasAccessBoundary) normalize(mods &~ Flags.PRIVATE) - else if ((mods hasFlag Flags.ABSTRACT) && (mods hasFlag Flags.OVERRIDE)) + else if (mods hasAllFlags (Flags.ABSTRACT | Flags.OVERRIDE)) normalize(mods &~ (Flags.ABSTRACT | Flags.OVERRIDE) | Flags.ABSOVERRIDE) else mods @@ -1701,7 +1701,7 @@ self => var result = mods if (in.token == LBRACKET) { in.nextToken() - if (mods.privateWithin != nme.EMPTY.toTypeName) + if (mods.hasAccessBoundary) syntaxError("duplicate private/protected qualifier", false) result = if (in.token == THIS) { in.nextToken(); mods | Flags.LOCAL } else Modifiers(mods.flags, ident().toTypeName) @@ -1819,7 +1819,7 @@ self => var mods = Modifiers(Flags.PARAM) if (owner.isTypeName) { mods = modifiers() | Flags.PARAMACCESSOR - if (mods.hasFlag(Flags.LAZY)) syntaxError("lazy modifier not allowed here. Use call-by-name parameters instead", false) + if (mods.isLazy) syntaxError("lazy modifier not allowed here. Use call-by-name parameters instead", false) if (in.token == VAL) { mods = mods withPosition (in.token, tokenRange(in)) in.nextToken() @@ -1846,10 +1846,10 @@ self => } else { // XX-METHOD-INFER accept(COLON) if (in.token == ARROW) { - if (owner.isTypeName && !mods.hasFlag(Flags.LOCAL)) + if (owner.isTypeName && !mods.hasLocalFlag) syntaxError( in.offset, - (if (mods.hasFlag(Flags.MUTABLE)) "`var'" else "`val'") + + (if (mods.isMutable) "`var'" else "`val'") + " parameters may not be call-by-name", false) else if (implicitmod != 0) syntaxError( @@ -1901,7 +1901,7 @@ self => val result = vds.toList if (owner == nme.CONSTRUCTOR && (result.isEmpty || - (!result.head.isEmpty && result.head.head.mods.hasFlag(Flags.IMPLICIT)))) + (!result.head.isEmpty && result.head.head.mods.isImplicit))) if (in.token == LBRACKET) syntaxError(in.offset, "no type parameters allowed here", false) else if(in.token == EOF) @@ -2123,7 +2123,7 @@ self => * | type [nl] TypeDcl */ def defOrDcl(pos: Int, mods: Modifiers): List[Tree] = { - if ((mods hasFlag Flags.LAZY) && in.token != VAL) + if (mods.isLazy && in.token != VAL) syntaxError("lazy not allowed here. Only vals can be lazy", false) in.token match { case VAL => @@ -2163,7 +2163,7 @@ self => val rhs = if (tp.isEmpty || in.token == EQUALS) { accept(EQUALS) - if (!tp.isEmpty && newmods.hasFlag(Flags.MUTABLE) && + if (!tp.isEmpty && newmods.isMutable && (lhs.toList forall (_.isInstanceOf[Ident])) && in.token == USCORE) { in.nextToken() newmods = newmods | Flags.DEFAULTINIT @@ -2182,10 +2182,10 @@ self => if (tp.isEmpty) p else Typed(p, tp) setPos (p.pos union tp.pos), rhs) - if (newmods hasFlag Flags.DEFERRED) { + if (newmods.isDeferred) { trees match { case List(ValDef(_, _, _, EmptyTree)) => - if (mods.hasFlag(Flags.LAZY)) syntaxError(p.pos, "lazy values may not be abstract", false) + if (mods.isLazy) syntaxError(p.pos, "lazy values may not be abstract", false) case _ => syntaxError(p.pos, "pattern definition may not be abstract", false) } } @@ -2349,7 +2349,7 @@ self => * | [override] trait TraitDef */ def tmplDef(pos: Int, mods: Modifiers): Tree = { - if (mods.hasFlag(Flags.LAZY)) syntaxError("classes cannot be lazy", false) + if (mods.isLazy) syntaxError("classes cannot be lazy", false) in.token match { case TRAIT => classDef(pos, (mods | Flags.TRAIT | Flags.ABSTRACT) withPosition (Flags.TRAIT, tokenRange(in))) @@ -2381,16 +2381,16 @@ self => val tparams = typeParamClauseOpt(name, contextBoundBuf) classContextBounds = contextBoundBuf.toList val tstart = (in.offset::classContextBounds.map(_.pos.startOrPoint)).min - if (!classContextBounds.isEmpty && mods.hasFlag(Flags.TRAIT)) { + if (!classContextBounds.isEmpty && mods.hasTraitFlag) { syntaxError("traits cannot have type parameters with context bounds `: ...' nor view bounds `<% ...'", false) classContextBounds = List() } val constrAnnots = annotations(false, true) val (constrMods, vparamss) = - if (mods.hasFlag(Flags.TRAIT)) (Modifiers(Flags.TRAIT), List()) - else (accessModifierOpt(), paramClauses(name, classContextBounds, mods.hasFlag(Flags.CASE))) + if (mods.hasTraitFlag) (Modifiers(Flags.TRAIT), List()) + else (accessModifierOpt(), paramClauses(name, classContextBounds, mods.isCase)) var mods1 = mods - if (mods hasFlag Flags.TRAIT) { + if (mods.hasTraitFlag) { if (settings.YvirtClasses && in.token == SUBTYPE) mods1 |= Flags.DEFERRED } else if (in.token == SUBTYPE) { syntaxError("classes are not allowed to be virtual", false) @@ -2449,7 +2449,7 @@ self => val (self, body) = templateBody(true) if (in.token == WITH && self.isEmpty) { val earlyDefs: List[Tree] = body flatMap { - case vdef @ ValDef(mods, name, tpt, rhs) if !(mods hasFlag Flags.DEFERRED) => + case vdef @ ValDef(mods, name, tpt, rhs) if !mods.isDeferred => List(treeCopy.ValDef(vdef, mods | Flags.PRESUPER, name, tpt, rhs)) case tdef @ TypeDef(mods, name, tparams, rhs) => List(treeCopy.TypeDef(tdef, mods | Flags.PRESUPER, name, tparams, rhs)) @@ -2473,7 +2473,7 @@ self => } def isInterface(mods: Modifiers, body: List[Tree]): Boolean = - (mods hasFlag Flags.TRAIT) && (body forall treeInfo.isInterfaceMember) + mods.hasTraitFlag && (body forall treeInfo.isInterfaceMember) /** ClassTemplateOpt ::= 'extends' ClassTemplate | [['extends'] TemplateBody] * TraitTemplateOpt ::= TraitExtends TraitTemplate | [['extends'] TemplateBody] | '<:' TemplateBody @@ -2482,10 +2482,10 @@ self => def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]], tstart: Int): Template = { val (parents0, argss, self, body) = - if (in.token == EXTENDS || settings.YvirtClasses && (mods hasFlag Flags.TRAIT) && in.token == SUBTYPE) { + if (in.token == EXTENDS || settings.YvirtClasses && mods.hasTraitFlag && in.token == SUBTYPE) { in.nextToken() - template(mods hasFlag Flags.TRAIT) - } else if ((in.token == SUBTYPE) && (mods hasFlag Flags.TRAIT)) { + template(mods.hasTraitFlag) + } else if ((in.token == SUBTYPE) && mods.hasTraitFlag) { in.nextToken() template(true) } else { @@ -2498,7 +2498,7 @@ self => parents = parents ::: List(scalaScalaObjectConstr) if (parents.isEmpty) parents = List(scalaAnyRefConstr) - if (mods.hasFlag(Flags.CASE)) parents = parents ::: List(productConstr) + if (mods.isCase) parents = parents ::: List(productConstr) val tstart0 = if (body.isEmpty && in.lastOffset < tstart) in.lastOffset else tstart atPos(tstart0) { Template(parents, self, constrMods, vparamss, argss, body, o2p(tstart)) 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) diff --git a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala index aa784e9c87..30acdff594 100644 --- a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala +++ b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala @@ -157,7 +157,7 @@ trait DependencyAnalysis extends SubComponent with Files { if ((tree.symbol ne null) && (tree.symbol != NoSymbol) && (!tree.symbol.isPackage) - && (!tree.symbol.hasFlag(Flags.JAVA)) + && (!tree.symbol.isJavaDefined) && ((tree.symbol.sourceFile eq null) || (tree.symbol.sourceFile.path != file.path)) && (!tree.symbol.isClassConstructor)) { @@ -168,7 +168,7 @@ trait DependencyAnalysis extends SubComponent with Files { } tree match { - case cdef: ClassDef if !cdef.symbol.hasFlag(Flags.PACKAGE) && + case cdef: ClassDef if !cdef.symbol.hasPackageFlag && !cdef.symbol.isAnonymousFunction => if (cdef.symbol != NoSymbol) buf += cdef.symbol atPhase(currentRun.erasurePhase.prev) { diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala index 55e9ec0b89..569b0d2a30 100644 --- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala @@ -70,7 +70,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory def isTrait = sym.isTrait def isClass = sym.isClass && !sym.isTrait def isObject = sym.isModule && !sym.isPackage - def isCaseClass = sym.isClass && sym.hasFlag(Flags.CASE) + def isCaseClass = sym.isCaseClass def isRootPackage = false def selfType = if (sym.thisSym eq sym) None else Some(makeType(sym.thisSym.typeOfThis, this)) } @@ -98,7 +98,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory else if (sym.isProtectedLocal) ProtectedInInstance() else { val qual = - if (sym.privateWithin != null && sym.privateWithin != NoSymbol) + if (sym.hasAccessBoundary) Some(makeTemplate(sym.privateWithin)) else None if (sym.isPrivate) PrivateInTemplate(inTpl) @@ -110,7 +110,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory def flags = { val fgs = mutable.ListBuffer.empty[Paragraph] if (sym.isImplicit) fgs += Paragraph(Text("implicit")) - if (sym hasFlag Flags.SEALED) fgs += Paragraph(Text("sealed")) + if (sym.isSealed) fgs += Paragraph(Text("sealed")) if (!sym.isTrait && (sym hasFlag Flags.ABSTRACT)) fgs += Paragraph(Text("abstract")) if (!sym.isTrait && (sym hasFlag Flags.DEFERRED)) fgs += Paragraph(Text("abstract")) if (!sym.isModule && (sym hasFlag Flags.FINAL)) fgs += Paragraph(Text("final")) @@ -392,7 +392,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory Some(new NonTemplateMemberImpl(bSym, inTpl) with Val { override def isVar = true }) - else if (bSym.isMethod && !bSym.isGetterOrSetter && !bSym.isConstructor && !bSym.isModule) + else if (bSym.isMethod && !bSym.hasAccessorFlag && !bSym.isConstructor && !bSym.isModule) Some(new NonTemplateParamMemberImpl(bSym, inTpl) with HigherKindedImpl with Def { override def isDef = true }) @@ -572,12 +572,12 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory } def isNestedObjectLazyVal(aSym: Symbol): Boolean = { - aSym.isLazy && !aSym.isRootPackage && !aSym.owner.isPackageClass && (aSym.lazyAccessor != NoSymbol) + aSym.isLazyAccessor && !aSym.isRootPackage && !aSym.owner.isPackageClass } def isEmptyJavaObject(aSym: Symbol): Boolean = { def hasMembers = aSym.info.members.exists(s => localShouldDocument(s) && (!s.isConstructor || s.owner == aSym)) - aSym.isModule && aSym.hasFlag(Flags.JAVA) && !hasMembers + aSym.isModule && aSym.isJavaDefined && !hasMembers } def localShouldDocument(aSym: Symbol): Boolean = { diff --git a/src/compiler/scala/tools/nsc/interactive/Global.scala b/src/compiler/scala/tools/nsc/interactive/Global.scala index dedd79f634..7cd225b719 100644 --- a/src/compiler/scala/tools/nsc/interactive/Global.scala +++ b/src/compiler/scala/tools/nsc/interactive/Global.scala @@ -444,7 +444,7 @@ self => val locals = new LinkedHashMap[Name, ScopeMember] def addScopeMember(sym: Symbol, pre: Type, viaImport: Tree) = if (!sym.name.decode.containsName(Dollar) && - !sym.hasFlag(Flags.SYNTHETIC) && + !sym.isSynthetic && !locals.contains(sym.name)) { locals(sym.name) = new ScopeMember( sym, diff --git a/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala b/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala index bde90bc347..64b57bcbf3 100644 --- a/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala +++ b/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala @@ -106,8 +106,8 @@ class RefinedBuildManager(val settings: Settings) extends Changes with BuildMana // See if we really have corresponding symbols, not just those // which share the name def isCorrespondingSym(from: Symbol, to: Symbol): Boolean = - (from.hasFlag(Flags.TRAIT) == to.hasFlag(Flags.TRAIT)) && - (from.hasFlag(Flags.MODULE) == to.hasFlag(Flags.MODULE)) + (from.hasTraitFlag == to.hasTraitFlag) && + (from.hasModuleFlag == to.hasModuleFlag) // For testing purposes only, order irrelevant for compilation def toStringSet(set: Set[AbstractFile]): String = @@ -159,7 +159,7 @@ class RefinedBuildManager(val settings: Settings) extends Changes with BuildMana case _ => // a new top level definition changesOf(sym) = - sym.info.parents.filter(_.typeSymbol hasFlag Flags.SEALED).map( + sym.info.parents.filter(_.typeSymbol.isSealed).map( p => changeChangeSet(p.typeSymbol, sym+" extends a sealed "+p.typeSymbol)) } diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index 1f071e2288..1dfab2a98a 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -615,8 +615,8 @@ trait JavaParsers extends JavaScanners { def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: Name): ValDef = { val tpt1 = optArrayBrackets(tpt) - if (in.token == ASSIGN && !(mods hasFlag Flags.PARAM)) skipTo(COMMA, SEMI) - val mods1 = if (mods hasFlag Flags.FINAL) mods &~ Flags.FINAL else mods | Flags.MUTABLE + if (in.token == ASSIGN && !mods.isParameter) skipTo(COMMA, SEMI) + val mods1 = if (mods.isFinal) mods &~ Flags.FINAL else mods | Flags.MUTABLE atPos(pos) { ValDef(mods1, name, tpt1, blankExpr) } @@ -771,7 +771,7 @@ trait JavaParsers extends JavaScanners { } else { if (in.token == ENUM || definesInterface(in.token)) mods |= Flags.STATIC val decls = memberDecl(mods, parentToken) - (if ((mods hasFlag Flags.STATIC) || inInterface && !(decls exists (_.isInstanceOf[DefDef]))) + (if (mods.hasStaticFlag || inInterface && !(decls exists (_.isInstanceOf[DefDef]))) statics else members) ++= decls diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala index 8a0702251d..4b717f209c 100644 --- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala +++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala @@ -110,7 +110,7 @@ trait ParallelMatching extends ast.TreeDSL // tests def isDefined = sym ne NoSymbol def isSimple = tpe.isByte || tpe.isShort || tpe.isChar || tpe.isInt - def isCaseClass = tpe.typeSymbol hasFlag Flags.CASE + def isCaseClass = tpe.typeSymbol.isCase // sequences def seqType = tpe.widen baseType SeqClass diff --git a/src/compiler/scala/tools/nsc/matching/Patterns.scala b/src/compiler/scala/tools/nsc/matching/Patterns.scala index 26ad296614..ec0939c2d6 100644 --- a/src/compiler/scala/tools/nsc/matching/Patterns.scala +++ b/src/compiler/scala/tools/nsc/matching/Patterns.scala @@ -474,7 +474,7 @@ trait Patterns extends ast.TreeDSL { def isSymValid = (sym != null) && (sym != NoSymbol) def isModule = sym.isModule || tpe.termSymbol.isModule - def isCaseClass = tpe.typeSymbol hasFlag Flags.CASE + def isCaseClass = tpe.typeSymbol.isCase def isObject = isSymValid && prefix.isStable // XXX not entire logic def unadorn(t: Tree): Tree = Pattern unadorn t diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 2452081c05..fb1e705a56 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -176,7 +176,7 @@ abstract class SymbolLoaders { def openPackageModule(module: Symbol)(packageClass: Symbol = module.owner): Unit = { // unlink existing symbols in the package for (member <- module.info.decls.iterator) { - if (!member.hasFlag(PRIVATE) && !member.isConstructor) { + if (!member.isPrivate && !member.isConstructor) { // todo: handle overlapping definitions in some way: mark as errors // or treat as abstractions. For now the symbol in the package module takes precedence. for (existing <- packageClass.info.decl(member.name).alternatives) @@ -185,7 +185,7 @@ abstract class SymbolLoaders { } // enter non-private decls the class for (member <- module.info.decls.iterator) { - if (!member.hasFlag(PRIVATE) && !member.isConstructor) { + if (!member.isPrivate && !member.isConstructor) { packageClass.info.decls.enter(member) } } diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 34a9dfa5cd..4bc9477a40 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -337,13 +337,13 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => */ final def isValue = isTerm && !(isModule && hasFlag(PACKAGE | JAVA)) - final def isVariable = isTerm && hasFlag(MUTABLE) && !isMethod + final def isVariable = isTerm && isMutable && !isMethod // interesting only for lambda lift. Captured variables are accessed from inner lambdas. final def isCapturedVariable = isVariable && hasFlag(CAPTURED) - final def isGetter = isTerm && hasFlag(ACCESSOR) && !nme.isSetterName(name) - final def isSetter = isTerm && hasFlag(ACCESSOR) && nme.isSetterName(name) + final def isGetter = isTerm && hasAccessorFlag && !nme.isSetterName(name) + final def isSetter = isTerm && hasAccessorFlag && nme.isSetterName(name) //todo: make independent of name, as this can be forged. final def hasGetter = isTerm && nme.isLocalName(name) @@ -434,7 +434,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => /** Does this symbol denote a stable value? */ final def isStable = isTerm && - !hasFlag(MUTABLE) && + !isMutable && (!hasFlag(METHOD | BYNAMEPARAM) || hasFlag(STABLE)) && !(tpe.isVolatile && !hasAnnotation(uncheckedStableClass)) @@ -1099,7 +1099,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => /** The symbol accessed by this accessor function, but with given owner type */ final def accessed(ownerTp: Type): Symbol = { - assert(hasFlag(ACCESSOR)) + assert(hasAccessorFlag) ownerTp.decl(nme.getterToLocal(if (isSetter) nme.setterToGetter(name) else name)) } @@ -1366,7 +1366,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => */ final def getter(base: Symbol): Symbol = { val getterName = if (isSetter) nme.setterToGetter(name) else nme.getterName(name) - base.info.decl(getterName) filter (_.hasFlag(ACCESSOR)) + base.info.decl(getterName) filter (_.hasAccessorFlag) } /** The setter of this value or getter definition, or NoSymbol if none exists */ @@ -1375,7 +1375,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => final def setter(base: Symbol, hasExpandedName: Boolean): Symbol = { var sname = nme.getterToSetter(nme.getterName(name)) if (hasExpandedName) sname = nme.expandedSetterName(sname, base) - base.info.decl(sname) filter (_.hasFlag(ACCESSOR)) + base.info.decl(sname) filter (_.hasAccessorFlag) } /** The case module corresponding to this case class @@ -1416,7 +1416,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => def expandName(base: Symbol) { if (this.isTerm && this != NoSymbol && !hasFlag(EXPANDEDNAME)) { setFlag(EXPANDEDNAME) - if (hasFlag(ACCESSOR) && !isDeferred) { + if (hasAccessorFlag && !isDeferred) { accessed.expandName(base) } else if (hasGetter) { getter(owner).expandName(base) @@ -1476,7 +1476,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => else if (isPackage) "package" else if (isModule) "object" else if (isSourceMethod) "def" - else if (isTerm && (!isParameter || hasFlag(PARAMACCESSOR))) "val" + else if (isTerm && (!isParameter || isParamAccessor)) "val" else "" /** String representation of symbol's kind */ @@ -1664,13 +1664,13 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } def setLazyAccessor(sym: Symbol): TermSymbol = { - assert(hasFlag(LAZY) && (referenced == NoSymbol || referenced == sym), this) + assert(isLazy && (referenced == NoSymbol || referenced == sym), this) referenced = sym this } override def lazyAccessor: Symbol = { - assert(hasFlag(LAZY), this) + assert(isLazy, this) referenced } @@ -1696,7 +1696,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } } - if (hasFlag(JAVA)) + if (isJavaDefined) cook(this) else if (hasFlag(OVERLOADED)) for (sym2 <- alternatives) @@ -1709,18 +1709,18 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => class ModuleSymbol(initOwner: Symbol, initPos: Position, initName: Name) extends TermSymbol(initOwner, initPos, initName) { private var flatname = nme.EMPTY + // This method could use a better name from someone clearer on what the condition expresses. + private def isFlatAdjusted = phase.flatClasses && !isMethod && rawowner != NoSymbol && !rawowner.isPackageClass override def owner: Symbol = - if (phase.flatClasses && !hasFlag(METHOD) && - rawowner != NoSymbol && !rawowner.isPackageClass) rawowner.owner + if (isFlatAdjusted) rawowner.owner else rawowner override def name: Name = - if (phase.flatClasses && !hasFlag(METHOD) && - rawowner != NoSymbol && !rawowner.isPackageClass) { + if (isFlatAdjusted) { if (flatname == nme.EMPTY) { assert(rawowner.isClass, "fatal: %s has owner %s, but a class owner is required".format(rawname, rawowner)) - flatname = newTermName(compactify(rawowner.name.toString() + "$" + rawname)) + flatname = newTermName(compactify(rawowner.name + "$" + rawname)) } flatname } else rawname @@ -1834,7 +1834,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * info for T in Test1 should be >: Nothing <: Test3[_] */ protected def doCookJavaRawInfo() { - // don't require hasFlag(JAVA), since T in the above example does not have that flag + // don't require isJavaDefined, since T in the above example does not have that flag val tpe1 = rawToExistential(info) // println("cooking type: "+ this +": "+ info +" to "+ tpe1) if (tpe1 ne info) { diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 7a5d4544fc..108bb2f8cc 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -899,12 +899,12 @@ trait Types extends reflect.generic.Types { self: SymbolTable => if (name == nme.ANYNAME) decls.elems else decls.lookupEntry(name) while (entry ne null) { val sym = entry.sym - if (sym.getFlag(requiredFlags) == requiredFlags) { + if (sym hasAllFlags requiredFlags) { val excl = sym.getFlag(excluded) if (excl == 0L && (// omit PRIVATE LOCALS unless selector class is contained in class owning the def. (bcs eq bcs0) || - sym.getFlag(PRIVATE | LOCAL) != (PRIVATE | LOCAL).toLong || + !sym.isPrivateLocal || (bcs0.head.hasTransOwner(bcs.head)))) { if (name.isTypeName || stableOnly && sym.isStable) { stopTimer(findMemberNanos, start) @@ -916,7 +916,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => if (member.name != sym.name || !(member == sym || member.owner != sym.owner && - !sym.hasFlag(PRIVATE) && { + !sym.isPrivate && { if (self eq null) self = this.narrow if (membertpe eq null) membertpe = self.memberType(member) (membertpe matches self.memberType(sym)) @@ -1183,7 +1183,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => // more precise conceptually, but causes cyclic errors: (paramss exists (_ contains sym)) override def isImmediatelyDependent = (sym ne NoSymbol) && (sym.owner.isMethod && sym.isValueParameter) - override def isVolatile : Boolean = underlying.isVolatile && (!sym.isStable) + override def isVolatile : Boolean = underlying.isVolatile && !sym.isStable /* override def narrow: Type = { if (phase.erasedTypes) this @@ -1918,7 +1918,7 @@ A type's typeSymbol should never be inspected directly. return normalize.typeArgs.init.mkString("(", ", ", ")") + " => " + normalize.typeArgs.last if (isTupleTypeOrSubtype(this)) return normalize.typeArgs.mkString("(", ", ", if (normalize.typeArgs.length == 1) ",)" else ")") - if (sym.isAliasType && (prefixChain exists (_.termSymbol hasFlag SYNTHETIC))) { + if (sym.isAliasType && (prefixChain exists (_.termSymbol.isSynthetic))) { val normed = normalize; if (normed ne this) return normed.toString } @@ -1942,7 +1942,7 @@ A type's typeSymbol should never be inspected directly. thisInfo.parents.mkString(" with ") + { if (sym.isStructuralRefinement) ((decls.toList filter { entry => - !entry.isConstructor && entry.allOverriddenSymbols.isEmpty && !entry.hasFlag(PRIVATE) + !entry.isConstructor && entry.allOverriddenSymbols.isEmpty && !entry.isPrivate }) map { entry => entry.defString }).mkString("{", "; ", "}") else "" @@ -3236,7 +3236,7 @@ A type's typeSymbol should never be inspected directly. // note: it's important to write the two tests in this order, // as only typeParams forces the classfile to be read. See #400 private def isRawIfWithoutArgs(sym: Symbol) = - sym.isClass && !sym.typeParams.isEmpty && sym.hasFlag(JAVA) + sym.isClass && sym.typeParams.nonEmpty && sym.isJavaDefined def isRaw(sym: Symbol, args: List[Type]) = !phase.erasedTypes && isRawIfWithoutArgs(sym) && args.isEmpty @@ -4036,7 +4036,7 @@ A type's typeSymbol should never be inspected directly. } private def equalSymsAndPrefixes(sym1: Symbol, pre1: Type, sym2: Symbol, pre2: Type): Boolean = - if (sym1 == sym2) sym1.hasFlag(PACKAGE) || phase.erasedTypes || pre1 =:= pre2 + if (sym1 == sym2) sym1.hasPackageFlag || phase.erasedTypes || pre1 =:= pre2 else (sym1.name == sym2.name) && isUnifiable(pre1, pre2) /** Do `tp1' and `tp2' denote equivalent types? @@ -4084,7 +4084,7 @@ A type's typeSymbol should never be inspected directly. def normalizePlus(tp: Type) = tp match { case TypeRef(pre, sym, List()) => if (!sym.isInitialized) sym.rawInfo.load(sym) - if (sym.hasFlag(JAVA) && !sym.typeParams.isEmpty) rawToExistential(tp) + if (sym.isJavaDefined && !sym.typeParams.isEmpty) rawToExistential(tp) else tp.normalize case _ => tp.normalize } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index cbc79b215d..525815a6b2 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -756,7 +756,7 @@ abstract class ClassfileParser { } val classSym = classNameToSymbol(subName(c => c == ';' || c == '<')) - assert(!classSym.hasFlag(OVERLOADED), classSym.alternatives) + assert(!classSym.isOverloaded, classSym.alternatives) var tpe = processClassType(processInner(classSym.tpe)) while (sig(index) == '.') { accept('.') diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index 95a0c2b53d..0c4dc9a961 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -45,7 +45,7 @@ abstract class ICodeReader extends ClassfileParser { var sym = cls sym.info // ensure accurate type information - isScalaModule = cls.isModule && !cls.hasFlag(JAVA) + isScalaModule = cls.isModule && !cls.isJavaDefined log("Reading class: " + cls + " isScalaModule?: " + isScalaModule) val name = cls.fullName('.') + (if (sym.hasFlag(MODULE)) "$" else "") @@ -506,7 +506,7 @@ abstract class ICodeReader extends ClassfileParser { case JVM.getstatic => val field = pool.getMemberSymbol(in.nextChar, true); size += 2 - if (field.hasFlag(Flags.MODULE)) + if (field.hasModuleFlag) code.emit(LOAD_MODULE(field)) else code.emit(LOAD_FIELD(field, true)) @@ -529,7 +529,7 @@ abstract class ICodeReader extends ClassfileParser { code.emit(CALL_METHOD(m, Dynamic)) case JVM.invokespecial => val m = pool.getMemberSymbol(in.nextChar, false); size += 2 - val style = if (m.name == nme.CONSTRUCTOR || m.hasFlag(Flags.PRIVATE)) Static(true) + val style = if (m.name == nme.CONSTRUCTOR || m.isPrivate) Static(true) else SuperCall(m.owner.name); code.emit(CALL_METHOD(m, style)) case JVM.invokestatic => diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 3b63ce2862..6fab87e9f6 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -91,7 +91,7 @@ abstract class Pickler extends SubComponent { (isRootSym(sym) || sym.isRefinementClass || sym.isAbstractType && sym.hasFlag(EXISTENTIAL) || // existential param - (sym hasFlag PARAM) || + sym.isParameter || isLocal(sym.owner)) private def staticAnnotations(annots: List[AnnotationInfo]) = @@ -497,7 +497,7 @@ abstract class Pickler extends SubComponent { writeRef(sym.name) writeRef(localizedOwner(sym)) writeLongNat((rawFlagsToPickled(sym.flags & PickledFlags))) - if (sym.privateWithin != NoSymbol) writeRef(sym.privateWithin) + if (sym.hasAccessBoundary) writeRef(sym.privateWithin) writeRef(sym.info) } @@ -990,7 +990,7 @@ abstract class Pickler extends SubComponent { printRef(sym.name) printRef(localizedOwner(sym)) print(flagsToString(sym.flags & PickledFlags)+" ") - if (sym.privateWithin != NoSymbol) printRef(sym.privateWithin) + if (sym.hasAccessBoundary) printRef(sym.privateWithin) printRef(sym.info) } def printBody(entry: AnyRef) = entry match { diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala index a2e7f425b6..afafce5abe 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala @@ -65,7 +65,7 @@ abstract class UnPickler extends reflect.generic.UnPickler { override def complete(sym: Symbol) { super.complete(sym) var alias = at(j, readSymbol) - if (alias hasFlag OVERLOADED) { + if (alias.isOverloaded) { atPhase(currentRun.picklerPhase) { alias = alias suchThat (alt => sym.tpe =:= sym.owner.thisType.memberType(alt)) } diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index 252055a63f..98ae175dad 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -197,15 +197,15 @@ abstract class AddInterfaces extends InfoTransform { clazz setFlag lateINTERFACE implClass(clazz) // generate an impl class } - val parents1 = - if (parents.isEmpty) List() - else { - assert(!parents.head.typeSymbol.isTrait, clazz) - if (clazz.isTrait) erasedTypeRef(ObjectClass) :: parents.tail + val parents1 = parents match { + case Nil => Nil + case hd :: tl => + assert(!hd.typeSymbol.isTrait, clazz) + if (clazz.isTrait) erasedTypeRef(ObjectClass) :: tl else parents - } + } val decls1 = decls filter (sym => - if (clazz hasFlag INTERFACE) isInterfaceMember(sym) + if (clazz.isInterface) isInterfaceMember(sym) else (!sym.isType || sym.isClass)) //if (!clazz.isPackageClass) System.out.println("Decls of "+clazz+" after explicitOuter = " + decls1);//DEBUG @@ -271,18 +271,11 @@ abstract class AddInterfaces extends InfoTransform { } def implClassDefs(trees: List[Tree]): List[Tree] = { - val buf = new ListBuffer[Tree] - for (tree <- trees) - tree match { - case ClassDef(_, _, _, impl) => - if (tree.symbol.needsImplClass) - buf += { - val clazz = implClass(tree.symbol).initialize - ClassDef(clazz, implTemplate(clazz, impl)) - } - case _ => - } - buf.toList + trees collect { + case cd: ClassDef if cd.symbol.needsImplClass => + val clazz = implClass(cd.symbol).initialize + ClassDef(clazz, implTemplate(clazz, cd.impl)) + } } /** Add calls to supermixin constructors @@ -302,7 +295,7 @@ abstract class AddInterfaces extends InfoTransform { (tree: @unchecked) match { case Block(stats, expr) => // needs `hasSymbol' check because `supercall' could be a block (named / default args) - val (presuper, supercall :: rest) = stats span (t => t.hasSymbol && t.symbol.hasFlag(PRESUPER)) + val (presuper, supercall :: rest) = stats span (t => t.hasSymbolWhich(_ hasFlag PRESUPER)) //assert(supercall.symbol.isClassConstructor, supercall) treeCopy.Block(tree, presuper ::: (supercall :: mixinConstructorCalls ::: rest), expr) } diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index 2d9c89bea0..af41bb97e9 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -650,7 +650,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { /* finds the static ctor DefDef tree within the template if it exists. */ private def findStaticCtor(template: Template): Option[Tree] = template.body find { - case defdef @ DefDef(mods, nme.CONSTRUCTOR, tparam, vparam, tp, rhs) => defdef.symbol hasFlag STATIC + case defdef @ DefDef(_, nme.CONSTRUCTOR, _, _, _, _) => defdef.symbol.hasStaticFlag case _ => false } diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 88ecab6363..ed479763e5 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -198,7 +198,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { // before the superclass constructor call, otherwise it goes after. // Lazy vals don't get the assignment in the constructor. if (!stat.symbol.tpe.isInstanceOf[ConstantType]) { - if (rhs != EmptyTree && !stat.symbol.hasFlag(LAZY)) { + if (rhs != EmptyTree && !stat.symbol.isLazy) { val rhs1 = intoConstructor(stat.symbol, rhs); (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign( stat.symbol, rhs1) @@ -225,10 +225,10 @@ abstract class Constructors extends Transform with ast.TreeDSL { // This is the case if the symbol is defined in the current class, and // ( the symbol is an object private parameter accessor field, or // the symbol is an outer accessor of a final class which does not override another outer accessor. ) - def maybeOmittable(sym: Symbol) = - (sym.owner == clazz && - ((sym hasFlag PARAMACCESSOR) && sym.isPrivateLocal || - sym.isOuterAccessor && sym.owner.isFinal && sym.allOverriddenSymbols.isEmpty)) + def maybeOmittable(sym: Symbol) = sym.owner == clazz && ( + sym.isParamAccessor && sym.isPrivateLocal || + sym.isOuterAccessor && sym.owner.isFinal && sym.allOverriddenSymbols.isEmpty + ) // Is symbol known to be accessed outside of the primary constructor, // or is it a symbol whose definition cannot be omitted anyway? @@ -426,7 +426,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { override def transform(tree: Tree): Tree = tree match { - case ClassDef(mods, name, tparams, impl) if !tree.symbol.hasFlag(INTERFACE) => + case ClassDef(mods, name, tparams, impl) if !tree.symbol.isInterface => treeCopy.ClassDef(tree, mods, name, tparams, transformClassTemplate(impl)) case _ => super.transform(tree) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index cfd78b7b08..9a436d86a3 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -671,7 +671,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. case Try(block, catches, finalizer) => treeCopy.Try(tree1, adaptBranch(block), catches map adaptCase, finalizer) case Ident(_) | Select(_, _) => - if (tree1.symbol hasFlag OVERLOADED) { + if (tree1.symbol.isOverloaded) { val first = tree1.symbol.alternatives.head val sym1 = tree1.symbol.filter { alt => alt == first || !(first.tpe looselyMatches alt.tpe) @@ -745,7 +745,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. val opc = new overridingPairs.Cursor(root) { override def exclude(sym: Symbol): Boolean = - (!sym.isTerm || sym.hasFlag(PRIVATE) || super.exclude(sym) + (!sym.isTerm || sym.isPrivate || super.exclude(sym) // specialized members have no type history before 'specialize', causing double def errors for curried defs || !sym.hasTypeAt(currentRun.refchecksPhase.id)) @@ -813,7 +813,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. new overridingPairs.Cursor(owner) { override def parents: List[Type] = List(owner.info.parents.head) override def exclude(sym: Symbol): Boolean = - !sym.isMethod || sym.hasFlag(PRIVATE) || super.exclude(sym) + !sym.isMethod || sym.isPrivate || super.exclude(sym) } } while (opc.hasNext) { diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 1403377367..9f6117dcf1 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -161,8 +161,8 @@ abstract class ExplicitOuter extends InfoTransform // On the other hand, mixing in the trait into a separately compiled // class needs to have a common naming scheme, independently of whether // the field was accessed from an inner class or not. See #2946 - if (sym.owner.isTrait && (sym hasFlag LOCAL) && - ((sym.getter(sym.owner.toInterface) == NoSymbol) && (!sym.isLazy || (sym.lazyAccessor == NoSymbol)))) + if (sym.owner.isTrait && sym.hasLocalFlag && + ((sym.getter(sym.owner.toInterface) == NoSymbol) && !sym.isLazyAccessor)) sym.makeNotPrivate(sym.owner) tp } @@ -343,12 +343,9 @@ abstract class ExplicitOuter extends InfoTransform /** If FLAG is set on symbol, sets notFLAG (this exists in anticipation of generalizing). */ def setNotFlags(sym: Symbol, flags: Int*) { - val notMap = Map( - PRIVATE -> notPRIVATE, - PROTECTED -> notPROTECTED - ) - for (f <- flags ; notFlag <- notMap get f ; if sym hasFlag f) - sym setFlag notFlag + for (f <- flags ; notFlag <- notFlagMap get f) + if (sym hasFlag f) + sym setFlag notFlag } def matchTranslation(tree: Match) = { @@ -461,7 +458,7 @@ abstract class ExplicitOuter extends InfoTransform super.transform(tree) case This(qual) => - if (sym == currentClass || (sym hasFlag MODULE) && sym.isStatic) tree + if (sym == currentClass || sym.hasModuleFlag && sym.isStatic) tree else atPos(tree.pos)(outerPath(outerValue, currentClass.outerClass, sym)) // (5) case Select(qual, name) => diff --git a/src/compiler/scala/tools/nsc/transform/Flatten.scala b/src/compiler/scala/tools/nsc/transform/Flatten.scala index 512c5fe2bd..704cf35853 100644 --- a/src/compiler/scala/tools/nsc/transform/Flatten.scala +++ b/src/compiler/scala/tools/nsc/transform/Flatten.scala @@ -51,7 +51,7 @@ abstract class Flatten extends InfoTransform { decls1 enter sym if (sym.isModule) sym.moduleClass setFlag LIFTED // Only top modules // Nested modules (MODULE flag is reset so we access through lazy): - if (sym.isModuleVar && sym.hasFlag(LAZY)) sym.lazyAccessor.lazyAccessor setFlag LIFTED + if (sym.isModuleVar && sym.isLazy) sym.lazyAccessor.lazyAccessor setFlag LIFTED } else if (sym.isClass) { liftClass(sym) if (sym.needsImplClass) liftClass(erasure.implClass(sym)) @@ -83,7 +83,7 @@ abstract class Flatten extends InfoTransform { tree match { case PackageDef(_, _) => liftedDefs(tree.symbol.moduleClass) = new ListBuffer - case Template(_, _, _) if (tree.symbol.owner.hasFlag(PACKAGE)) => + case Template(_, _, _) if tree.symbol.owner.hasPackageFlag => liftedDefs(tree.symbol.owner) = new ListBuffer case _ => } diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala index 9baec23129..84916606a3 100644 --- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala +++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala @@ -65,7 +65,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD tree match { case DefDef(mods, name, tparams, vparams, tpt, rhs) => atOwner(tree.symbol) { - val res = if (!sym.owner.isClass && sym.hasFlag(LAZY)) { + val res = if (!sym.owner.isClass && sym.isLazy) { val enclosingDummyOrMethod = if (sym.enclMethod == NoSymbol) sym.owner else sym.enclMethod val idx = lazyVals(enclosingDummyOrMethod) diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 3d4c41ed93..5b6f19c18e 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -43,7 +43,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { private def isImplementedStatically(sym: Symbol) = sym.owner.isImplClass && sym.isMethod && (!sym.isModule || sym.hasFlag(PRIVATE | LIFTED)) && - (!(sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.hasFlag(LAZY)) + (!(sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isLazy) /** A member of a trait is static only if it belongs only to the * implementation class, not the interface, and it is implemented @@ -114,8 +114,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // --------- type transformation ----------------------------------------------- def isConcreteAccessor(member: Symbol) = - (member hasFlag ACCESSOR) && - (!(member hasFlag DEFERRED) || (member hasFlag lateDEFERRED)) + member.hasAccessorFlag && (!member.isDeferred || (member hasFlag lateDEFERRED)) /** Is member overridden (either directly or via a bridge) in base class sequence `bcs'? */ def isOverriddenAccessor(member: Symbol, bcs: List[Symbol]): Boolean = atPhase(ownPhase) { @@ -138,9 +137,10 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { member setFlag MIXEDIN } - def needsExpandedSetterName(field: Symbol) = - !(field hasFlag LAZY) && - (if (field.isMethod) (field hasFlag STABLE) else !(field hasFlag MUTABLE)) + def needsExpandedSetterName(field: Symbol) = !field.isLazy && ( + if (field.isMethod) field.hasStableFlag + else !field.isMutable + ) /** Add getters and setters for all non-module fields of an implementation * class to its interface unless they are already present. This is done @@ -162,7 +162,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // } clazz.newMethod(field.pos, nme.getterName(field.name)) .setFlag(field.flags & ~(PRIVATE | LOCAL) | ACCESSOR | lateDEFERRED | - (if (field hasFlag MUTABLE) 0 else STABLE)) + (if (field.isMutable) 0 else STABLE)) .setInfo(MethodType(List(), field.info)) // TODO preserve pre-erasure info? } @@ -188,12 +188,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { for (member <- impl.info.decls.toList) { if (!member.isMethod && !member.isModule && !member.isModuleVar) { assert(member.isTerm && !member.isDeferred, member) - if (member.getter(impl) hasFlag PRIVATE) { + if (member.getter(impl).isPrivate) { member.makeNotPrivate(clazz) // this will also make getter&setter not private } val getter = member.getter(clazz) if (getter == NoSymbol) addMember(clazz, newGetter(member)) - if (!member.tpe.isInstanceOf[ConstantType] && !member.hasFlag(LAZY)) { + if (!member.tpe.isInstanceOf[ConstantType] && !member.isLazy) { val setter = member.setter(clazz, needsExpandedSetterName(member)) if (setter == NoSymbol) addMember(clazz, newSetter(member)) } @@ -278,7 +278,8 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { for (member <- mixinClass.info.decls.toList) { if (isConcreteAccessor(member)) { if (isOverriddenAccessor(member, clazz.info.baseClasses)) { - if (settings.debug.value) println("!!! is overridden val: "+member) + if (settings.debug.value) + println("!!! is overridden val: "+member) } else { // mixin field accessors val member1 = addMember( @@ -290,7 +291,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // atPhase(currentRun.erasurePhase){ // println("before erasure: "+ (member.info, member1.info)) // } - if (member.hasFlag(LAZY)) { + if (member.isLazy) { var init = implClass(mixinClass).info.decl(member.name) assert(init != NoSymbol, "Could not find initializer for " + member.name) initializer(member1) = init @@ -314,17 +315,17 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { addMember(clazz, sym setFlag (LOCAL | PRIVATE | member.getFlag(MUTABLE | LAZY)) - setFlag (if (!member.hasFlag(STABLE)) MUTABLE else 0) + setFlag (if (!member.hasStableFlag) MUTABLE else 0) setAnnotations accessed.annotations) } } - } else if (member hasFlag SUPERACCESSOR) { // mixin super accessors + } else if (member.isSuperAccessor) { // mixin super accessors val member1 = addMember(clazz, member.cloneSymbol(clazz)) setPos clazz.pos assert(member1.alias != NoSymbol, member1) val alias1 = rebindSuper(clazz, member.alias, mixinClass) member1.asInstanceOf[TermSymbol] setAlias alias1 - } else if (member.isMethod && member.isModule && !(member hasFlag (LIFTED | BRIDGE))) { + } else if (member.isMethod && member.isModule && member.hasNoFlags(LIFTED | BRIDGE)) { // mixin objects: todo what happens with abstract objects? addMember(clazz, member.cloneSymbol(clazz)) .setPos(clazz.pos) @@ -414,12 +415,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { case _ => if (tree.hasSymbol && tree.symbol != NoSymbol) { val sym = tree.symbol - if ((sym.hasFlag(ACCESSOR) || (sym.isTerm && !sym.isMethod)) - && sym.hasFlag(PRIVATE) + if ((sym.hasAccessorFlag || (sym.isTerm && !sym.isMethod)) + && sym.isPrivate && !(currentOwner.isGetter && currentOwner.accessed == sym) // getter && !definitions.isValueClass(sym.tpe.resultType.typeSymbol) && sym.owner == templ.symbol.owner - && !sym.hasFlag(LAZY) + && !sym.isLazy && !tree.isDef) { log("added use in: " + currentOwner + " -- " + tree) usedIn(sym) ::= currentOwner @@ -432,11 +433,10 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { } SingleUseTraverser(templ) log("usedIn: " + usedIn) - usedIn filter { pair => - val member = pair._2.head - (member.isValue - && member.hasFlag(LAZY) - && pair._2.tail.isEmpty) } + usedIn filter { + case (_, member :: Nil) => member.isValue && member.isLazy + case _ => false + } } // --------- term transformation ----------------------------------------------- @@ -631,7 +631,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { */ def completeSuperAccessor(stat: Tree) = stat match { case DefDef(mods, name, tparams, List(vparams), tpt, EmptyTree) - if (stat.symbol hasFlag SUPERACCESSOR) => + if (stat.symbol.isSuperAccessor) => val rhs0 = (Super(clazz, nme.EMPTY.toTypeName) DOT stat.symbol.alias)(vparams map (v => Ident(v.symbol)): _*) val rhs1 = localTyper.typed(atPos(stat.pos)(rhs0), stat.symbol.tpe.resultType) val rhs2 = atPhase(currentRun.mixinPhase)(transform(rhs1)) @@ -779,7 +779,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { */ def mkLazyDef(clazz: Symbol, lzyVal: Symbol, init: List[Tree], retVal: Tree, offset: Int): Tree = { def nullify(sym: Symbol): Tree = { - val sym1 = if (sym.hasFlag(ACCESSOR)) sym.accessed else sym + val sym1 = if (sym.hasAccessorFlag) sym.accessed else sym Select(This(clazz), sym1) === LIT(null) } @@ -814,7 +814,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { val stats1 = for (stat <- stats; sym = stat.symbol) yield stat match { case DefDef(mods, name, tp, vp, tpt, rhs) - if sym.hasFlag(LAZY) && rhs != EmptyTree && !clazz.isImplClass => + if sym.isLazy && rhs != EmptyTree && !clazz.isImplClass => assert(fieldOffset.isDefinedAt(sym)) val rhs1 = if (sym.tpe.resultType.typeSymbol == UnitClass) mkLazyDef(clazz, sym, List(rhs), UNIT, fieldOffset(sym)) @@ -861,8 +861,8 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // if (settings.debug.value) { // log("needsInitFlag(" + sym.fullName + "): " + res) // log("\tsym.isGetter: " + sym.isGetter) -// log("\t!isInitializedToDefault: " + !sym.isInitializedToDefault + sym.hasFlag(DEFAULTINIT) + sym.hasFlag(ACCESSOR) + sym.isTerm) -// log("\t!sym.hasFlag(PARAMACCESSOR): " + !sym.hasFlag(PARAMACCESSOR)) +// log("\t!isInitializedToDefault: " + !sym.isInitializedToDefault + sym.hasFlag(DEFAULTINIT) + sym.hasAccessorFlag + sym.isTerm) +// log("\t!sym.isParamAccessor: " + !sym.isParamAccessor) // //println("\t!sym.accessed.hasFlag(PRESUPER): " + !sym.accessed.hasFlag(PRESUPER)) // log("\t!sym.isOuterAccessor: " + !sym.isOuterAccessor) // } @@ -967,7 +967,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { case MethodType(List(), ConstantType(c)) => Literal(c) case _ => // if it is a mixed-in lazy value, complete the accessor - if (sym.hasFlag(LAZY) && sym.isGetter) { + if (sym.isLazy && sym.isGetter) { val rhs1 = if (sym.tpe.resultType.typeSymbol == UnitClass) mkLazyDef(clazz, sym, List(Apply(staticRef(initializer(sym)), List(gen.mkAttributedThis(clazz)))), UNIT, fieldOffset(sym)) @@ -1006,7 +1006,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { else init } - } else if (!sym.hasFlag(LAZY) && needsInitFlag(sym)) { + } else if (!sym.isLazy && needsInitFlag(sym)) { mkCheckedAccessor(clazz, accessedRef, fieldOffset(sym), sym.pos, sym) } else gen.mkCheckInit(accessedRef) @@ -1014,7 +1014,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { } else if (!sym.isMethod) { // add fields addDef(position(sym), ValDef(sym)) - } else if (sym hasFlag SUPERACCESSOR) { + } else if (sym.isSuperAccessor) { // add superaccessors addDefDef(sym, vparams => EmptyTree) } else { @@ -1037,7 +1037,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { } // if there are no lazy fields, take the fast path and save a traversal of the whole AST - if (templ.symbol.owner.info.decls.exists(_.hasFlag(LAZY))) { + if (templ.symbol.owner.info.decls.exists(_.isLazy)) { // check what fields can be nulled for val uses = singleUseFields(templ) for ((field, users) <- uses; lazyFld <- users) { @@ -1117,7 +1117,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { if (mix == nme.EMPTY.toTypeName && currentOwner.enclClass.isImplClass) assert(false, "illegal super in trait: " + currentOwner.enclClass + " " + tree); if (sym.owner hasFlag lateINTERFACE) { - if (sym.hasFlag(ACCESSOR)) { + if (sym.hasAccessorFlag) { assert(args.isEmpty) val sym1 = sym.overridingSymbol(currentOwner.enclClass) typedPos(tree.pos)((transformSuper(qual) DOT sym1)()) diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index d0d3235c8a..ed4808ebbd 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -485,7 +485,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { override def target = m.owner.info.member(specializedName(m, env)) } - } else if (m.isMethod && !m.hasFlag(ACCESSOR)) { // other concrete methods + } else if (m.isMethod && !m.hasAccessorFlag) { // other concrete methods forwardToOverload(m) } else if (m.isValue && !m.isMethod) { // concrete value definition @@ -869,7 +869,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case PolyType(targs, ClassInfoType(base, decls, clazz)) if clazz != RepeatedParamClass && clazz != JavaRepeatedParamClass - && !clazz.hasFlag(JAVA) => + && !clazz.isJavaDefined => val parents = base map specializedType if (settings.debug.value) log("transformInfo (poly) " + clazz + " with parents1: " + parents + " ph: " + phase) // if (clazz.name.toString == "$colon$colon") @@ -878,7 +878,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { new Scope(specializeClass(clazz, typeEnv(clazz)) ::: specialOverrides(clazz)), clazz)) - case ClassInfoType(base, decls, clazz) if !clazz.isPackageClass && !clazz.hasFlag(JAVA) => + case ClassInfoType(base, decls, clazz) if !clazz.isPackageClass && !clazz.isJavaDefined => atPhase(phase.next)(base.map(_.typeSymbol.info)) val parents = base map specializedType if (settings.debug.value) log("transformInfo " + clazz + " with parents1: " + parents + " ph: " + phase) @@ -1207,7 +1207,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { localTyper.typed(treeCopy.DefDef(tree, mods, name, tparams, vparamss, tpt, rhs1)) } - case ValDef(mods, name, tpt, rhs) if symbol.hasFlag(SPECIALIZED) && !symbol.hasFlag(PARAMACCESSOR) => + case ValDef(mods, name, tpt, rhs) if symbol.hasFlag(SPECIALIZED) && !symbol.isParamAccessor => assert(body.isDefinedAt(symbol.alias)) val tree1 = treeCopy.ValDef(tree, mods, name, tpt, body(symbol.alias).duplicate) if (settings.debug.value) log("now typing: " + tree1 + " in " + tree.symbol.owner.fullName) @@ -1325,7 +1325,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { && satisfiable(typeEnv(m), warn(cls))) { log("creating tree for " + m.fullName) if (m.isMethod) { - if (info(m).target.isGetterOrSetter) hasSpecializedFields = true + if (info(m).target.hasAccessorFlag) hasSpecializedFields = true if (m.isClassConstructor) { val origParamss = parameters(info(m).target) diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index e75a7f9580..26c1efbf91 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -274,7 +274,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers { /** Undo eta expansion for parameterless and nullary methods */ def deEta(fun: Function): Tree = fun match { case Function(List(), Apply(expr, List())) if treeInfo.isPureExpr(expr) => - if (expr.hasSymbol && expr.symbol.hasFlag(LAZY)) + if (expr hasSymbolWhich (_.isLazy)) fun else expr @@ -690,7 +690,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers { applyUnary() case Select(_, _) | TypeApply(_, _) => applyUnary() - case Return(expr) if (tree.symbol != currentOwner.enclMethod || currentOwner.hasFlag(LAZY)) => + case Return(expr) if (tree.symbol != currentOwner.enclMethod || currentOwner.isLazy) => if (settings.debug.value) log("non local return in "+tree.symbol+" from "+currentOwner.enclMethod) atPos(tree.pos)(nonLocalReturnThrow(expr, tree.symbol)) case TypeTree() => diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 7136945de6..ef0f38a341 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -430,12 +430,12 @@ trait Contexts { self: Analyzer => val ab = sym.accessBoundary(sym.owner) ( (ab.isTerm || ab == definitions.RootClass) || (accessWithin(ab) || accessWithinLinked(ab)) && - ( !sym.hasFlag(LOCAL) + ( !sym.hasLocalFlag || sym.owner.isImplClass // allow private local accesses to impl classes - || (sym hasFlag PROTECTED) && isSubThisType(pre, sym.owner) + || sym.isProtected && isSubThisType(pre, sym.owner) || pre =:= sym.owner.thisType ) - || (sym hasFlag PROTECTED) && + || sym.isProtected && ( superAccess || pre.isInstanceOf[ThisType] || sym.isConstructor @@ -485,7 +485,7 @@ trait Contexts { self: Analyzer => * with the same names. Local symbols override imported ones. This fixes #2866. */ private def isQualifyingImplicit(sym: Symbol, pre: Type, imported: Boolean) = - sym.hasFlag(IMPLICIT) && + sym.isImplicit && isAccessible(sym, pre, false) && !(imported && { val e = scope.lookupEntry(sym.name) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 70df60cc55..eb775f2301 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -548,7 +548,7 @@ self: Analyzer => def comesBefore(sym: Symbol, owner: Symbol) = { val ownerPos = owner.pos.pointOrElse(Integer.MAX_VALUE) sym.pos.pointOrElse(0) < ownerPos && ( - if(sym isGetterOrSetter) { + if(sym hasAccessorFlag) { val symAcc = sym.accessed // #3373 symAcc.pos.pointOrElse(0) < ownerPos && !(owner.ownerChain exists (o => (o eq sym) || (o eq symAcc))) // probably faster to iterate only once, don't feel like duplicating hasTransOwner for this case diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 4d5fe9549c..095094579a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -707,7 +707,7 @@ trait Infer { val argtpes1 = argtpes map { case NamedType(name, tp) => // a named argument var res = tp - val pos = params.indexWhere(p => (p.name == name || deprecatedName(p) == Some(name)) && !p.hasFlag(SYNTHETIC)) + val pos = params.indexWhere(p => (p.name == name || deprecatedName(p) == Some(name)) && !p.isSynthetic) if (pos == -1) { if (positionalAllowed) { // treat assignment as positional argument argPos(index) = index @@ -820,13 +820,12 @@ trait Infer { case NamedType(name, _) => Some(name) case _ => None })._1 - if (missing.exists(!_.hasFlag(DEFAULTPARAM))) tryTupleApply - else { - val argtpes1 = argtpes0 ::: missing.map { - p => NamedType(p.name, p.tpe) // add defaults as named arguments - } + if (missing forall (_.hasDefaultFlag)) { + // add defaults as named arguments + val argtpes1 = argtpes0 ::: (missing map (p => NamedType(p.name, p.tpe))) isApplicable(undetparams, ftpe, argtpes1, pt) } + else tryTupleApply } case PolyType(tparams, restpe) => @@ -1679,7 +1678,7 @@ trait Infer { else treeSymTypeMsg(tree) + " does not take type parameters") return } - if (sym0.hasFlag(OVERLOADED)) { + if (sym0.isOverloaded) { val sym = sym0 filter { alt => isWithinBounds(pre, alt.owner, alt.typeParams, argtypes) } if (sym == NoSymbol) { if (!(argtypes exists (_.isErroneous))) { @@ -1691,7 +1690,7 @@ trait Infer { return } } - if (sym.hasFlag(OVERLOADED)) { + if (sym.isOverloaded) { val tparams = new AsSeenFromMap(pre, sym.alternatives.head.owner).mapOver( sym.alternatives.head.typeParams) val bounds = tparams map (_.tpeHK) // see e.g., #1236 diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 35b34ae5fd..e2098ee7d5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -68,7 +68,7 @@ trait Namers { self: Analyzer => val typer = newTyper(context) def setPrivateWithin[Sym <: Symbol](tree: Tree, sym: Sym, mods: Modifiers): Sym = { - if (!mods.privateWithin.isEmpty) + if (mods.hasAccessBoundary) sym.privateWithin = typer.qualifyingClass(tree, mods.privateWithin, true) sym } @@ -130,8 +130,8 @@ trait Namers { self: Analyzer => } def usePrimary = sym.isTerm && ( - (sym hasFlag PARAMACCESSOR) || - ((sym hasFlag PARAM) && sym.owner.isPrimaryConstructor) + (sym.isParamAccessor) || + (sym.isParameter && sym.owner.isPrimaryConstructor) ) if (usePrimary) primaryConstructorParamNamer @@ -152,10 +152,10 @@ trait Namers { self: Analyzer => private def doubleDefError(pos: Position, sym: Symbol) { context.error(pos, sym.name.toString() + " is already defined as " + - (if (sym.hasFlag(SYNTHETIC)) + (if (sym.isSynthetic) "(compiler-generated) "+ (if (sym.isModule) "case class companion " else "") else "") + - (if (sym.hasFlag(CASE)) "case class " + sym.name else sym.toString())) + (if (sym.isCase) "case class " + sym.name else sym.toString())) } private def inCurrentScope(m: Symbol): Boolean = { @@ -232,7 +232,7 @@ trait Namers { self: Analyzer => var m: Symbol = context.scope.lookup(tree.name) val moduleFlags = tree.mods.flags | MODULE | FINAL if (m.isModule && !m.isPackage && inCurrentScope(m) && - (currentRun.canRedefine(m) || (m hasFlag SYNTHETIC))) { + (currentRun.canRedefine(m) || m.isSynthetic)) { updatePosFlags(m, tree.pos, moduleFlags) setPrivateWithin(tree, m, tree.mods) if (m.moduleClass != NoSymbol) @@ -260,7 +260,7 @@ trait Namers { self: Analyzer => var namer : Namer = this for (tree <- trees) { val txt = namer.enterSym(tree) - if (!(txt eq namer.context)) namer = newNamer(txt) + if (txt ne namer.context) namer = newNamer(txt) } namer } @@ -319,8 +319,8 @@ trait Namers { self: Analyzer => if (sym.name == nme.copy || isCopyGetter(sym)) { // it could be a compiler-generated copy method or one of its default getters setInfo(sym)(mkTypeCompleter(tree)(copySym => { - def copyIsSynthetic() = sym.owner.info.member(nme.copy).hasFlag(SYNTHETIC) - if (sym.hasFlag(SYNTHETIC) && (!sym.hasFlag(DEFAULTPARAM) || copyIsSynthetic())) { + def copyIsSynthetic() = sym.owner.info.member(nme.copy).isSynthetic + if (sym.isSynthetic && (!sym.hasDefaultFlag || copyIsSynthetic())) { // the 'copy' method of case classes needs a special type completer to make bug0054.scala (and others) // work. the copy method has to take exactly the same parameter types as the primary constructor. val constrType = copySym.owner.primaryConstructor.tpe @@ -362,10 +362,10 @@ trait Namers { self: Analyzer => val m = ensureCompanionObject(tree, caseModuleDef(tree)) caseClassOfModuleClass(m.moduleClass) = tree } - val hasDefault = impl.body flatMap { - case DefDef(_, nme.CONSTRUCTOR, _, vparamss, _, _) => vparamss.flatten - case _ => Nil - } exists (_.mods hasFlag DEFAULTPARAM) + val hasDefault = impl.body exists { + case DefDef(_, nme.CONSTRUCTOR, _, vparamss, _, _) => vparamss.flatten exists (_.mods.hasDefault) + case _ => false + } if (hasDefault) { val m = ensureCompanionObject(tree, companionModuleDef(tree)) @@ -378,7 +378,7 @@ trait Namers { self: Analyzer => case vd @ ValDef(mods, name, tp, rhs) => if ((!context.owner.isClass || - (mods.flags & (PRIVATE | LOCAL | CASEACCESSOR)) == (PRIVATE | LOCAL) || + (mods.isPrivateLocal && !mods.isCaseAccessor) || name.startsWith(nme.OUTER) || context.unit.isJava) && !mods.isLazy) { @@ -388,7 +388,7 @@ trait Namers { self: Analyzer => finish } else { val mods1 = - if (mods.hasFlag(PRIVATE) && mods.hasFlag(LOCAL) && !mods.isLazy) { + if (mods.isPrivateLocal && !mods.isLazy) { context.error(tree.pos, "private[this] not allowed for case class parameters") mods &~ LOCAL } else mods @@ -413,7 +413,7 @@ trait Namers { self: Analyzer => owner.newValue(tree.pos, name + "$lzy" ).setFlag((mods1.flags | MUTABLE) & ~IMPLICIT) } else { val mFlag = if (mods1.isLazy) MUTABLE else 0 - val lFlag = if (mods.hasFlag(PRIVATE) && mods.hasFlag(LOCAL)) 0 else LOCAL + val lFlag = if (mods.isPrivateLocal) 0 else LOCAL val newflags = mods1.flags & FieldFlags | PRIVATE | lFlag | mFlag owner.newValue(tree.pos, nme.getterToLocal(name)) setFlag newflags } @@ -446,7 +446,7 @@ trait Namers { self: Analyzer => case imp @ Import(_, _) => tree.symbol = NoSymbol.newImport(tree.pos) setInfo(sym)(namerOf(sym).typeCompleter(tree)) - return (context.makeNewImport(imp)) + return context.makeNewImport(imp) case _ => } } @@ -507,7 +507,7 @@ trait Namers { self: Analyzer => else Select(This(getter.owner.name), name)) } enterSyntheticSym(beanGetterDef) - if (mods hasFlag MUTABLE) { + if (mods.isMutable) { // can't use "enterSyntheticSym", because the parameter type is not yet // known. instead, uses the same machinery as for the non-bean setter: // create and enter the symbol here, add the tree in Typer.addGettterSetter. @@ -537,7 +537,7 @@ trait Namers { self: Analyzer => case _ => } sym.setInfo(tp) - if ((sym.isAliasType || sym.isAbstractType) && !(sym hasFlag PARAM) && + if ((sym.isAliasType || sym.isAbstractType) && !sym.isParameter && !typer.checkNonCyclic(tree.pos, tp)) sym.setInfo(ErrorType) // this early test is there to avoid infinite baseTypes when // adding setters and getters --> bug798 @@ -613,7 +613,7 @@ trait Namers { self: Analyzer => } val tpe1 = tpe.deconst val tpe2 = tpe1.widen - if ((sym.isVariable || sym.isMethod && !(sym hasFlag ACCESSOR))) + if ((sym.isVariable || sym.isMethod && !sym.hasAccessorFlag)) if (tpe2 <:< pt) tpe2 else tpe1 else if (isHidden(tpe)) tpe2 else if (sym.isFinal || sym.isLocal) tpe @@ -751,7 +751,7 @@ trait Namers { self: Analyzer => // here, clazz is the ClassSymbol of the case class (not the module). // @check: this seems to work only if the type completer of the class runs before the one of the // module class: the one from the module class removes the entry form caseClassOfModuleClass (see above). - if (clazz.isClass && !clazz.hasFlag(MODULE)) { + if (clazz.isClass && !clazz.hasModuleFlag) { Namers.this.caseClassOfModuleClass get companionModuleOf(clazz, context).moduleClass map { cdef => def hasCopy(decls: Scope) = (decls lookup nme.copy) != NoSymbol if (!hasCopy(decls) && @@ -865,7 +865,7 @@ trait Namers { self: Analyzer => for (vparams <- vparamss; vparam <- vparams) if (vparam.tpt.isEmpty) vparam.symbol setInfo WildcardType val overridden = overriddenSymbol - if (overridden != NoSymbol && !(overridden hasFlag OVERLOADED)) { + if (overridden != NoSymbol && !overridden.isOverloaded) { overridden.cookJavaRawInfo() // #3404 xform java rawtypes into existentials resultPt = site.memberType(overridden) match { case PolyType(tparams, rt) => rt.substSym(tparams, tparamSyms) @@ -919,7 +919,7 @@ trait Namers { self: Analyzer => tpt.tpe } else typer.typedType(tpt).tpe // #2382: return type of default getters are always @uncheckedVariance - if (meth.hasFlag(DEFAULTPARAM)) + if (meth.hasDefaultFlag) rt.withAnnotation(AnnotationInfo(definitions.uncheckedVarianceClass.tpe, List(), List())) else rt }) @@ -938,7 +938,7 @@ trait Namers { self: Analyzer => val isConstr = meth.isConstructor val overridden = if (isConstr || !meth.owner.isClass) NoSymbol else overriddenSymbol - val overrides = overridden != NoSymbol && !(overridden hasFlag OVERLOADED) + val overrides = overridden != NoSymbol && !overridden.isOverloaded // value parameters of the base class (whose defaults might be overridden) var baseParamss = overridden.tpe.paramss // match empty and missing parameter list @@ -961,8 +961,8 @@ trait Namers { self: Analyzer => for (vparam <- vparams) { val sym = vparam.symbol // true if the corresponding parameter of the base class has a default argument - val baseHasDefault = overrides && (baseParams.head hasFlag DEFAULTPARAM) - if (sym hasFlag DEFAULTPARAM) { + val baseHasDefault = overrides && baseParams.head.hasDefaultFlag + if (sym.hasDefaultFlag) { // generate a default getter for that argument val oflag = if (baseHasDefault) OVERRIDE else 0 val name = nme.defaultGetterName(meth.name, posCounter) @@ -1151,7 +1151,7 @@ trait Namers { self: Analyzer => newNamer(context.makeNewScope(tree, sym)).methodSig(mods, tparams, vparamss, tpt, rhs) case vdef @ ValDef(mods, name, tpt, rhs) => - val typer1 = typer.constrTyperIf(sym.hasFlag(PARAM | PRESUPER) && !mods.hasFlag(JAVA) && sym.owner.isConstructor) + val typer1 = typer.constrTyperIf(sym.hasFlag(PARAM | PRESUPER) && !mods.isJavaDefined && sym.owner.isConstructor) if (tpt.isEmpty) { if (rhs.isEmpty) { context.error(tpt.pos, "missing parameter type"); @@ -1175,7 +1175,7 @@ trait Namers { self: Analyzer => typer.checkStable(expr1) if ((expr1.symbol ne null) && expr1.symbol.isRootPackage) context.error(tree.pos, "_root_ cannot be imported") def checkNotRedundant(pos: Position, from: Name, to: Name): Boolean = { - if (!tree.symbol.hasFlag(SYNTHETIC) && + if (!tree.symbol.isSynthetic && !((expr1.symbol ne null) && expr1.symbol.isInterpreterWrapper) && base.member(from) != NoSymbol) { val e = context.scope.lookupEntry(to) @@ -1290,10 +1290,10 @@ trait Namers { self: Analyzer => context.error(sym.pos, "`override' modifier not allowed for constructors") if (sym.hasFlag(ABSOVERRIDE) && !sym.owner.isTrait) context.error(sym.pos, "`abstract override' modifier only allowed for members of traits") - if (sym.hasFlag(LAZY) && sym.hasFlag(PRESUPER)) + if (sym.isLazy && sym.hasFlag(PRESUPER)) context.error(sym.pos, "`lazy' definitions may not be initialized early") if (sym.info.typeSymbol == FunctionClass(0) && - sym.isValueParameter && sym.owner.isClass && sym.owner.hasFlag(CASE)) + sym.isValueParameter && sym.owner.isCaseClass) context.error(sym.pos, "pass-by-name arguments not allowed for case class parameters") if (sym hasFlag DEFERRED) { // virtual classes count, too if (sym.hasAnnotation(definitions.NativeAttr)) @@ -1314,6 +1314,10 @@ trait Namers { self: Analyzer => /* checkNoConflict(PRIVATE, FINAL) // can't do this because FINAL also means compile-time constant */ checkNoConflict(ABSTRACT, FINAL) // bug #1833 checkNoConflict(DEFERRED, FINAL) + + // @PP: I added this as a sanity check because these flags are supposed to be + // converted to ABSOVERRIDE before arriving here. + checkNoConflict(ABSTRACT, OVERRIDE) } } @@ -1343,7 +1347,7 @@ trait Namers { self: Analyzer => * of the actual declaration or definition, not in terms of the generated setters * and getters */ def underlying(member: Symbol): Symbol = - if (member hasFlag ACCESSOR) { + if (member.hasAccessorFlag) { if (member.isDeferred) { val getter = if (member.isSetter) member.getter(member.owner) else member val result = getter.owner.newValue(getter.pos, getter.name) @@ -1363,7 +1367,7 @@ trait Namers { self: Analyzer => var res = clazz.companionModule if (res == NoSymbol) res = context.lookup(clazz.name.toTermName, clazz.owner).suchThat(sym => - sym.hasFlag(MODULE) && sym.isCoDefinedWith(clazz)) + sym.hasModuleFlag && sym.isCoDefinedWith(clazz)) res } catch { case e: InvalidCompanions => diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 808dbcc785..04c6dbe4a0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -364,7 +364,7 @@ trait NamesDefaults { self: Analyzer => pos: util.Position, context: Context): (List[Tree], List[Symbol]) = { if (givenArgs.length < params.length) { val (missing, positional) = missingParams(givenArgs, params) - if (missing forall (_.hasFlag(DEFAULTPARAM))) { + if (missing forall (_.hasDefaultFlag)) { val defaultArgs = missing map (p => { var default1 = qual match { case Some(q) => gen.mkAttributedSelect(q.duplicate, defaultGetter(p, context)) @@ -380,7 +380,7 @@ trait NamesDefaults { self: Analyzer => } }) (givenArgs ::: defaultArgs, Nil) - } else (givenArgs, missing filter (! _.hasFlag(DEFAULTPARAM))) + } else (givenArgs, missing filterNot (_.hasDefaultFlag)) } else (givenArgs, Nil) } @@ -453,7 +453,7 @@ trait NamesDefaults { self: Analyzer => val udp = typer.context.extractUndetparams() val subst = new SubstTypeMap(udp, udp map (_ => WildcardType)) { override def apply(tp: Type): Type = tp match { - case TypeRef(_, sym, List(arg)) if (sym == ByNameParamClass) => super.apply(arg) + case TypeRef(_, ByNameParamClass, List(arg)) => super.apply(arg) case _ => super.apply(tp) } } @@ -515,7 +515,7 @@ trait NamesDefaults { self: Analyzer => var rest = params while (!rest.isEmpty) { val p = rest.head - if (!p.hasFlag(SYNTHETIC)) { + if (!p.isSynthetic) { if (p.name == name) return (i, None) if (deprecatedName(p) == Some(name)) return (i, Some(p.name)) } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 17048f691a..5c6c3a846f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -99,10 +99,10 @@ abstract class RefChecks extends InfoTransform { private def checkDefaultsInOverloaded(clazz: Symbol) { def check(members: List[Symbol]): Unit = members match { case x :: xs => - if (x.paramss.exists(_.exists(p => p.hasFlag(DEFAULTPARAM))) && !nme.isProtectedAccessor(x.name)) { + if ((x hasParamWhich (_.hasDefaultFlag)) && !nme.isProtectedAccessor(x.name)) { val others = xs.filter(alt => { alt.name == x.name && - alt.paramss.exists(_.exists(_.hasFlag(DEFAULTPARAM))) && + (alt hasParamWhich (_.hasDefaultFlag)) && (!alt.isConstructor || alt.owner == x.owner) // constructors of different classes are allowed to have defaults }) if (!others.isEmpty) { @@ -281,8 +281,10 @@ abstract class RefChecks extends InfoTransform { } } - def accessFlagsToString(sym: Symbol) - = flagsToString(sym getFlag (PRIVATE | PROTECTED), if (!sym.hasAccessBoundary) "" else sym.privateWithin.name.toString) + def accessFlagsToString(sym: Symbol) = flagsToString( + sym getFlag (PRIVATE | PROTECTED), + if (sym.hasAccessBoundary) "" + sym.privateWithin.name else "" + ) def overrideAccessError() { val otherAccess = accessFlagsToString(other) @@ -344,7 +346,7 @@ abstract class RefChecks extends InfoTransform { } else if ((other hasFlag ABSOVERRIDE) && other.isIncompleteIn(clazz) && !(member hasFlag ABSOVERRIDE)) { overrideError("needs `abstract override' modifiers") } else if ((member hasFlag (OVERRIDE | ABSOVERRIDE)) && - (other hasFlag ACCESSOR) && other.accessed.isVariable && !other.accessed.hasFlag(LAZY)) { + (other hasFlag ACCESSOR) && other.accessed.isVariable && !other.accessed.isLazy) { overrideError("cannot override a mutable variable") } else if ((member hasFlag (OVERRIDE | ABSOVERRIDE)) && !(member.owner.thisType.baseClasses exists (_ isSubClass other.owner)) && @@ -681,7 +683,7 @@ abstract class RefChecks extends InfoTransform { // Flip occurrences of type parameters and parameters, unless // - it's a constructor, or case class factory or extractor // - it's a type parameter of tvar's owner. - if ((sym hasFlag PARAM) && !sym.owner.isConstructor && !sym.owner.isCaseApplyOrUnapply && + if (sym.isParameter && !sym.owner.isConstructor && !sym.owner.isCaseApplyOrUnapply && !(tvar.isTypeParameterOrSkolem && sym.isTypeParameterOrSkolem && tvar.owner == sym.owner)) state = -state; else if (!sym.owner.isClass || @@ -1078,7 +1080,7 @@ abstract class RefChecks extends InfoTransform { case Apply(_, args) => val clazz = pat.tpe.typeSymbol; clazz == seltpe.typeSymbol && - clazz.isClass && (clazz hasFlag CASE) && + clazz.isCaseClass && (args corresponds clazz.primaryConstructor.tpe.asSeenFrom(seltpe, clazz).paramTypes)(isIrrefutable) // @PP: corresponds case Typed(pat, tpt) => seltpe <:< tpt.tpe @@ -1138,7 +1140,7 @@ abstract class RefChecks extends InfoTransform { private def checkTypeRef(tp: Type, pos: Position) = tp match { case TypeRef(pre, sym, args) => checkDeprecated(sym, pos) - if(sym.hasFlag(JAVA)) + if(sym.isJavaDefined) sym.typeParams foreach (_.cookJavaRawInfo()) if (!tp.isHigherKinded) checkBounds(pre, sym.owner, sym.typeParams, args, pos) @@ -1239,7 +1241,7 @@ abstract class RefChecks extends InfoTransform { if (settings.Xmigration28.value) checkMigration(sym, tree.pos) - if (currentClass != sym.owner && (sym hasFlag LOCAL)) { + if (currentClass != sym.owner && sym.hasLocalFlag) { var o = currentClass var hidden = false while (!hidden && o != sym.owner && o != sym.owner.moduleClass && !o.isPackage) { diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 717b4e672e..7f8359fb94 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -194,8 +194,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT mayNeedProtectedAccessor(sel, args, false) case sel @ Select(qual @ This(_), name) => - if ((sym hasFlag PARAMACCESSOR) - && (sym.alias != NoSymbol)) { + if (sym.isParamAccessor && sym.alias != NoSymbol) { val result = localTyper.typed { Select( Super(qual.symbol, nme.EMPTY.toTypeName/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos, @@ -208,9 +207,9 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT else mayNeedProtectedAccessor(sel, List(EmptyTree), false) case Select(sup @ Super(_, mix), name) => - if (sym.isValue && !sym.isMethod || sym.hasFlag(ACCESSOR)) { + if (sym.isValue && !sym.isMethod || sym.hasAccessorFlag) { unit.error(tree.pos, "super may be not be used on "+ - (if (sym.hasFlag(ACCESSOR)) sym.accessed else sym)) + (if (sym.hasAccessorFlag) sym.accessed else sym)) } else if (isDisallowed(sym)) { unit.error(tree.pos, "super not allowed here: use this." + name.decode + " instead") @@ -225,7 +224,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT case Assign(lhs @ Select(qual, name), rhs) => if (lhs.symbol.isVariable && - lhs.symbol.hasFlag(JAVA) && + lhs.symbol.isJavaDefined && needsProtectedAccessor(lhs.symbol, tree.pos)) { if (settings.debug.value) log("Adding protected setter for " + tree) val setter = makeSetter(lhs); diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 61894092f3..545aab4c79 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -234,8 +234,7 @@ trait SyntheticMethods extends ast.TreeDSL { // only nested objects inside objects should get readResolve automatically // otherwise after de-serialization we get null references for lazy accessors (nested object -> lazy val + class def) // since the bitmap gets serialized but the moduleVar not - clazz.isSerializable && - ((!clazz.owner.isPackageClass && clazz.owner.isModuleClass) || clazz.owner.isPackageClass) + clazz.isSerializable && (clazz.owner.isPackageClass || clazz.owner.isModuleClass) ) // A buffer collecting additional methods for the template body diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala index 16961db77b..2042b08d83 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala @@ -211,7 +211,7 @@ abstract class TreeCheckers extends Analyzer { tree match { case DefDef(_, _, _, _, _, _) => - if (sym.isGetterOrSetter && !sym.isDeferred) { + if (sym.hasAccessorFlag && !sym.isDeferred) { sym.tpe.resultType match { case _: ConstantType => () case _ => @@ -239,7 +239,7 @@ abstract class TreeCheckers extends Analyzer { checkSym(tree) case This(_) => checkSym(tree) - if (sym.isStatic && (sym hasFlag MODULE)) () + if (sym.isStatic && sym.hasModuleFlag) () else if (currentOwner.ownerChain takeWhile (_ != sym) exists (_ == NoSymbol)) return fail("tree symbol "+sym+" does not point to enclosing class; tree = ") diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index d87cd571d8..ceae787b1d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -211,7 +211,7 @@ trait Typers { self: Analyzer => argBuff += mkArg(res.tree, param.name) } else { mkArg = mkNamedArg // don't pass the default argument (if any) here, but start emitting named arguments for the following args - if (!param.hasFlag(DEFAULTPARAM)) + if (!param.hasDefault) context.error(fun.pos, errorMessage(param.name, param.tpe)) /* else { TODO: alternative (to expose implicit search failure more) --> @@ -444,7 +444,7 @@ trait Typers { self: Analyzer => else if (!phase.erasedTypes) { // privates val badSymbol = hiddenSymbols.head error(tree.pos, - (if (badSymbol hasFlag PRIVATE) "private " else "") + badSymbol + + (if (badSymbol.isPrivate) "private " else "") + badSymbol + " escapes its defining scope as part of type "+tree.tpe) setError(tree) } else tree @@ -455,7 +455,7 @@ trait Typers { self: Analyzer => override def apply(t: Type): Type = { def checkNoEscape(sym: Symbol) { - if (sym.hasFlag(PRIVATE) && !sym.hasFlag(SYNTHETIC_PRIVATE)) { + if (sym.isPrivate && !sym.hasFlag(SYNTHETIC_PRIVATE)) { var o = owner while (o != NoSymbol && o != sym.owner && !o.isLocal && !o.hasFlag(PRIVATE) && @@ -636,7 +636,7 @@ trait Typers { self: Analyzer => * </ol> */ private def stabilize(tree: Tree, pre: Type, mode: Int, pt: Type): Tree = { - if (tree.symbol.hasFlag(OVERLOADED) && (mode & FUNmode) == 0) + if (tree.symbol.isOverloaded && (mode & FUNmode) == 0) inferExprAlternative(tree, pt) val sym = tree.symbol @@ -890,9 +890,9 @@ trait Typers { self: Analyzer => if ((mode & FUNmode) != 0) { tree } else if (tree.hasSymbol && !tree.symbol.typeParams.isEmpty && (mode & HKmode) == 0 && - !(tree.symbol.hasFlag(JAVA) && context.unit.isJava)) { // (7) + !(tree.symbol.isJavaDefined && context.unit.isJava)) { // (7) // @M When not typing a higher-kinded type ((mode & HKmode) == 0) - // or raw type (tree.symbol.hasFlag(JAVA) && context.unit.isJava), types must be of kind *, + // or raw type (tree.symbol.isJavaDefined && context.unit.isJava), types must be of kind *, // and thus parameterized types must be applied to their type arguments // @M TODO: why do kind-* tree's have symbols, while higher-kinded ones don't? errorTree(tree, tree.symbol+" takes type parameters") @@ -925,7 +925,7 @@ trait Typers { self: Analyzer => val unapply = unapplyMember(extractor.tpe) val clazz = unapplyParameterType(unapply) - if ((unapply hasFlag CASE) && (clazz hasFlag CASE) && !(clazz.ancestors exists (_ hasFlag CASE))) { + if (unapply.isCase && clazz.isCase && !(clazz.ancestors exists (_.isCase))) { if (!phase.erasedTypes) checkStable(tree) // todo: do we need to demand this? // convert synthetic unapply of case class to case class constructor val prefix = tree.tpe.prefix @@ -1098,7 +1098,7 @@ trait Typers { self: Analyzer => // "change your code now!" as there are material bugs (which are very unlikely // to be fixed) associated with case class inheritance. if (!phase.erasedTypes) { - for (ancestor <- clazz.ancestors find (_ hasFlag CASE)) + for (ancestor <- clazz.ancestors find (_.isCase)) unit.deprecationWarning(clazz.pos, ( "case class `%s' has case class ancestor `%s'. This has been deprecated " + "for unduly complicating both usage and implementation. You should instead " + @@ -1230,7 +1230,7 @@ trait Typers { self: Analyzer => error(parent.pos, psym+" needs to be a trait to be mixed in") } } - if (psym hasFlag FINAL) { + if (psym.isFinal) { error(parent.pos, "illegal inheritance from final "+psym) } if (psym.isSealed && !phase.erasedTypes) { @@ -1241,7 +1241,7 @@ trait Typers { self: Analyzer => } if (!(selfType <:< parent.tpe.typeOfThis) && !phase.erasedTypes && - !(context.owner hasFlag SYNTHETIC) && // don't do this check for synthetic concrete classes for virtuals (part of DEVIRTUALIZE) + !context.owner.isSynthetic && // don't do this check for synthetic concrete classes for virtuals (part of DEVIRTUALIZE) !(settings.suppressVTWarn.value) && !selfType.isErroneous && !parent.tpe.isErroneous) { @@ -1350,7 +1350,7 @@ trait Typers { self: Analyzer => if (mdef.name == nme.PACKAGEkw) for (m <- mdef.symbol.info.members) - if (m.isClass && m.hasFlag(CASE)) + if (m.isCaseClass) context.error(if (m.pos.isDefined) m.pos else mdef.pos, "implementation restriction: "+mdef.symbol+" cannot contain case "+m) treeCopy.ModuleDef(mdef, typedMods, mdef.name, impl2) setType NoType @@ -1370,23 +1370,22 @@ trait Typers { self: Analyzer => def addGetterSetter(stat: Tree): List[Tree] = stat match { case ValDef(mods, name, tpt, rhs) // PRIVATE | LOCAL are fields generated for primary constructor arguments - if (mods.flags & (PRIVATE | LOCAL)) != (PRIVATE | LOCAL).toLong && !stat.symbol.isModuleVar => - - val isDeferred = mods hasFlag DEFERRED + if !mods.isPrivateLocal && !stat.symbol.isModuleVar => + val isDeferred = mods.isDeferred val value = stat.symbol val allAnnots = value.annotations if (!isDeferred) // keepClean: by default annotations go to the field, except if the field is // generated for a class parameter (PARAMACCESSOR). - value.setAnnotations(memberAnnots(allAnnots, FieldTargetClass, keepClean = !mods.hasFlag(PARAMACCESSOR))) + value.setAnnotations(memberAnnots(allAnnots, FieldTargetClass, keepClean = !mods.isParamAccessor)) val getter = if (isDeferred) value else value.getter(value.owner) assert(getter != NoSymbol, stat) - if (getter hasFlag OVERLOADED) + if (getter.isOverloaded) error(getter.pos, getter+" is defined twice") getter.setAnnotations(memberAnnots(allAnnots, GetterTargetClass)) - if (value.hasFlag(LAZY)) List(stat) + if (value.isLazy) List(stat) else { val vdef = treeCopy.ValDef(stat, mods | PRIVATE | LOCAL, nme.getterToLocal(name), tpt, rhs) val getterDef: DefDef = atPos(vdef.pos.focus) { @@ -1418,7 +1417,7 @@ trait Typers { self: Analyzer => val gs = new ListBuffer[DefDef] gs.append(getterDef) - if (mods hasFlag MUTABLE) { + if (mods.isMutable) { val setter = getter.setter(value.owner) gs.append(setterDef(setter)) } @@ -1435,14 +1434,14 @@ trait Typers { self: Analyzer => unit.error(stat.pos, "implementation limitation: the BeanProperty annotation cannot be used in a type alias or renamed import") } beanGetter.setAnnotations(memberAnnots(allAnnots, BeanGetterTargetClass)) - if (mods.hasFlag(MUTABLE) && beanGetter != NoSymbol) { + if (mods.isMutable && beanGetter != NoSymbol) { val beanSetterName = "set" + nameSuffix val beanSetter = value.owner.info.decl(beanSetterName) // unlike for the beanGetter, the beanSetter body is generated here. see comment in Namers. gs.append(setterDef(beanSetter, isBean = true)) } } - if (mods hasFlag DEFERRED) gs.toList else vdef :: gs.toList + if (mods.isDeferred) gs.toList else vdef :: gs.toList } case dd @ DocDef(comment, defn) => addGetterSetter(defn) map (stat => DocDef(comment, stat) setPos dd.pos) @@ -1532,7 +1531,7 @@ trait Typers { self: Analyzer => assert(clazz.info.decls != EmptyScope) enterSyms(context.outer.make(templ, clazz, clazz.info.decls), templ.body) validateParentClasses(parents1, selfType) - if (clazz hasFlag CASE) + if (clazz.isCase) validateNoCaseAncestor(clazz) if ((clazz isSubClass ClassfileAnnotationClass) && !clazz.owner.isPackageClass) @@ -1560,7 +1559,7 @@ trait Typers { self: Analyzer => def typedValDef(vdef: ValDef): ValDef = { // attributes(vdef) val sym = vdef.symbol - val typer1 = constrTyperIf(sym.hasFlag(PARAM) && sym.owner.isConstructor) + val typer1 = constrTyperIf(sym.isParameter && sym.owner.isConstructor) val typedMods = removeAnnotations(vdef.mods) // complete lazy annotations @@ -1569,9 +1568,9 @@ trait Typers { self: Analyzer => var tpt1 = checkNoEscaping.privates(sym, typer1.typedType(vdef.tpt)) checkNonCyclic(vdef, tpt1) if (sym.hasAnnotation(definitions.VolatileAttr)) { - if (!sym.hasFlag(MUTABLE)) + if (!sym.isMutable) error(vdef.pos, "values cannot be volatile") - else if (sym.hasFlag(FINAL)) + else if (sym.isFinal) error(vdef.pos, "final vars cannot be volatile") } val rhs1 = @@ -1580,7 +1579,7 @@ trait Typers { self: Analyzer => error(vdef.pos, "local variables must be initialized") vdef.rhs } else { - val tpt2 = if (sym hasFlag DEFAULTPARAM) { + val tpt2 = if (sym.hasDefault) { // When typechecking default parameter, replace all type parameters in the expected type by Wildcard. // This allows defining "def foo[T](a: T = 1)" val tparams = @@ -1638,7 +1637,7 @@ trait Typers { self: Analyzer => if (superConstr.symbol.isPrimaryConstructor) { val superClazz = superConstr.symbol.owner - if (!superClazz.hasFlag(JAVA)) { + if (!superClazz.isJavaDefined) { val superParamAccessors = superClazz.constrParamAccessors if (superParamAccessors.length == superArgs.length) { (superParamAccessors, superArgs).zipped map { (superAcc, superArg) => @@ -1652,7 +1651,7 @@ trait Typers { self: Analyzer => superClazz.info.nonPrivateMember(alias.name) != alias) alias = NoSymbol if (alias != NoSymbol) { - var ownAcc = clazz.info.decl(name).suchThat(_.hasFlag(PARAMACCESSOR)) + var ownAcc = clazz.info.decl(name).suchThat(_.isParamAccessor) if ((ownAcc hasFlag ACCESSOR) && !ownAcc.isDeferred) ownAcc = ownAcc.accessed if (!ownAcc.isVariable && !alias.accessed.isVariable) { @@ -1678,7 +1677,7 @@ trait Typers { self: Analyzer => * - a type member of the structural type * - an abstract type declared outside of the structural type. */ def checkMethodStructuralCompatible(meth: Symbol): Unit = - if (meth.owner.isStructuralRefinement && meth.allOverriddenSymbols.isEmpty && (!meth.hasFlag(PRIVATE) && meth.privateWithin == NoSymbol)) { + if (meth.owner.isStructuralRefinement && meth.allOverriddenSymbols.isEmpty && !(meth.isPrivate || meth.hasAccessBoundary)) { val tp: Type = meth.tpe match { case mt: MethodType => mt case pt: PolyType => pt.resultType @@ -1774,7 +1773,7 @@ trait Typers { self: Analyzer => ddef.tpt.setType(tpt1.tpe) val typedMods = removeAnnotations(ddef.mods) var rhs1 = - if (ddef.name == nme.CONSTRUCTOR && !ddef.symbol.hasFlag(STATIC)) { // need this to make it possible to generate static ctors + if (ddef.name == nme.CONSTRUCTOR && !ddef.symbol.hasStaticFlag) { // need this to make it possible to generate static ctors if (!meth.isPrimaryConstructor && (!meth.owner.isClass || meth.owner.isModuleClass || @@ -1792,7 +1791,7 @@ trait Typers { self: Analyzer => if (tpt1.tpe.typeSymbol != NothingClass && !context.returnsSeen) rhs1 = checkDead(rhs1) if (phase.id <= currentRun.typerPhase.id && meth.owner.isClass && - meth.paramss.exists(ps => ps.exists(_.hasFlag(DEFAULTPARAM)) && isRepeatedParamType(ps.last.tpe))) + meth.paramss.exists(ps => ps.exists(_.hasDefaultFlag) && isRepeatedParamType(ps.last.tpe))) error(meth.pos, "a parameter section with a `*'-parameter is not allowed to have default arguments") if (phase.id <= currentRun.typerPhase.id) { @@ -1935,7 +1934,7 @@ trait Typers { self: Analyzer => for (member <- classDef.symbol.info.decls.toList if member.isTerm && !member.isConstructor && member.allOverriddenSymbols.isEmpty && - (!member.hasFlag(PRIVATE) && member.privateWithin == NoSymbol) && + (!member.isPrivate && !member.hasAccessBoundary) && !(visibleMembers exists { visible => visible.name == member.name && member.tpe <:< visible.tpe.substThis(visible.owner, ThisType(classDef.symbol)) @@ -2048,7 +2047,7 @@ trait Typers { self: Analyzer => error( vparam.pos, "missing parameter type"+ - (if (vparam.mods.hasFlag(SYNTHETIC)) " for expanded function "+fun + (if (vparam.mods.isSynthetic) " for expanded function "+fun else "")) ErrorType } @@ -2132,10 +2131,12 @@ trait Typers { self: Analyzer => } } - def accesses(accessor: Symbol, accessed: Symbol) = - (accessed hasFlag LOCAL) && (accessed hasFlag PARAMACCESSOR) || - (accessor hasFlag ACCESSOR) && - !(accessed hasFlag ACCESSOR) && accessed.isPrivateLocal + /** 'accessor' and 'accessed' are so similar it becomes very difficult to + * follow the logic, so I renamed one to something distinct. + */ + def accesses(looker: Symbol, accessed: Symbol) = accessed.hasLocalFlag && ( + accessed.isParamAccessor || (looker.hasAccessorFlag && !accessed.hasAccessorFlag && accessed.isPrivate) + ) def checkNoDoubleDefsAndAddSynthetics(stats: List[Tree]): List[Tree] = { val scope = if (inBlock) context.scope else context.owner.info.decls @@ -2155,7 +2156,7 @@ trait Typers { self: Analyzer => (e.sym.isType || inBlock || (e.sym.tpe matches e1.sym.tpe))) // default getters are defined twice when multiple overloads have defaults. an // error for this is issued in RefChecks.checkDefaultsInOverloaded - if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasFlag(DEFAULTPARAM)) { + if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasDefaultFlag) { error(e.sym.pos, e1.sym+" is defined twice"+ {if(!settings.debug.value) "" else " in "+unit.toString}) scope.unlink(e1) // need to unlink to avoid later problems with lub; see #2779 @@ -2165,11 +2166,9 @@ trait Typers { self: Analyzer => } // add synthetics - context.unit.synthetics get e.sym match { - case Some(tree) => - newStats += typedStat(tree) // might add even more synthetics to the scope - context.unit.synthetics -= e.sym - case _ => + context.unit.synthetics get e.sym foreach { tree => + newStats += typedStat(tree) // might add even more synthetics to the scope + context.unit.synthetics -= e.sym } e = e.next @@ -2182,7 +2181,7 @@ trait Typers { self: Analyzer => if (newStats.isEmpty) stats else { val (defaultGetters, others) = newStats.toList.partition { - case DefDef(mods, _, _, _, _, _) => mods.hasFlag(DEFAULTPARAM) + case DefDef(mods, _, _, _, _, _) => mods.hasDefaultFlag case _ => false } // default getters first: see #2489 @@ -2251,7 +2250,7 @@ trait Typers { self: Analyzer => def doTypedApply(tree: Tree, fun0: Tree, args: List[Tree], mode: Int, pt: Type): Tree = { var fun = fun0 - if (fun.hasSymbol && (fun.symbol hasFlag OVERLOADED)) { + if (fun.hasSymbol && fun.symbol.isOverloaded) { // remove alternatives with wrong number of parameters without looking at types. // less expensive than including them in inferMethodAlternatvie (see below). def shapeType(arg: Tree): Type = arg match { @@ -2272,13 +2271,13 @@ trait Typers { self: Analyzer => // (I had expected inferMethodAlternative to pick up the slack introduced by using WildcardType here) isApplicableSafe(context.undetparams, followApply(pre.memberType(alt)), argtypes, pt) } - if (sym hasFlag OVERLOADED) { + if (sym.isOverloaded) { val sym1 = sym filter (alt => { // eliminate functions that would result from tupling transforms // keeps alternatives with repeated params hasExactlyNumParams(followApply(alt.tpe), argtypes.length) || // also keep alts which define at least one default - alt.tpe.paramss.exists(_.exists(_.hasFlag(DEFAULTPARAM))) + alt.tpe.paramss.exists(_.exists(_.hasDefault)) }) if (sym1 != NoSymbol) sym = sym1 } @@ -2675,7 +2674,7 @@ trait Typers { self: Analyzer => if (typedFun.isErroneous) annotationError else if (annType.typeSymbol isNonBottomSubClass ClassfileAnnotationClass) { // annotation to be saved as java classfile annotation - val isJava = typedFun.symbol.owner.hasFlag(JAVA) + val isJava = typedFun.symbol.owner.isJavaDefined if (!annType.typeSymbol.isNonBottomSubClass(annClass)) { error(tpt.pos, "expected annotation of type "+ annClass.tpe +", found "+ annType) } else if (argss.length > 1) { @@ -2686,7 +2685,7 @@ trait Typers { self: Analyzer => List(new AssignOrNamedArg(Ident(nme.value), argss.head.head)) else argss.head val annScope = annType.decls - .filter(sym => sym.isMethod && !sym.isConstructor && sym.hasFlag(JAVA)) + .filter(sym => sym.isMethod && !sym.isConstructor && sym.isJavaDefined) val names = new collection.mutable.HashSet[Symbol] names ++= (if (isJava) annScope.iterator else typedFun.tpe.params.iterator) @@ -2713,7 +2712,7 @@ trait Typers { self: Analyzer => for (name <- names) { if (!name.annotations.contains(AnnotationInfo(AnnotationDefaultAttr.tpe, List(), List())) && - !name.hasFlag(DEFAULTPARAM)) + !name.hasDefaultFlag) error(ann.pos, "annotation " + annType.typeSymbol.fullName + " is missing argument " + name.name) } @@ -2789,7 +2788,7 @@ trait Typers { self: Analyzer => } def isRawParameter(sym: Symbol) = // is it a type parameter leaked by a raw type? - sym.isTypeParameter && sym.owner.hasFlag(JAVA) + sym.isTypeParameter && sym.owner.isJavaDefined /** Given a set `rawSyms' of term- and type-symbols, and a type `tp'. * produce a set of fresh type parameters and a type so that it can be @@ -2841,11 +2840,11 @@ trait Typers { self: Analyzer => sym.isExistentialSkolem && sym.unpackLocation == tree || tree.isDef && tree.symbol == sym def isVisibleParameter(sym: Symbol) = - (sym hasFlag PARAM) && (sym.owner == owner) && (sym.isType || !owner.isAnonymousFunction) + sym.isParameter && (sym.owner == owner) && (sym.isType || !owner.isAnonymousFunction) def containsDef(owner: Symbol, sym: Symbol): Boolean = - (!(sym hasFlag PACKAGE)) && { + (!sym.hasPackageFlag) && { var o = sym.owner - while (o != owner && o != NoSymbol && !(o hasFlag PACKAGE)) o = o.owner + while (o != owner && o != NoSymbol && !o.hasPackageFlag) o = o.owner o == owner && !isVisibleParameter(sym) } var localSyms = collection.immutable.Set[Symbol]() @@ -2874,7 +2873,7 @@ trait Typers { self: Analyzer => def addLocals(tp: Type) { val remainingSyms = new ListBuffer[Symbol] def addIfLocal(sym: Symbol, tp: Type) { - if (isLocal(sym) && !localSyms.contains(sym) && !boundSyms.contains(sym)) { + if (isLocal(sym) && !localSyms(sym) && !boundSyms(sym)) { if (sym.typeParams.isEmpty) { localSyms += sym remainingSyms += sym @@ -3198,9 +3197,9 @@ trait Typers { self: Analyzer => */ def narrowRhs(tp: Type) = { val sym = context.tree.symbol context.tree match { - case ValDef(mods, _, _, Apply(Select(`tree`, _), _)) if !(mods hasFlag MUTABLE) && sym != null && sym != NoSymbol => + case ValDef(mods, _, _, Apply(Select(`tree`, _), _)) if !mods.isMutable && sym != null && sym != NoSymbol => val sym1 = if (sym.owner.isClass && sym.getter(sym.owner) != NoSymbol) sym.getter(sym.owner) - else if ((sym hasFlag LAZY) && sym.lazyAccessor != NoSymbol) sym.lazyAccessor + else if (sym.isLazyAccessor) sym.lazyAccessor else sym val pre = if (sym1.owner.isClass) sym1.owner.thisType else NoPrefix intersectionType(List(tp, singleType(pre, sym1))) @@ -3209,7 +3208,7 @@ trait Typers { self: Analyzer => val tp = tpt1.tpe val sym = tp.typeSymbol - if (sym.isAbstractType || (sym hasFlag ABSTRACT)) + if (sym.isAbstractType || sym.hasAbstractFlag) error(tree.pos, sym + " is abstract; cannot be instantiated") else if (!( tp == sym.initialize.thisSym.tpe // when there's no explicit self type -- with (#3612) or without self variable // sym.thisSym.tpe == tp.typeOfThis (except for objects) @@ -3544,7 +3543,7 @@ trait Typers { self: Analyzer => } if (!reallyExists(sym)) { - if (context.owner.toplevelClass.hasFlag(JAVA) && name.isTypeName) { + if (context.owner.toplevelClass.isJavaDefined && name.isTypeName) { val tree1 = atPos(tree.pos) { gen.convertToSelectFromType(qual, name) } if (tree1 != EmptyTree) return typed1(tree1, mode, pt) } diff --git a/src/library/scala/reflect/generic/HasFlags.scala b/src/library/scala/reflect/generic/HasFlags.scala index 9ce91ce197..2f635fbd79 100644 --- a/src/library/scala/reflect/generic/HasFlags.scala +++ b/src/library/scala/reflect/generic/HasFlags.scala @@ -26,7 +26,7 @@ package generic final def isModuleVar: Boolean = isVariable && hasFlag(MODULEVAR) final def isStable = isTerm && - !hasFlag(MUTABLE) && + !hasTraitFlag && (!hasFlag(METHOD | BYNAMEPARAM) || hasFlag(STABLE)) && !(tpe.isVolatile && !hasAnnotation(uncheckedStableClass)) final def isStatic: Boolean = @@ -178,8 +178,10 @@ trait HasFlags { def isDefaultInit = hasFlag(DEFAULTINIT) // Disambiguating: DEFAULTPARAM, TRAIT - def hasDefault = hasAllFlags(DEFAULTPARAM | PARAM) - def isTrait = hasFlag(TRAIT) && !hasFlag(PARAM) + def hasDefault = hasAllFlags(DEFAULTPARAM | PARAM) + def isTrait = hasFlag(TRAIT) && !hasFlag(PARAM) + def hasTraitFlag = hasFlag(TRAIT) + def hasDefaultFlag = hasFlag(DEFAULTPARAM) // Straightforwardly named accessors already being used differently. // These names are most likely temporary. diff --git a/src/library/scala/reflect/generic/Symbols.scala b/src/library/scala/reflect/generic/Symbols.scala index 25454698f8..0362e497e5 100755 --- a/src/library/scala/reflect/generic/Symbols.scala +++ b/src/library/scala/reflect/generic/Symbols.scala @@ -135,7 +135,6 @@ trait Symbols { self: Universe => final def isCovariant = isType && hasFlag(COVARIANT) final def isEarlyInitialized: Boolean = isTerm && hasFlag(PRESUPER) final def isExistentiallyBound = isType && hasFlag(EXISTENTIAL) - final def isGetterOrSetter = hasFlag(ACCESSOR) final def isImplClass = isClass && hasFlag(IMPLCLASS) // Is this symbol an implementation class for a mixin? final def isLazyAccessor = isLazy && lazyAccessor != NoSymbol final def isMethod = isTerm && hasFlag(METHOD) |