ClassInfo

abstract def bytecodeName: String

The name as found in the bytecode.

abstract def file: AbstractFile

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

var _innerClasses: Seq[String]

var _isLocalClass: Boolean

var _isTopLevel: Boolean

def accessModifier: String

lazy val allInterfaces: Set[ClassInfo]

All interfaces inherited directly or indirectly by this class

lazy val allTraits: Set[ClassInfo]

All traits inherited directly or indirectly by this class

final def asInstanceOf[T0]: T0

def canEqual(other: Any): Boolean

def classString: String

def clone(): AnyRef

lazy val concreteMethods: List[MemberInfo]

The concrete methods of this trait

def constructors: List[MemberInfo]

The constructors of this class pre: methodsAreRelevant

def declarationPrefix: String

final def decodedName: String

The name as found in the original Scala source.

lazy val deferredMethods: List[MemberInfo]

The deferred methods of this trait

def deferredMethodsInBytecode: List[MemberInfo]

All deferred methods of this type as seen in the bytecode.

def description: String

lazy val directTraits: List[ClassInfo]

The inherited traits in the linearization of this class or trait, except any traits inherited by its superclass.

lazy val emulatedConcreteMethods: List[MemberInfo]

The subset of concrete methods of this trait that are abstract at the JVM level.

def ensureLoaded(): Unit

final def eq(arg0: AnyRef): Boolean

final def equals(other: Any): Boolean

def fields: Members

def fields_=(x: Members): Unit

def finalize(): Unit

def flags: Int

def flags_=(x: Int): Unit

def formattedFullName: String

lazy val fullName: String

final def getClass(): Class[_]

def hasStaticImpl(m: MemberInfo): Boolean

Does this implementation class have a static implementation of given method m'?

final def hashCode(): Int

def implClass: ClassInfo

The implementation class of this trait, or NoClass if it is not a trait.

def implClass_=(ic: ClassInfo): Unit

def innerClasses: Seq[String]

def interfaces: List[ClassInfo]

def interfaces_=(x: List[ClassInfo]): Unit

def isBridge: Boolean

def isClass: Boolean

is this a class, an object or a trait's implementation class

lazy val isClassInheritsTrait: Boolean

Is this class a non-trait that inherits !from a trait

def isConcrete: Boolean

def isDeferred: Boolean

def isFinal: Boolean

lazy val isImplClass: Boolean

Is this class an implementation class?

final def isInstanceOf[T0]: Boolean

def isInterface: Boolean

Is this class a trait without concrete methods or a java interface?

def isLessVisibleThan(that: WithAccessModifier): Boolean

def isLocalClass: Boolean

def isModule: Boolean

def isPrivate: Boolean

def isProtected: Boolean

def isPublic: Boolean

def isScala: Boolean

def isScalaUnsafe: Boolean

def isScala_=(x: Boolean): Unit

def isSynthetic: Boolean

def isTopLevel: Boolean

def isTrait: Boolean

Is this class a trait with some concrete methods or fields?

var loaded: Boolean

def lookupClassFields(name: String): Iterator[MemberInfo]

def lookupClassMethods(name: String): Iterator[MemberInfo]

def lookupConcreteTraitMethods(name: String): Iterator[MemberInfo]

def lookupMethods(name: String): Iterator[MemberInfo]

def methods: Members

def methodsAreRelevant: Boolean

Should methods be parsed from classfile?

def methods_=(x: Members): Unit

final def ne(arg0: AnyRef): Boolean

def nonBridge: Boolean

def nonFinal: Boolean

final def notify(): Unit

final def notifyAll(): Unit

val owner: PackageInfo

def shortDescription: String

def sourceFileName: String

def sourceFileName_=(fileName: String): Unit

def staticImpl(m: MemberInfo): Option[MemberInfo]

Optionally, the static implementation method corresponding to trait member m'

def superClass: ClassInfo

def superClass_=(x: ClassInfo): Unit

lazy val superClasses: Set[ClassInfo]

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

def toString(): String

lazy val traitSetters: List[MemberInfo]

The setter methods defined of this trait that correspond to a concrete field.

lazy val unimplementedMethods: List[MemberInfo]

The methods that should be implemented by this class but aren't

lazy val unimplementedSetters: List[MemberInfo]

The fields that should be implemented by this class but aren't

final def wait(): Unit

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

final def wait(arg0: Long): Unit