/* NSC -- new Scala compiler
* Copyright 2005-2006 LAMP/EPFL
* @author Martin Odersky
*/
// $Id$
package scala.tools.nsc.symtab
import scala.tools.nsc.io.AbstractFile
import scala.tools.nsc.util.{Position, SourceFile}
import Flags._
trait Symbols requires SymbolTable {
import definitions._
private var ids = 0
//for statistics:
def symbolCount = ids
var typeSymbolCount = 0
var classSymbolCount = 0
type AttrInfo = Triple[Type, List[Constant], List[Pair[Name,Constant]]]
val emptySymbolArray = new Array[Symbol](0)
type PositionType
val NoPos: PositionType
val FirstPos: PositionType
implicit def coercePosToInt(pos: PositionType): Int
def coerceIntToPos(pos: Int): PositionType
object RequiresIntsAsPositions {
implicit def coerceIntToPos0(pos: Int) =
coerceIntToPos(pos)
}
/** The class for all symbols */
abstract class Symbol(initOwner: Symbol, initPos: PositionType, initName: Name) {
var rawowner = initOwner
var rawname = initName
var rawflags: long = 0
private var rawpos = initPos
val id = { ids = ids + 1; ids }
var validTo: Period = NoPeriod
def pos = rawpos
def setPos(pos: PositionType): this.type = { this.rawpos = pos; this }
def namePos(source: SourceFile) = {
val pos: Int = this.pos
val buf = source.content
if (pos == Position.NOPOS) Position.NOPOS
else if (isTypeParameter) pos - name.length
else if (isVariable || isMethod || isClass || isModule) {
var ret = pos
if (buf(pos) == ',') ret = ret + 1
else if (isClass) ret = ret + ("class").length()
else if (isModule) ret = ret + ("object").length()
else ret = ret + ("var").length()
while (Character.isWhitespace(buf(ret))) ret = ret + 1
ret
}
else if (isValue) {
if (pos < (buf.length + ("val ").length())) {
if ((buf(pos + 0) == 'v') &&
(buf(pos + 1) == 'a') &&
(buf(pos + 2) == 'l') &&
(buf(pos + 3) == ' ')) {
var pos0 = pos + 4
while (pos0 < buf.length && Character.isWhitespace(buf(pos0)))
pos0 = pos0 + 1
pos0
} else pos
} else pos
}
else -1
}
var attributes: List[AttrInfo] = List()
var privateWithin: Symbol = _
// Creators -------------------------------------------------------------------
final def newValue(pos: PositionType, name: Name) =
new TermSymbol(this, pos, name)
final def newVariable(pos: PositionType, name: Name) =
newValue(pos, name).setFlag(MUTABLE)
final def newValueParameter(pos: PositionType, name: Name) =
newValue(pos, name).setFlag(PARAM)
final def newLocalDummy(pos: PositionType) =
newValue(pos, nme.LOCAL(this)).setInfo(NoType)
final def newMethod(pos: PositionType, name: Name) =
newValue(pos, name).setFlag(METHOD)
final def newLabel(pos: PositionType, name: Name) =
newMethod(pos, name).setFlag(LABEL)
final def newConstructor(pos: PositionType) =
newMethod(pos, nme.CONSTRUCTOR)
final def newModule(pos: PositionType, name: Name, clazz: ClassSymbol) =
new ModuleSymbol(this, pos, name).setFlag(MODULE | FINAL).setModuleClass(clazz)
final def newModule(pos: PositionType, name: Name) = {
val m = new ModuleSymbol(this, pos, name).setFlag(MODULE | FINAL)
m.setModuleClass(new ModuleClassSymbol(m))
}
final def newPackage(pos: PositionType, name: Name) = {
assert(name == nme.ROOT || isPackageClass)
val m = newModule(pos, name).setFlag(JAVA | PACKAGE)
m.moduleClass.setFlag(JAVA | PACKAGE)
m
}
final def newThisSym(pos: PositionType) = {
newValue(pos, nme.this_).setFlag(SYNTHETIC)
}
final def newThisSkolem: Symbol =
new ThisSkolem(owner, pos, name, this)
.setFlag(SYNTHETIC | FINAL)
final def newImport(pos: PositionType) =
newValue(pos, nme.IMPORT).setFlag(SYNTHETIC)
final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol =
newValue(alternatives.head.pos, alternatives.head.name)
.setFlag(OVERLOADED)
.setInfo(OverloadedType(pre, alternatives))
final def newErrorValue(name: Name) =
newValue(pos, name).setFlag(SYNTHETIC | IS_ERROR).setInfo(ErrorType)
final def newAliasType(pos: PositionType, name: Name) =
new TypeSymbol(this, pos, name)
final def newAbstractType(pos: PositionType, name: Name) =
new TypeSymbol(this, pos, name).setFlag(DEFERRED)
final def newTypeParameter(pos: PositionType, name: Name) =
newAbstractType(pos, name).setFlag(PARAM)
final def newTypeSkolem: Symbol =
new TypeSkolem(owner, pos, name, this)
.setFlag(flags)
final def newClass(pos: PositionType, name: Name) =
new ClassSymbol(this, pos, name)
final def newModuleClass(pos: PositionType, name: Name) =
new ModuleClassSymbol(this, pos, name)
final def newAnonymousClass(pos: PositionType) =
newClass(pos, nme.ANON_CLASS_NAME.toTypeName)
final def newAnonymousFunctionClass(pos: PositionType) = {
val anonfun = newClass(pos, nme.ANON_FUN_NAME.toTypeName)
anonfun.attributes =
Triple(definitions.SerializableAttr.tpe, List(), List()) :: anonfun.attributes
anonfun
}
final def newRefinementClass(pos: PositionType) =
newClass(pos, nme.REFINE_CLASS_NAME.toTypeName)
final def newErrorClass(name: Name) = {
val clazz = newClass(pos, name).setFlag(SYNTHETIC | IS_ERROR)
clazz.setInfo(ClassInfoType(List(), new ErrorScope(this), clazz))
clazz
}
final def newErrorSymbol(name: Name): Symbol =
if (name.isTypeName) newErrorClass(name) else newErrorValue(name)
// Tests ----------------------------------------------------------------------
def isTerm = false //to be overridden
def isType = false //to be overridden
def isClass = false //to be overridden
final def isValue = isTerm && !(isModule && hasFlag(PACKAGE | JAVA))
final def isVariable = isTerm && hasFlag(MUTABLE) && !isMethod
final def isCapturedVariable = isVariable && hasFlag(CAPTURED)
final def isGetter = isTerm && hasFlag(ACCESSOR) && !nme.isSetterName(name)
final def isSetter = isTerm && hasFlag(ACCESSOR) && nme.isSetterName(name)
//todo: make independent of name, as this can be forged.
final def hasGetter = isTerm && nme.isLocalName(name)
final def isValueParameter = isTerm && hasFlag(PARAM)
final def isLocalDummy = isTerm && nme.isLocalDummyName(name)
final def isMethod = isTerm && hasFlag(METHOD)
final def isSourceMethod = isTerm && (flags & (METHOD | STABLE)) == METHOD
final def isLabel = isTerm && hasFlag(LABEL)
final def isClassConstructor = isTerm && (name == nme.CONSTRUCTOR)
final def isMixinConstructor = isTerm && (name == nme.MIXIN_CONSTRUCTOR)
final def isConstructor = isTerm && (name == nme.CONSTRUCTOR) || (name == nme.MIXIN_CONSTRUCTOR)
final def isModule = isTerm && hasFlag(MODULE)
final def isStaticModule = isModule && isStatic && !isMethod
final def isPackage = isModule && hasFlag(PACKAGE)
final def isThisSym = isTerm && name == nme.this_
final def isThisSkolem = isTerm && deSkolemize != this
final def isError = hasFlag(IS_ERROR)
final def isErroneous = isError || isInitialized && tpe.isErroneous
final def isTrait = isClass & hasFlag(TRAIT)
final def isAliasType = isType && !isClass && !hasFlag(DEFERRED)
final def isAbstractType = isType && !isClass && hasFlag(DEFERRED)
final def isTypeParameterOrSkolem = isType && hasFlag(PARAM)
final def isTypeParameter = isTypeParameterOrSkolem && deSkolemize == this
final def isClassLocalToConstructor = isClass && hasFlag(INCONSTRUCTOR)
final def isAnonymousClass = isClass && (originalName startsWith nme.ANON_CLASS_NAME)
// startsWith necessary because name may grow when lifted and also because of anonymous function classes
final def isRefinementClass = isClass && name == nme.REFINE_CLASS_NAME.toTypeName; // no lifting for refinement classes
final def isModuleClass = isClass && hasFlag(MODULE)
final def isPackageClass = isClass && hasFlag(PACKAGE)
final def isRoot = isPackageClass && name == nme.ROOT.toTypeName
final def isRootPackage = isPackage && name == nme.ROOTPKG
final def isEmptyPackage = isPackage && name == nme.EMPTY_PACKAGE_NAME
final def isEmptyPackageClass = isPackageClass && name == nme.EMPTY_PACKAGE_NAME.toTypeName
/** Does this symbol denote a stable value? */
final def isStable =
isTerm && !hasFlag(MUTABLE) && (!hasFlag(METHOD | BYNAMEPARAM) || hasFlag(STABLE))
/** Does this symbol denote the primary constructor of its enclosing class? */
final def isPrimaryConstructor =
isConstructor && owner.primaryConstructor == this
/** Is this symbol an implementation class for a mixin? */
final def isImplClass: boolean = isClass && hasFlag(IMPLCLASS)
/** Is this symbol a trait which needs an implementation class? */
final def needsImplClass: boolean =
isTrait && (!hasFlag(INTERFACE) || hasFlag(lateINTERFACE)) && !isImplClass
/** Is this a symbol which exists only in the implementation class, not in its trait? */
final def isImplOnly: boolean = (
hasFlag(PRIVATE) ||
(owner.isImplClass || owner.isTrait) &&
(hasFlag(notPRIVATE | LIFTED) && !hasFlag(ACCESSOR | SUPERACCESSOR | MODULE) || isConstructor)
)
/** Is this symbol a module variable ? */
final def isModuleVar: boolean = isVariable && hasFlag(MODULEVAR)
/** Is this symbol static (i.e. with no outer instance)? */
final def isStatic: boolean =
hasFlag(STATIC) || isRoot || owner.isStaticOwner
/** Does this symbol denote a class that defines static symbols? */
final def isStaticOwner: boolean =
isPackageClass || isModuleClass && isStatic
/** Is this symbol final?*/
final def isFinal: boolean = (
hasFlag(FINAL) ||
isTerm && (
hasFlag(PRIVATE) || isLocal || owner.isClass && owner.hasFlag(FINAL | MODULE))
)
/** Is this symbol a sealed class?*/
final def isSealed: boolean =
isClass && (hasFlag(SEALED) || isUnboxedClass(this))
/** Is this symbol locally defined? I.e. not accessed from outside `this' instance */
final def isLocal: boolean = owner.isTerm
/** Is this symbol a constant? */
final def isConstant: boolean =
isStable && (tpe match {
case ConstantType(_) => true
case PolyType(_, ConstantType(_)) => true
case MethodType(_, ConstantType(_)) => true
case _ => false
})
/** Is this class nested in another class or module (not a package)? */
final def isNestedClass: boolean =
isClass && !isRoot && !owner.isPackageClass
/** Is this class locally defined?
* A class is local, if
* - it is anonymous, or
* - its owner is a value
* - it is defined within a local class214
*/
final def isLocalClass: boolean =
isClass && (isAnonymousClass || isRefinementClass || isLocal ||
!owner.isPackageClass && owner.isLocalClass)
/** A a member of class `base' is incomplete if (1) it is declared deferred or
* (2) it is abstract override and its super symbol in `base' is nonexistent or inclomplete.
*/
final def isIncompleteIn(base: Symbol): boolean = (
(this hasFlag DEFERRED) ||
(this hasFlag ABSOVERRIDE) && {
val supersym = superSymbol(base)
supersym == NoSymbol || supersym.isIncompleteIn(base)
}
)
final def exists: boolean =
this != NoSymbol && (!owner.isPackageClass || { rawInfo.load(this); rawInfo != NoType })
final def isInitialized: boolean =
runId(validTo) == currentRunId
final def isCovariant: boolean = isType && hasFlag(COVARIANT)
final def isContravariant: boolean = isType && hasFlag(CONTRAVARIANT)
/** The variance of this symbol as an integer */
final def variance: int =
if (isCovariant) 1
else if (isContravariant) -1
else 0
// Flags, owner, and name attributes --------------------------------------------------------------
def owner: Symbol = rawowner
final def owner_=(owner: Symbol): unit = { rawowner = owner }
def ownerChain: List[Symbol] = this :: owner.ownerChain
def name: Name = rawname
final def name_=(name: Name): unit = { rawname = name }
def originalName = nme.originalName(name)
final def flags = {
val fs = rawflags & phase.flagMask
(fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
}
final def flags_=(fs: long) = rawflags = fs
final def setFlag(mask: long): this.type = { rawflags = rawflags | mask; this }
final def resetFlag(mask: long): this.type = { rawflags = rawflags & ~mask; this }
final def getFlag(mask: long): long = flags & mask
final def hasFlag(mask: long): boolean = (flags & mask) != 0
final def resetFlags: unit = { rawflags = rawflags & TopLevelCreationFlags }
/** The class up to which this symbol is accessible,
* or NoSymbol if it is public or not a class member
*/
final def accessBoundary(base: Symbol): Symbol = {
if (hasFlag(PRIVATE)) owner
else if (privateWithin != NoSymbol && !phase.erasedTypes) privateWithin
else if (hasFlag(PROTECTED)) base
else NoSymbol
}
// Info and Type -------------------------------------------------------------------
private var infos: TypeHistory = null
/** Get type. The type of a symbol is:
* for a type symbol, the type corresponding to the symbol itself
* for a term symbol, its usual type
*/
def tpe: Type = info
/** Get type info associated with symbol at current phase, after
* ensuring that symbol is initialized (i.e. type is completed).
*/
final def info: Type = {
var cnt = 0
while (runId(validTo) != currentRunId) {
//if (settings.debug.value) System.out.println("completing " + this);//DEBUG
var ifs = infos
assert(ifs != null, this.name)
while (ifs.prev != null) {
ifs = ifs.prev
}
val tp = ifs.info
//if (settings.debug.value) System.out.println("completing " + this.rawname + tp.getClass());//debug
if ((rawflags & LOCKED) != 0) {
setInfo(ErrorType)
throw CyclicReference(this, tp)
}
rawflags = rawflags | LOCKED
val current = phase
try {
phase = phaseWithId(ifs.start)
tp.complete(this)
// if (settings.debug.value && runId(validTo) == currentRunId) System.out.println("completed " + this/* + ":" + info*/);//DEBUG
rawflags = rawflags & ~LOCKED
} finally {
phase = current
}
cnt = cnt + 1
// allow for two completions:
// one: sourceCompleter to LazyType, two: LazyType to completed type
if (cnt == 3) throw new Error("no progress in completing " + this + ":" + tp)
}
rawInfo
}
/** Set initial info. */
def setInfo(info: Type): this.type = {
assert(info != null)
var period = currentPeriod
if (phaseId(period) == 0) {
// can happen when we initialize NoSymbol before running the compiler
assert(name == nme.NOSYMBOL)
period = period + 1
}
infos = new TypeHistory(phaseId(period), info, null)
if (info.isComplete) {
rawflags = rawflags & ~LOCKED
validTo = currentPeriod
} else {
rawflags = rawflags & ~LOCKED
validTo = NoPeriod
}
this
}
/** Set new info valid from start of this phase. */
final def updateInfo(info: Type): Symbol = {
assert(infos.start <= phase.id)
if (infos.start == phase.id) infos = infos.prev
infos = new TypeHistory(phase.id, info, infos)
this
}
/** Return info without checking for initialization or completing */
final def rawInfo: Type =
if (validTo == currentPeriod) {
infos.info
} else {
var limit = phaseId(validTo)
if (limit < phase.id) {
if (runId(validTo) == currentRunId) {
val current = phase
var itr = infoTransformers.nextFrom(limit)
infoTransformers = itr; // caching optimization
while (itr.pid != NoPhase.id && itr.pid < current.id) {
limit = itr.pid
phase = phaseWithId(limit)
val info1 = itr.transform(this, infos.info)
validTo = currentPeriod + 1
if (info1 ne infos.info) {
infos = new TypeHistory(limit + 1, info1, infos)
}
itr = itr.nextFrom(limit + 1)
}
phase = current
validTo = currentPeriod
}
assert(infos != null, name)
infos.info
} else {
var infos = this.infos
while (phase.id < infos.start && infos.prev != null) infos = infos.prev
infos.info
}
}
/** Initialize the symbol */
final def initialize: this.type = {
if (!isInitialized) info
this
}
/** Was symbol's type updated during given phase? */
final def isUpdatedAt(pid: Phase#Id): boolean = {
var infos = this.infos
while (infos != null && infos.start != pid + 1) infos = infos.prev
infos != null
}
/** The type constructor of a symbol is:
* For a type symbol, the type corresponding to the symbol itself,
* excluding parameters.
* Not applicable for term symbols.
*/
def typeConstructor: Type =
throw new Error("typeConstructor inapplicable for " + this)
/** The type parameters of this symbol */
def unsafeTypeParams: List[Symbol] = rawInfo.typeParams
def typeParams: List[Symbol] = {
rawInfo.load(this); rawInfo.typeParams
}
def getAttributes(clazz: Symbol): List[AttrInfo] =
attributes.filter(._1.symbol.isNonBottomSubClass(clazz))
/** Reset symbol to initial state
*/
def reset(completer: Type): unit = {
resetFlags
infos = null
validTo = NoPeriod
//limit = NoPhase.id
setInfo(completer)
}
// Comparisons ----------------------------------------------------------------
/** A total ordering between symbols that refines the class
* inheritance graph (i.e. subclass.isLess(superclass) always holds).
* the ordering is given by: (isType, -|closure| for type symbols, id)
*/
final def isLess(that: Symbol): boolean = {
def closureLength(sym: Symbol) =
if (sym.isAbstractType) 1 + sym.info.bounds.hi.closure.length
else sym.info.closure.length
if (this.isType)
(that.isType &&
{ val diff = closureLength(this) - closureLength(that)
diff > 0 || diff == 0 && this.id < that.id })
else
that.isType || this.id < that.id
}
/** A partial ordering between symbols.
* (this isNestedIn that) holds iff this symbol is defined within
* a class or method defining that symbol
*/
final def isNestedIn(that: Symbol): boolean =
owner == that || owner != NoSymbol && (owner isNestedIn that)
/** Is this class symbol a subclass of that symbol? */
final def isNonBottomSubClass(that: Symbol): boolean = {
this == that || this.isError || that.isError ||
info.closurePos(that) >= 0
}
final def isSubClass(that: Symbol): boolean = {
isNonBottomSubClass(that) ||
this == AllClass ||
this == AllRefClass &&
(that == AnyClass ||
that != AllClass && (that isSubClass AnyRefClass))
}
// Overloaded Alternatives ---------------------------------------------------------
def alternatives: List[Symbol] =
if (hasFlag(OVERLOADED)) info.asInstanceOf[OverloadedType].alternatives
else List(this)
def filter(cond: Symbol => boolean): Symbol =
if (hasFlag(OVERLOADED)) {
//assert(info.isInstanceOf[OverloadedType], "" + this + ":" + info);//DEBUG
val alts = alternatives
val alts1 = alts filter cond
if (alts1 eq alts) this
else if (alts1.isEmpty) NoSymbol
else if (alts1.tail.isEmpty) alts1.head
else owner.newOverloaded(info.prefix, alts1)
} else if (cond(this)) this
else NoSymbol
def suchThat(cond: Symbol => boolean): Symbol = {
val result = filter(cond)
assert(!(result hasFlag OVERLOADED), result.alternatives)
result
}
// Cloneing -------------------------------------------------------------------
/** A clone of this symbol */
final def cloneSymbol: Symbol =
cloneSymbol(owner)
/** A clone of this symbol, but with given owner */
final def cloneSymbol(owner: Symbol): Symbol =
cloneSymbolImpl(owner).setInfo(info.cloneInfo(owner)).setFlag(this.rawflags)
/** Internal method to clone a symbol's implementation without flags or type
*/
def cloneSymbolImpl(owner: Symbol): Symbol
// Access to related symbols --------------------------------------------------
/** The next enclosing class */
def enclClass: Symbol = if (isClass) this else owner.enclClass
/** The next enclosing method */
def enclMethod: Symbol = if (isSourceMethod) this else owner.enclMethod
/** The primary constructor of a class */
def primaryConstructor: Symbol = {
val c = info.decl(if (isTrait || isImplClass) nme.MIXIN_CONSTRUCTOR else nme.CONSTRUCTOR)
if (c hasFlag OVERLOADED) c.alternatives.head else c
}
/** The self symbol of a class with explicit self type, or else the symbol itself.
*/
def thisSym: Symbol = this
/** The type of `this' in a class, or else the type of the symbol itself. */
def typeOfThis = thisSym.tpe
/** Sets the type of `this' in a class */
def typeOfThis_=(tp: Type): unit =
throw new Error("typeOfThis cannot be set for " + this)
/** If symbol is a class, the type this.type in this class, otherwise NoPrefix */
def thisType: Type = NoPrefix
/** Return every accessor of a primary constructor parameter in this case class
* todo: limit to accessors for first constructor parameter section.
*/
final def caseFieldAccessors: List[Symbol] =
info.decls.toList filter (sym => !(sym hasFlag PRIVATE) && sym.hasFlag(CASEACCESSOR))
final def constrParamAccessors: List[Symbol] =
info.decls.toList filter (sym => !sym.isMethod && sym.hasFlag(PARAMACCESSOR))
/** The symbol accessed by this accessor function.
*/
final def accessed: Symbol = {
assert(hasFlag(ACCESSOR))
owner.info.decl(nme.getterToLocal(if (isSetter) nme.setterToGetter(name) else name))
}
final def implClass: Symbol = owner.info.decl(nme.implClassName(name))
/** For a paramaccessor: a superclass paramaccessor for which this symbol is
* an alias, NoSymbol for all others */
def alias: Symbol = NoSymbol
/** The top-level class containing this symbol */
def toplevelClass: Symbol =
if (isClass && owner.isPackageClass) this else owner.toplevelClass
/** The class with the same name in the same package as this module or
* case class factory
*/
final def linkedClassOfModule: Symbol = {
if (this != NoSymbol)
owner.info.decl(name.toTypeName).suchThat(sym => sym.rawInfo ne NoType)
else NoSymbol
}
/** The module or case class factory with the same name in the same
* package as this class.
*/
final def linkedModuleOfClass: Symbol =
if (this.isClass && !this.isAnonymousClass && !this.isRefinementClass) {
owner.rawInfo.decl(name.toTermName).suchThat(
sym => (sym hasFlag MODULE) && (sym.rawInfo ne NoType))
} else NoSymbol
/** For a module its linked class, for a class its linked module or case factory otherwise */
final def linkedSym: Symbol =
if (isTerm) linkedClassOfModule
else if (isClass) owner.info.decl(name.toTermName).suchThat(sym => sym.rawInfo ne NoType)
else NoSymbol
/** For a module class its linked class, for a plain class
* the module class of itys linked module */
final def linkedClassOfClass: Symbol =
if (isModuleClass) linkedClassOfModule else linkedModuleOfClass.moduleClass
final def toInterface: Symbol =
if (isImplClass) {
val result =
if (phase.next.erasedTypes) {
assert(!tpe.parents.isEmpty, this)
tpe.parents.last.symbol
} else {
owner.info.decl(nme.interfaceName(name))
}
assert(result != NoSymbol, this)
result
} else this
/** The module corresponding to this module class (note that this
* is not updated when a module is cloned).
*/
def sourceModule: Symbol = NoSymbol
/** The module class corresponding to this module.
*/
def moduleClass: Symbol = NoSymbol
/** The non-abstract, symbol whose type matches the type of this symbol
* in in given class.
*
* @param ofclazz The class containing the symbol's definition
* @param site The base type from which member types are computed
*/
final def matchingSymbol(ofclazz: Symbol, site: Type): Symbol =
ofclazz.info.nonPrivateDecl(name).filter(sym =>
!sym.isTerm || (site.memberType(this) matches site.memberType(sym)))
/** The symbol overridden by this symbol in given class `ofclazz' */
final def overriddenSymbol(ofclazz: Symbol): Symbol =
matchingSymbol(ofclazz, owner.thisType)
/** The symbol overriding this symbol in given subclass `ofclazz' */
final def overridingSymbol(ofclazz: Symbol): Symbol =
matchingSymbol(ofclazz, ofclazz.thisType)
final def allOverriddenSymbols: List[Symbol] =
if (owner.isClass)
for { val bc <- owner.info.baseClasses
val s = overriddenSymbol(bc)
s != NoSymbol } yield s
else List()
/** The symbol accessed by a super in the definition of this symbol when
* seen from class `base'. This symbol is always concrete.
* pre: `this.owner' is in the base class sequence of `base'.
*/
final def superSymbol(base: Symbol): Symbol = {
var bcs = base.info.baseClasses.dropWhile(owner !=).tail
var sym: Symbol = NoSymbol
while (!bcs.isEmpty && sym == NoSymbol) {
if (!bcs.head.isImplClass)
sym = matchingSymbol(bcs.head, base.thisType).suchThat(
sym => !sym.hasFlag(DEFERRED))
bcs = bcs.tail
}
sym
}
/** The getter of this value definition in class `base', or NoSymbol if
* none exists.
*/
final def getter(base: Symbol): Symbol =
base.info.decl(nme.getterName(name)) filter (.hasFlag(ACCESSOR))
/** The setter of this value definition, or NoSymbol if none exists */
final def setter(base: Symbol): Symbol =
base.info.decl(nme.getterToSetter(nme.getterName(name))) filter (.hasFlag(ACCESSOR))
/** If this symbol is a skolem, its corresponding type parameter, otherwise this */
def deSkolemize: Symbol = this
/** Remove private modifier from symbol `sym's definition. If `sym' is a
* term symbol rename it by expanding its name to avoid name clashes
*/
final def makeNotPrivate(base: Symbol): unit =
if (this hasFlag PRIVATE) {
setFlag(notPRIVATE)
if (!hasFlag(DEFERRED) && isTerm) setFlag(lateFINAL)
expandName(base)
if (isModule) moduleClass.makeNotPrivate(base)
}
/** change name by appending $$<fully-qualified-name-of-class `base'>
* Do the same for any accessed symbols or setters/getters
*/
def expandName(base: Symbol): unit =
if (this != NoSymbol && !hasFlag(EXPANDEDNAME)) {
setFlag(EXPANDEDNAME)
if (hasFlag(ACCESSOR)) {
accessed.expandName(base)
} else if (hasGetter) {
getter(owner).expandName(base)
setter(owner).expandName(base)
}
name = base.expandedName(name)
if (isType) name = name.toTypeName
}
def expandedName(name: Name): Name =
newTermName(fullNameString('$') + nme.EXPAND_SEPARATOR_STRING + name)
def sourceFile: AbstractFile =
(if (isModule) moduleClass else toplevelClass).sourceFile
def sourceFile_=(f: AbstractFile): unit =
throw new Error("sourceFile_= inapplicable for " + this)
def isFromClassFile: Boolean =
(if (isModule) moduleClass else toplevelClass).isFromClassFile
// ToString -------------------------------------------------------------------
/** A tag which (in the ideal case) uniquely identifies class symbols */
final def tag: int = fullNameString.hashCode()
/** The simple name of this Symbol (this is always a term name) */
final def simpleName: Name = name
/** String representation of symbol's definition key word */
final def keyString: String =
if (isTrait && hasFlag(JAVA)) "interface"
else if (isTrait) "trait"
else if (isClass) "class"
else if (isType && !hasFlag(PARAM)) "type"
else if (isVariable) "var"
else if (isPackage) "package"
else if (isModule) "object"
else if (isMethod) "def"
else if (isTerm && (!hasFlag(PARAM) || hasFlag(PARAMACCESSOR))) "val"
else ""
/** String representation of symbol's kind */
final def kindString: String =
if (isPackageClass)
if (settings.debug.value) "package class" else "package"
else if (isAnonymousClass) "template"
else if (isRefinementClass) ""
else if (isModuleClass) "singleton class"
else if (isTrait) "trait"
else if (isClass) "class"
else if (isType) "type"
else if (isVariable) "variable"
else if (isPackage) "package"
else if (isModule) "object"
else if (isClassConstructor) "constructor"
else if (isSourceMethod) "method"
else if (isTerm) "value"
else ""
/** String representation of symbol's simple name.
* If !settings.debug translates expansions of operators back to operator symbol.
* E.g. $eq => =.
* If settings.uniquId adds id.
*/
def nameString: String =
simpleName.decode + idString
/** String representation of symbol's full name with `separator'
* between class names.
* Never translates expansions of operators back to operator symbol.
* Never adds id.
*/
final def fullNameString(separator: char): String = {
assert(owner != NoSymbol, this)
var str =
if (owner.isRoot || owner.isEmptyPackageClass) simpleName.toString()
else owner.fullNameString(separator) + separator + simpleName
if (str.charAt(str.length - 1) == ' ') str = str.substring(0, str.length - 1)
str
}
final def fullNameString: String = fullNameString('.')
/** If settings.uniqid is set, the symbol's id, else "" */
final def idString: String =
if (settings.uniqid.value) "#" + id else ""
/** String representation, including symbol's kind
* e.g., "class Foo", "method Bar".
*/
override def toString(): String =
compose(List(kindString, if (isClassConstructor) owner.nameString else nameString))
/** String representation of location. */
final def locationString: String =
if (owner.isClass &&
(!owner.isAnonymousClass && !owner.isRefinementClass || settings.debug.value))
" in " + (if (owner.isModuleClass) "object " + owner.nameString else owner)
else ""
/** String representation of symbol's definition following its name */
final def infoString(tp: Type): String = {
def typeParamsString: String = tp match {
case PolyType(tparams, _) if (tparams.length != 0) =>
(tparams map (.defString)).mkString("[", ",", "]")
case _ =>
""
}
if (isClass)
typeParamsString + " extends " + tp.resultType
else if (isAliasType)
typeParamsString + " = " + tp.resultType
else if (isAbstractType)
tp match {
case TypeBounds(lo, hi) =>
(if (lo.symbol == AllClass) "" else " >: " + lo) +
(if (hi.symbol == AnyClass) "" else " <: " + hi)
case _ =>
"<: " + tp
}
else if (isModule)
moduleClass.infoString(tp)
else
tp match {
case PolyType(tparams, res) =>
typeParamsString + infoString(res)
case MethodType(pts, res) =>
pts.mkString("(", ",", ")") + infoString(res)
case _ =>
": " + tp
}
}
def infosString = infos.toString()
/** String representation of symbol's variance */
private def varianceString: String =
if (variance == 1) "+"
else if (variance == -1) "-"
else ""
/** String representation of symbol's definition */
final def defString: String =
compose(List(flagsToString(if (settings.debug.value) flags else flags & ExplicitFlags),
keyString,
varianceString + nameString + infoString(rawInfo)))
/** Concatenate strings separated by spaces */
private def compose(ss: List[String]): String =
ss.filter("" !=).mkString("", " ", "")
}
/** A class for term symbols */
class TermSymbol(initOwner: Symbol, initPos: PositionType, initName: Name)
extends Symbol(initOwner, initPos, initName) {
override def isTerm = true
privateWithin = NoSymbol
override def owner: Symbol = {
if (name == nme.MIXIN_CONSTRUCTOR && !phase.erasedTypes && super.owner.isImplClass)
super.owner.toInterface
else rawowner
}
protected var referenced: Symbol = NoSymbol
def cloneSymbolImpl(owner: Symbol): Symbol = {
val clone = new TermSymbol(owner, pos, name)
clone.referenced = referenced
clone
}
override def alias: Symbol =
if (hasFlag(SUPERACCESSOR | PARAMACCESSOR | MIXEDIN)) initialize.referenced
else NoSymbol
def setAlias(alias: Symbol): TermSymbol = {
assert(alias != NoSymbol, this)
assert(!(alias hasFlag OVERLOADED), alias)
assert(hasFlag(SUPERACCESSOR | PARAMACCESSOR | MIXEDIN), this)
referenced = alias
this
}
override def moduleClass: Symbol =
if (hasFlag(MODULE)) referenced else NoSymbol
def setModuleClass(clazz: Symbol): TermSymbol = {
assert(hasFlag(MODULE))
referenced = clazz
this
}
}
/** A class for module symbols */
class ModuleSymbol(initOwner: Symbol, initPos: PositionType, initName: Name)
extends TermSymbol(initOwner, initPos, initName) {
private var flatname = nme.EMPTY
override def owner: Symbol =
if (phase.flatClasses && !hasFlag(METHOD) &&
rawowner != NoSymbol && !rawowner.isPackageClass) rawowner.owner
else rawowner
override def name: Name =
if (phase.flatClasses && !hasFlag(METHOD) &&
rawowner != NoSymbol && !rawowner.isPackageClass) {
if (flatname == nme.EMPTY) {
assert(rawowner.isClass)
flatname = newTermName(rawowner.name.toString() + "$" + rawname)
}
flatname
} else rawname
override def cloneSymbolImpl(owner: Symbol): Symbol = {
val clone = new ModuleSymbol(owner, pos, name)
clone.referenced = referenced
clone
}
}
/** A class for type parameters viewed from inside their scopes */
class ThisSkolem(initOwner: Symbol, initPos: PositionType, initName: Name, clazz: Symbol) extends TermSymbol(initOwner, initPos, initName) {
override def deSkolemize = clazz
override def cloneSymbolImpl(owner: Symbol): Symbol = {
throw new Error("should not clone a this skolem")
}
override def nameString: String = clazz.name.toString() + ".this"
}
/** A class of type symbols. Alias and abstract types are direct instances
* of this class. Classes are instances of a subclass.
*/
class TypeSymbol(initOwner: Symbol, initPos: PositionType, initName: Name)
extends Symbol(initOwner, initPos, initName) {
override def isType = true
privateWithin = NoSymbol
private var tyconCache: Type = null
private var tyconRunId = NoRunId
private var tpeCache: Type = _
private var tpePeriod = NoPeriod
override def tpe: Type = {
if (tpeCache eq NoType) throw CyclicReference(this, typeConstructor)
if (tpePeriod != currentPeriod) {
if (isValid(tpePeriod)) {
tpePeriod = currentPeriod
} else {
if (isInitialized) tpePeriod = currentPeriod
tpeCache = NoType
val targs = if (phase.erasedTypes && this != ArrayClass) List()
else unsafeTypeParams map (.tpe)
tpeCache = typeRef(if (isTypeParameterOrSkolem) NoPrefix else owner.thisType, this, targs)
}
}
assert(tpeCache != null/*, "" + this + " " + phase*/)//debug
tpeCache
}
override def typeConstructor: Type = {
if (tyconCache == null || tyconRunId != currentRunId) {
tyconCache = typeRef(if (isTypeParameter) NoPrefix else owner.thisType, this, List())
tyconRunId = currentRunId
}
assert(tyconCache != null)
tyconCache
}
override def setInfo(tp: Type): this.type = {
tpePeriod = NoPeriod
tyconCache = null
tp match { //debug
case TypeRef(_, sym, _) =>
assert(sym != this, this)
case ClassInfoType(parents, _, _) =>
for(val p <- parents) assert(p.symbol != this, owner)
case _ =>
}
super.setInfo(tp)
this
}
override def reset(completer: Type): unit = {
super.reset(completer)
tpePeriod = NoPeriod
tyconRunId = NoRunId
}
def cloneSymbolImpl(owner: Symbol): Symbol =
new TypeSymbol(owner, pos, name)
if (util.Statistics.enabled) typeSymbolCount = typeSymbolCount + 1
}
/** A class for type parameters viewed from inside their scopes */
class TypeSkolem(initOwner: Symbol, initPos: PositionType, initName: Name, typeParam: Symbol) extends TypeSymbol(initOwner, initPos, initName) {
override def deSkolemize = typeParam
override def cloneSymbolImpl(owner: Symbol): Symbol = {
throw new Error("should not clone a type skolem")
}
override def nameString: String =
if (settings.debug.value) (super.nameString + "&")
else super.nameString
}
/** A class for class symbols */
class ClassSymbol(initOwner: Symbol, initPos: PositionType, initName: Name) extends TypeSymbol(initOwner, initPos, initName) {
/** The classfile from which this class was loaded. Maybe null. */
var classFile: AbstractFile = null;
private var source: AbstractFile = null
override def sourceFile = if (owner.isPackageClass) source else super.sourceFile
override def sourceFile_=(f: AbstractFile): unit = {
//System.err.println("set source file of " + this + ": " + f);
source = f
}
override def isFromClassFile = {
if (classFile != null) true
else if (owner.isPackageClass) false
else super.isFromClassFile
}
private var thissym: Symbol = this
override def isClass: boolean = true
override def reset(completer: Type): unit = {
super.reset(completer)
thissym = this
}
private var flatname = nme.EMPTY
override def owner: Symbol =
if (phase.flatClasses && rawowner != NoSymbol && !rawowner.isPackageClass) rawowner.owner
else rawowner
override def name: Name =
if (phase.flatClasses && rawowner != NoSymbol && !rawowner.isPackageClass) {
if (flatname == nme.EMPTY) {
assert(rawowner.isClass)
flatname = newTypeName(rawowner.name.toString() + "$" + rawname)
}
flatname
} else rawname
private var thisTypeCache: Type = _
private var thisTypePeriod = NoPeriod
/** the type this.type in this class */
override def thisType: Type = {
val period = thisTypePeriod
if (period != currentPeriod) {
thisTypePeriod = currentPeriod
if (!isValid(period)) thisTypeCache = ThisType(this)
}
thisTypeCache
}
/** A symbol carrying the self type of the class as its type */
override def thisSym: Symbol = thissym
override def typeOfThis: Type =
if (getFlag(MODULE | IMPLCLASS) == MODULE && owner != NoSymbol)
singleType(owner.thisType, sourceModule)
else thissym.tpe
/** Sets the self type of the class */
override def typeOfThis_=(tp: Type): unit =
thissym = newThisSym(pos).setInfo(tp)
override def cloneSymbolImpl(owner: Symbol): Symbol = {
assert(!isModuleClass)
val clone = new ClassSymbol(owner, pos, name)
if (thisSym != this) clone.typeOfThis = typeOfThis
clone
}
override def sourceModule =
if (isModuleClass) linkedModuleOfClass else NoSymbol
if (util.Statistics.enabled) classSymbolCount = classSymbolCount + 1
}
/** A class for module class symbols
* Note: Not all module classes are of this type; when unpickled, we get
* plain class symbols!
*/
class ModuleClassSymbol(owner: Symbol, pos: PositionType, name: Name) extends ClassSymbol(owner, pos, name) {
private var module: Symbol = null
def this(module: TermSymbol) = {
this(module.owner, module.pos, module.name.toTypeName)
setFlag(module.getFlag(ModuleToClassFlags) | MODULE | FINAL)
setSourceModule(module)
}
override def sourceModule = module
def setSourceModule(module: Symbol): unit = this.module = module
}
/** An object repreesenting a missing symbol */
object NoSymbol extends Symbol(null, NoPos, nme.NOSYMBOL) {
setInfo(NoType)
privateWithin = this
override def setInfo(info: Type): this.type = {
assert(info eq NoType); super.setInfo(info)
}
override def enclClass: Symbol = this
override def toplevelClass: Symbol = this
override def enclMethod: Symbol = this
override def owner: Symbol = throw new Error("no-symbol does not have owner")
override def sourceFile: AbstractFile = null
override def ownerChain: List[Symbol] = List()
override def alternatives: List[Symbol] = List()
override def reset(completer: Type): unit = {}
def cloneSymbolImpl(owner: Symbol): Symbol = throw new Error()
}
def cloneSymbols(syms: List[Symbol]): List[Symbol] = {
val syms1 = syms map (.cloneSymbol)
for (val sym1 <- syms1) sym1.setInfo(sym1.info.substSym(syms, syms1))
syms1
}
def cloneSymbols(syms: List[Symbol], owner: Symbol): List[Symbol] = {
val syms1 = syms map (.cloneSymbol(owner))
for (val sym1 <- syms1) sym1.setInfo(sym1.info.substSym(syms, syms1))
syms1
}
/** An exception for cyclic references of symbol definitions */
case class CyclicReference(sym: Symbol, info: Type)
extends TypeError("illegal cyclic reference involving " + sym)
/** A class for type histories */
private case class TypeHistory(start: Phase#Id, info: Type, prev: TypeHistory) {
assert(prev == null || start > prev.start, this)
assert(start != 0)
override def toString() =
"TypeHistory(" + phaseWithId(start) + "," + info + "," + prev + ")"
}
}