Context

abstract val callsiteTyper: Typer

abstract val expandee: Tree

abstract val mirror: Global

abstract val prefix: Expr[PrefixType]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object CompilationUnit extends CompilationUnitExtractor

val Expr: Context.this.mirror.Expr.type

object Run extends RunExtractor

object TypeError extends TypeErrorExtractor with Serializable

val TypeTag: Context.this.mirror.TypeTag.type

Creator/extractor objects for Expr and TypeTag values

def abort(pos: Position, msg: String): Nothing

final def asInstanceOf[T0]: T0

val cache: Map[Any, Any]

def captureVariable(vble: Symbol): Unit

def capturedVariableType(vble: Symbol): Type

def clone(): AnyRef

def compilerSettings: List[String]

def concreteTag[T](implicit cttag: ConcreteTypeTag[T]): ConcreteTypeTag[T]

def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]): ConcreteTypeTag[T]

val currentMacro: Symbol

val currentRun: Run

def echo(pos: Position, msg: String): Unit

val enclosingApplication: Tree

val enclosingClass: Tree

val enclosingImplicits: List[(Type, Tree)]

val enclosingMacros: List[Context]

val enclosingMethod: Tree

val enclosingPosition: Position

val enclosingUnit: CompilationUnit

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

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

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

def ensuring(cond: Boolean): Context

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

val forInteractive: Boolean

val forJVM: Boolean

val forMSIL: Boolean

val forScaladoc: Boolean

def formatted(fmtstr: String): String

def fresh(name: Name): Name

def fresh(name: String): String

def fresh(): String

lazy val freshNameCreator: FreshNameCreator

def frontEnd: FrontEnd

final def getClass(): Class[_]

val globalCache: Map[Any, Any]

def globalSettings: Settings

def hasErrors: Boolean

def hasWarnings: Boolean

def hashCode(): Int

def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree

def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, reportAmbiguous: Boolean = true, pos: Position = enclosingPosition): Tree

def info(pos: Position, msg: String, force: Boolean): Unit

def interactive(): Unit

final def isInstanceOf[T0]: Boolean

def isLocatable(sym: Symbol): Boolean

def isStatic(sym: Symbol): Boolean

def literal(x: Char): Expr[Char]

def literal(x: String): Expr[String]

def literal(x: Double): Expr[Double]

def literal(x: Float): Expr[Float]

def literal(x: Long): Expr[Long]

def literal(x: Int): Expr[Int]

def literal(x: Short): Expr[Short]

def literal(x: Byte): Expr[Byte]

def literal(x: Boolean): Expr[Boolean]

def literalFalse: Expr[Boolean]

def literalNull: Expr[Null]

def literalTrue: Expr[Boolean]

def literalUnit: Expr[Unit]

val macroApplication: Tree

val macroDebugLite: Boolean

val macroDebugVerbose: Boolean

final def macroLogLite(msg: ⇒ Any): Unit

final def macroLogVerbose(msg: ⇒ Any): Unit

val macroTraceLite: SimpleTracer

val macroTraceVerbose: SimpleTracer

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openImplicits: List[(Type, Tree)]

def openMacros: List[Context]

def referenceCapturedVariable(vble: Symbol): Tree

lazy val reflectMirrorPrefix: Tree

def reify[T](expr: T): Expr[T]

def reifyErasure(tpe: Type, concrete: Boolean = true): Tree

def reifyTree(prefix: Tree, tree: Tree): Tree

def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): Tree

def resetAllAttrs[T <: Tree](tree: T): T

def resetLocalAttrs[T <: Tree](tree: T): T

val self: Any

val self: Any

def setCompilerSettings(options: List[String]): Context.this.type

def setCompilerSettings(options: String): Context.this.type

def setFrontEnd(frontEnd: FrontEnd): Context.this.type

def settings: List[String]

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

def tag[T](implicit ttag: TypeTag[T]): TypeTag[T]

def toString(): String

def typeCheck(tree: Tree, pt: Type = mirror.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree

def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

def unreifyTree(tree: Tree): Tree

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def withCompilerSettings[T](options: List[String])(op: ⇒ T): T

def withCompilerSettings[T](options: String)(op: ⇒ T): T

def withFrontEnd[T](frontEnd: FrontEnd)(op: ⇒ T): T

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

def x: Context

def x: Context