ICodeReader

abstract def classPath: ClassPath[AbstractFile]

The compiler classpath.

abstract val global: Global

abstract val loaders: Global.loaders

abstract def lookupMemberAtTyperPhaseIfPossible(sym: Global.Symbol, name: Global.Name): Global.Symbol

If typer phase is defined then perform member lookup of a symbol sym at typer phase.

abstract val symbolTable: global.type

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

val JVM: reflect.internal.ClassfileConstants.type

def addEnclosingTParams(clazz: Global.Symbol): Unit

Add type parameters of enclosing classes

final def asInstanceOf[T0]: T0

var busy: Global.Symbol

def classNameToSymbol(name: Global.Name): Global.Symbol

Return the class symbol of the given name.

var classTParams: Map[Global.Name, Global.Symbol]

var clazz: Global.Symbol

def clone(): AnyRef

var currentClass: Global.Name

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

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

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

def ensuring(cond: Boolean): ICodeReader

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def forceMangledName(name: Global.Name, module: Boolean): Global.Symbol

Try to force the chain of enclosing classes for the given name.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def getCode(flags: JavaAccFlags): Global.icodes.IClass

Return the icode class that should include members with the given flags.

def getScope(flags: JavaAccFlags): Global.Scope

def hashCode(): Int

var in: AbstractFileReader

object innerClasses

Return the class symbol for the given name.

var instanceCode: Global.icodes.IClass

var instanceScope: Global.Scope

def isBox(m: Global.Symbol): Boolean

Note: these methods are different from the methods of the same name found in Definitions.

final def isInstanceOf[T0]: Boolean

var isScala: Boolean

var isScalaAnnot: Boolean

var isScalaModule: Boolean

var isScalaRaw: Boolean

def isUnbox(m: Global.Symbol): Boolean

var maxLocals: Int

var maxStack: Int

var method: Global.icodes.IMethod

def moduleClass: Global.Symbol

final def ne(arg0: AnyRef): Boolean

def newConstantPool: ICodeConstantPool

final def notify(): Unit

final def notifyAll(): Unit

def parse(file: AbstractFile, root: Global.Symbol): Unit

def parseAttribute(): Unit

def parseAttributes(sym: Global.Symbol, symtype: Global.Type): Unit

def parseByteCode(): Unit

Parse java bytecode into ICode

def parseClass(): Unit

def parseField(): Unit

def parseInnerClasses(): Unit

Parse inner classes.

def parseMethod(): Unit

var pc: Int

var pool: ThisConstantPool

def readClass(cls: Global.Symbol): (Global.icodes.IClass, Global.icodes.IClass)

Read back bytecode for the given class symbol.

def skipAttributes(): Unit

def skipMembers(): Unit

def skipSuperclasses(): Unit

def srcfile: Option[AbstractFile]

var srcfile0: Option[AbstractFile]

var staticCode: Global.icodes.IClass

var staticModule: Global.Symbol

var staticScope: Global.Scope

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

def toString(): String

def toUnsignedByte(b: Byte): Int

final def u1(): Int

final def u2(): Int

final def u4(): Int

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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