SymbolLoader

abstract def description: String

Description of the resource (ClassPath, AbstractFile) being processed by this loader

abstract def doComplete(root: (symbolTable)#Symbol): Unit

Load source or class file for root, return

final def !=(arg0: Any): Boolean

Test two objects for inequality.

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.

def +(other: String): String

def ->[B](y: B): (SymbolLoader, B)

def <:<(that: (symbolTable)#Type): Boolean

def =:=(that: (symbolTable)#Type): Boolean

final def ==(arg0: Any): Boolean

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

def addThrowsAnnotation(throwableSym: (symbolTable)#Symbol): (symbolTable)#Type

def annotations: List[(symbolTable)#AnnotationInfo]

final def asInstanceOf[T0]: T0

Cast the receiver object to be of type T0.

def asSeenFrom(pre: (symbolTable)#Type, clazz: (symbolTable)#Symbol): (symbolTable)#Type

def atOwner(owner: (symbolTable)#Symbol): (symbolTable)#Type

def baseClasses: List[(symbolTable)#Symbol]

def baseType(clazz: (symbolTable)#Symbol): (symbolTable)#Type

def baseTypeIndex(sym: (symbolTable)#Symbol): Int

def baseTypeSeq: (symbolTable)#BaseTypeSeq

def baseTypeSeqDepth: Depth

def betaReduce: (symbolTable)#Type

def boundSyms: Set[(symbolTable)#Symbol]

def bounds: (symbolTable)#TypeBounds

def clone(): AnyRef

Create a copy of the receiver object.

def cloneInfo(owner: (symbolTable)#Symbol): (symbolTable)#Type

def collect[T](pf: PartialFunction[(symbolTable)#Type, T]): List[T]

def companion: (symbolTable)#Type

def complete(root: (symbolTable)#Symbol): Unit

def computeMemberType(sym: (symbolTable)#Symbol): (symbolTable)#Type

def contains(sym: (symbolTable)#Symbol): Boolean

def dealias: (symbolTable)#Type

def dealiasWiden: (symbolTable)#Type

def dealiasWidenChain: List[(symbolTable)#Type]

def decl(name: (symbolTable)#Name): (symbolTable)#Symbol

def declaration(name: (symbolTable)#Name): (symbolTable)#Symbol

def declarations: (symbolTable)#Scope

def decls: (symbolTable)#Scope

def deconst: (symbolTable)#Type

def deferredMembers: (symbolTable)#Scope

def directObjectString: String

def dummyArgs: List[(symbolTable)#Type]

def ensuring(cond: (SymbolLoader) ⇒ Boolean, msg: ⇒ Any): SymbolLoader

def ensuring(cond: (SymbolLoader) ⇒ Boolean): SymbolLoader

def ensuring(cond: Boolean, msg: ⇒ Any): SymbolLoader

def ensuring(cond: Boolean): SymbolLoader

final def eq(arg0: AnyRef): Boolean

Tests whether the argument (that) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

The equality method for reference types.

def erasure: (symbolTable)#Type

def etaExpand: (symbolTable)#Type

def exists(p: ((symbolTable)#Type) ⇒ Boolean): Boolean

def filterAnnotations(p: ((symbolTable)#AnnotationInfo) ⇒ Boolean): (symbolTable)#Type

final def finalResultType: (symbolTable)#Type

def finalize(): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.

def find(p: ((symbolTable)#Type) ⇒ Boolean): Option[(symbolTable)#Type]

def findMember(name: (symbolTable)#Name, excludedFlags: Long, requiredFlags: Long, stableOnly: Boolean): (symbolTable)#Symbol

def findMembers(excludedFlags: Long, requiredFlags: Long): (symbolTable)#Scope

def firstParent: (symbolTable)#Type

def forceDirectSuperclasses: Unit

def foreach(f: ((symbolTable)#Type) ⇒ Unit): Unit

def formatted(fmtstr: String): String

def fromSource: Boolean

def getAnnotation(cls: (symbolTable)#Symbol): Option[(symbolTable)#AnnotationInfo]

final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def hasAnnotation(cls: (symbolTable)#Symbol): Boolean

def hashCode(): Int

The hashCode method for reference types.

def implicitMembers: (symbolTable)#Scope

def instantiateTypeParams(formals: List[(symbolTable)#Symbol], actuals: List[(symbolTable)#Type]): (symbolTable)#Type

def isComplete: Boolean

def isDependentMethodType: Boolean

def isErroneous: Boolean

def isError: Boolean

def isFinalType: Boolean

def isGround: Boolean

def isHigherKinded: Boolean

def isImmediatelyDependent: Boolean

final def isInstanceOf[T0]: Boolean

Test whether the dynamic type of the receiver object is T0.

def isSpliceable: Boolean

final def isStable: Boolean

def isStructuralRefinement: Boolean

def isTrivial: Boolean

final def isVolatile: Boolean

def isWildcard: Boolean

def kind: String

def load(root: (symbolTable)#Symbol): Unit

def looselyMatches(that: (symbolTable)#Type): Boolean

def map(f: ((symbolTable)#Type) ⇒ (symbolTable)#Type): (symbolTable)#Type

def matches(that: (symbolTable)#Type): Boolean

def matchesPattern(that: (symbolTable)#Type): Boolean

def member(name: (symbolTable)#Name): (symbolTable)#Symbol

def memberBasedOnName(name: (symbolTable)#Name, excludedFlags: Long): (symbolTable)#Symbol

def memberInfo(sym: (symbolTable)#Symbol): (symbolTable)#Type

def memberType(sym: (symbolTable)#Symbol): (symbolTable)#Type

def members: (symbolTable)#Scope

def membersBasedOnFlags(excludedFlags: Long, requiredFlags: Long): (symbolTable)#Scope

def narrow: (symbolTable)#Type

final def ne(arg0: AnyRef): Boolean

Equivalent to !(this eq that).

def nonLocalMember(name: (symbolTable)#Name): (symbolTable)#Symbol

def nonPrivateDecl(name: (symbolTable)#Name): (symbolTable)#Symbol

def nonPrivateDecls: List[(symbolTable)#Symbol]

def nonPrivateMember(name: (symbolTable)#Name): (symbolTable)#Symbol

def nonPrivateMemberAdmitting(name: (symbolTable)#Name, admit: Long): (symbolTable)#Symbol

def nonPrivateMembers: (symbolTable)#Scope

def nonPrivateMembersAdmitting(admit: Long): (symbolTable)#Scope

def normalize: (symbolTable)#Type

final def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

def objectPrefix: String

final def orElse(alt: ⇒ (symbolTable)#Type): (symbolTable)#Type

def packagePrefix: String

def paramLists: List[List[(symbolTable)#Symbol]]

def paramSectionCount: Int

def paramTypes: List[(symbolTable)#Type]

def params: List[(symbolTable)#Symbol]

def paramss: List[List[(symbolTable)#Symbol]]

def parents: List[(symbolTable)#Type]

def prefix: (symbolTable)#Type

def prefixChain: List[(symbolTable)#Type]

def prefixString: String

def removeAnnotation(cls: (symbolTable)#Symbol): (symbolTable)#Type

def resultApprox: (symbolTable)#Type

def resultType(actuals: List[(symbolTable)#Type]): (symbolTable)#Type

def resultType: (symbolTable)#Type

def safeToString: String

def setAnnotations(annots: List[(symbolTable)#AnnotationInfo]): (symbolTable)#Type

def skolemizeExistential: (symbolTable)#Type

def skolemizeExistential(owner: (symbolTable)#Symbol, origin: AnyRef): (symbolTable)#Type

def skolemsExceptMethodTypeParams: List[(symbolTable)#Symbol]

def sourcefile: Option[AbstractFile]

def stat_<:<(that: (symbolTable)#Type): Boolean

def staticAnnotations: collection.immutable.List[(symbolTable)#AnnotationInfo]

def subst(from: List[(symbolTable)#Symbol], to: List[(symbolTable)#Type]): (symbolTable)#Type

def substSym(from: List[(symbolTable)#Symbol], to: List[(symbolTable)#Symbol]): (symbolTable)#Type

def substThis(from: (symbolTable)#Symbol, to: (symbolTable)#Symbol): (symbolTable)#Type

def substThis(from: (symbolTable)#Symbol, to: (symbolTable)#Type): (symbolTable)#Type

def substThisAndSym(from: (symbolTable)#Symbol, to: (symbolTable)#Type, symsFrom: List[(symbolTable)#Symbol], symsTo: List[(symbolTable)#Symbol]): (symbolTable)#Type

def substituteSymbols(from: List[(symbolTable)#Symbol], to: List[(symbolTable)#Symbol]): (symbolTable)#Type

def substituteTypes(from: List[(symbolTable)#Symbol], to: List[(symbolTable)#Type]): (symbolTable)#Type

final def synchronized[T0](arg0: ⇒ T0): T0

def takesTypeArgs: Boolean

def termSymbol: (symbolTable)#Symbol

def termSymbolDirect: (symbolTable)#Symbol

def throwsAnnotations(): List[(symbolTable)#Symbol]

def toLongString: String

final def toString(): String

Creates a String representation of this object.

def trimPrefix(str: String): String

def typeArgs: List[(symbolTable)#Type]

def typeArguments: List[(symbolTable)#Type]

def typeConstructor: (symbolTable)#Type

def typeOfThis: (symbolTable)#Type

def typeParams: List[(symbolTable)#Symbol]

def typeSymbol: (symbolTable)#Symbol

def typeSymbolDirect: (symbolTable)#Symbol

def underlying: (symbolTable)#Type

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def weak_<:<(that: (symbolTable)#Type): Boolean

def widen: (symbolTable)#Type

final def withAnnotation(annot: (symbolTable)#AnnotationInfo): (symbolTable)#Type

def withAnnotations(annots: List[(symbolTable)#AnnotationInfo]): (symbolTable)#Type

def withFilter(p: ((symbolTable)#Type) ⇒ Boolean): FilterMapForeach

def withoutAnnotations: (symbolTable)#Type

def →[B](y: B): (SymbolLoader, B)