Context

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Analyzer.Context, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ambiguousErrors: Boolean

final def asInstanceOf[T0]: T0

var buffer: Set[Analyzer.AbsTypeError]

def bufferErrors: Boolean

var checking: Boolean

def clone(): AnyRef

def condBufferFlush(removeP: (Analyzer.AbsTypeError) ⇒ Boolean): Unit

var depth: Int

var diagnostic: List[String]

var enclClass: Analyzer.Context

def enclClassOrMethod: Analyzer.Context

var enclMethod: Analyzer.Context

def enclosingContextChain: List[Analyzer.Context]

def enclosingSubClassContext(clazz: Global.Symbol): Analyzer.Context

Return the closest enclosing context that defines a subclass of clazz or a companion object thereof, or NoContext if no such context exists.

var enrichmentEnabled: Boolean

def ensuring(cond: (Analyzer.Context) ⇒ Boolean, msg: ⇒ Any): Analyzer.Context

def ensuring(cond: (Analyzer.Context) ⇒ Boolean): Analyzer.Context

def ensuring(cond: Boolean, msg: ⇒ Any): Analyzer.Context

def ensuring(cond: Boolean): Analyzer.Context

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errBuffer: Set[Analyzer.AbsTypeError]

def error(pos: Global.Position, msg: String): Unit

def error(pos: Global.Position, err: Throwable): Unit

def extractUndetparams(): List[Global.Symbol]

def finalize(): Unit

def flushAndReturnBuffer(): Set[Analyzer.AbsTypeError]

def flushBuffer(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hasErrors: Boolean

def hashCode(): Int

var implicitsEnabled: Boolean

def implicitss: List[List[Analyzer.ImplicitInfo]]

def importedAccessibleSymbol(imp: Analyzer.ImportInfo, name: Global.Name): Global.Symbol

The symbol with name name imported via the import in imp, if any such symbol is accessible from this context.

var imports: List[Analyzer.ImportInfo]

var inConstructorSuffix: Boolean

var inSelfSuperCall: Boolean

def isAccessible(sym: Global.Symbol, pre: Global.Type, superAccess: Boolean = false): Boolean

Is sym accessible as a member of pre in current context?

def isInPackageObject(sym: Global.Symbol, pkg: Global.Symbol): Boolean

Is sym defined in package object of package pkg? Since sym may be defined in some parent of the package object, we cannot inspect its owner only; we have to go through the info of the package object.

final def isInstanceOf[T0]: Boolean

def isLocal(): Boolean

def isNameInScope(name: Global.Name): Boolean

def isSubClassOrCompanion(sub: Global.Symbol, base: Global.Symbol): Boolean

Is sub a subclass of base or a companion object of such a subclass?

def issue(err: Analyzer.AbsTypeError): Unit

def issueAmbiguousError(err: Analyzer.AbsTypeError): Unit

def issueAmbiguousError(pre: Global.Type, sym1: Global.Symbol, sym2: Global.Symbol, err: Analyzer.AbsTypeError): Unit

def lookup(name: Global.Name, expectedOwner: Global.Symbol): Global.Symbol

Find a symbol in this context or one of its outers.

def lookupSymbol(name: Global.Name, qualifies: (Global.Symbol) ⇒ Boolean): Global.NameLookup

Find the symbol of a simple name starting from this context.

var macrosEnabled: Boolean

def make(tree: Global.Tree): Analyzer.Context

def make(tree: Global.Tree, owner: Global.Symbol): Analyzer.Context

def make(tree: Global.Tree, owner: Global.Symbol, scope: Global.Scope): Analyzer.Context

def make(unit: Global.CompilationUnit, tree: Global.Tree, owner: Global.Symbol, scope: Global.Scope, imports: List[Analyzer.ImportInfo]): Analyzer.Context

def makeConstructorContext: Analyzer.Context

def makeImplicit(reportAmbiguousErrors: Boolean): Analyzer.Context

def makeNewImport(imp: Global.Import): Analyzer.Context

def makeNewImport(sym: Global.Symbol): Analyzer.Context

def makeNewScope(tree: Global.Tree, owner: Global.Symbol): Analyzer.Context

def makeSilent(reportAmbiguousErrors: Boolean, newtree: Global.Tree = tree): Analyzer.Context

var namedApplyBlockInfo: Option[(Global.Tree, Analyzer.NamedApplyInfo)]

final def ne(arg0: AnyRef): Boolean

def nextEnclosing(p: (Analyzer.Context) ⇒ Boolean): Analyzer.Context

final def notify(): Unit

final def notifyAll(): Unit

var openImplicits: List[(Global.Type, Global.Tree)]

var outer: Analyzer.Context

var owner: Global.Symbol

var prefix: Global.Type

def pushTypeBounds(sym: Global.Symbol): Unit

def reportErrors: Boolean

def resetCache(): Unit

def restoreState(state0: Int): Unit

def restoreTypeBounds(tp: Global.Type): Global.Type

var returnsSeen: Boolean

var retyping: Boolean

var savedTypeBounds: List[(Global.Symbol, Global.Type)]

final def savingEnclClass[A](c: Analyzer.Context)(a: ⇒ A): A

var scope: Global.Scope

def setAmbiguousErrors(report: Boolean): Unit

def setBufferErrors(): Unit

def setReportErrors(): Unit

def setThrowErrors(): Unit

def state: Int

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

def throwErrors: Boolean

def toString(): String

var tree: Global.Tree

def typingIndent: String

var typingIndentLevel: Int

def undetparams: List[Global.Symbol]

def undetparamsString: String

def undetparams_=(ps: List[Global.Symbol]): Unit

var unit: Global.CompilationUnit

def updateBuffer(errors: Set[Analyzer.AbsTypeError]): Set[Analyzer.AbsTypeError]

var variance: Int

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warning(pos: Global.Position, msg: String, force: Boolean): Unit

def warning(pos: Global.Position, msg: String): Unit

def withImplicitsDisabled[T](op: ⇒ T): T

def withImplicitsDisabledAllowEnrichment[T](op: ⇒ T): T

def withImplicitsEnabled[T](op: ⇒ T): T

def withMacrosDisabled[T](op: ⇒ T): T

def withMacrosEnabled[T](op: ⇒ T): T

def →[B](y: B): (Analyzer.Context, B)

val self: Any

val self: Any

def x: Analyzer.Context

def x: Analyzer.Context