SourcefileLoader

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

def <:<(that: Type): Boolean

def =:=(that: Type): Boolean

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def annotations: List[AnnotationInfo]

final def asInstanceOf[T0]: T0

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

def atOwner(owner: Symbol): Type

def baseClasses: List[Symbol]

def baseType(clazz: Symbol): Type

def baseTypeIndex(sym: Symbol): Int

def baseTypeSeq: BaseTypeSeq

def baseTypeSeqDepth: Int

def betaReduce: Type

def boundSyms: Set[Symbol]

def bounds: TypeBounds

def clone(): AnyRef

def cloneInfo(owner: Symbol): Type

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

def complete(root: Symbol): Unit

def computeMemberType(sym: Symbol): Type

def contains(sym: Symbol): Boolean

def containsTp(tp: Type): Boolean

def dealias: Type

def decl(name: Name): Symbol

def declaration(name: Name): Symbol

def declarations: Scope

def decls: Scope

def deconst: Type

def deferredMembers: List[Symbol]

def description: String

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

def directObjectString: String

def doComplete(root: Symbol): Unit

Load source or class file for root, return

def dummyArgs: List[Type]

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

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

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

def ensuring(cond: Boolean): SourcefileLoader

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def erasure: Type

def etaExpand: Type

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

def filter(p: (Type) ⇒ Boolean): List[Type]

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

def finalResultType: Type

def finalize(): Unit

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

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

def firstParent: Type

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

def formatted(fmtstr: String): String

def fromSource: Boolean

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

final def getClass(): Class[_]

def hasAnnotation(cls: Symbol): Boolean

def hashCode(): Int

def implicitMembers: List[Symbol]

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

def isComplete: Boolean

def isConcrete: Boolean

def isDependent: Boolean

def isErroneous: Boolean

def isError: Boolean

def isFinalType: Boolean

def isGround: Boolean

def isHigherKinded: Boolean

def isImmediatelyDependent: Boolean

final def isInstanceOf[T0]: Boolean

def isNotNull: Boolean

def isSpliceable: Boolean

def isStable: Boolean

def isStructuralRefinement: Boolean

def isTrivial: Boolean

def isVolatile: Boolean

def isWildcard: Boolean

def kind: String

def load(root: Symbol): Unit

def looselyMatches(that: Type): Boolean

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

def matches(that: Type): Boolean

def matchesPattern(that: Type): Boolean

def member(name: Name): Symbol

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

def memberInfo(sym: Symbol): Type

def memberType(sym: Symbol): Type

def members: List[Symbol]

def membersBasedOnFlags(excludedFlags: Long, requiredFlags: Long): List[Symbol]

def membersWithFlags(requiredFlags: Long): List[Symbol]

def narrow: Type

final def ne(arg0: AnyRef): Boolean

def nonLocalMember(name: Name): Symbol

def nonPrivateDecl(name: Name): Symbol

def nonPrivateDeclaration(name: Name): Symbol

def nonPrivateDecls: List[Symbol]

def nonPrivateMember(name: Name): Symbol

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

def nonPrivateMembers: List[Symbol]

def nonPrivateMembersAdmitting(admit: Long): List[Symbol]

def nonPrivateMembersWithFlags(requiredFlags: Long): List[Symbol]

def normalize: Type

def notNull: Type

final def notify(): Unit

final def notifyAll(): Unit

def objectPrefix: String

def packagePrefix: String

def paramSectionCount: Int

def paramTypes: List[Type]

def params: List[Symbol]

def paramss: List[List[Symbol]]

def parents: List[Type]

def prefix: Type

def prefixChain: List[Type]

def prefixString: String

def remove(clazz: Symbol): Type

def removeAnnotation(cls: Symbol): Type

def resultApprox: Type

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

def resultType: Type

def safeToString: String

def selfsym: Symbol

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

def skolemizeExistential: Type

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

def skolemsExceptMethodTypeParams: List[Symbol]

def sourcefile: Some[AbstractFile]

def specializes(sym: Symbol): Boolean

val srcfile: AbstractFile

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

def stripAnnotations: Type

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

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

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

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

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

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

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

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

def termSymbol: Symbol

def termSymbolDirect: Symbol

def throwsAnnotations(): List[Symbol]

def toLongString: String

def toString(): String

def trimPrefix(str: String): String

def typeArgs: List[Type]

def typeArguments: List[Type]

def typeConstructor: Type

def typeOfThis: Type

def typeParams: List[Symbol]

def typeSymbol: Symbol

def typeSymbolDirect: Symbol

def underlying: Type

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def widen: Type

final def withAnnotation(annot: AnnotationInfo): Type

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

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

def withSelfsym(sym: Symbol): Type

def withoutAnnotations: Type

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

val self: Any

val self: Any

def x: SourcefileLoader

def x: SourcefileLoader