TyperRun

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def advancePhase(): Unit

take note that phase is completed (for progress reporting)

def advanceUnit(): Unit

take note that a phase on a unit is completed (for progress reporting)

val allConditionalWarnings: collection.immutable.List[Global.ConditionalWarning]

final def asInstanceOf[T0]: T0

def canRedefine(sym: Global.Symbol): Boolean

canRedefine is used to detect double declarations of classes and objects in multiple source files.

def cancel(): Unit

val cleanupPhase: Phase

def clone(): AnyRef

val closelimPhase: Phase

def compile(filenames: List[String]): Unit

Compile list of files given by their names

def compileFiles(files: List[AbstractFile]): Unit

Compile list of abstract files.

def compileLate(unit: Global.CompilationUnit): Unit

Compile abstract file until globalPhase, but at least to phase "namer".

def compileLate(file: AbstractFile): Unit

Compile abstract file until globalPhase, but at least to phase "namer".

def compileSources(_sources: List[SourceFile]): Unit

Compile list of source files

def compileUnits(units: List[Global.CompilationUnit], fromPhase: Phase): Unit

val compiledFiles: HashSet[String]

def compiles(sym: Global.Symbol): Boolean

does this run compile given class, module, or case factory?

var currentUnit: Global.CompilationUnit

The currently compiled unit; set from GlobalPhase

val dcePhase: Phase

def deprecationWarnings: List[(Global.Position, String)]

val deprecationWarnings0: Global.ConditionalWarning

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

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

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

def ensuring(cond: Boolean): TyperRun

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val erasurePhase: Phase

val explicitouterPhase: Phase

val featureWarnings: Global.ConditionalWarning

def finalize(): Unit

val flattenPhase: Phase

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

val icodePhase: Phase

def informUnitStarting(phase: Phase, unit: Global.CompilationUnit): Unit

For subclasses to override.

val inlineExceptionHandlersPhase: Phase

val inlineclassesPhase: Phase

val inlinerPhase: Phase

val inlinerWarnings: Global.ConditionalWarning

var isDefined: Boolean

Have been running into too many init order issues with Run during erroneous conditions.

final def isInstanceOf[T0]: Boolean

val jvmPhase: Phase

val lambdaliftPhase: Phase

val mixinPhase: Phase

val namerPhase: Phase

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val parserPhase: Phase

All phases as of 3/2012 here for handiness; the ones in active use uncommented.

def phaseNamed(name: String): Phase

val picklerPhase: Phase

val posterasurePhase: Phase

def progress(current: Int, total: Int): Unit

Progress tracking.

val refchecksPhase: Phase

def registerPickle(sym: Global.Symbol): Unit

def reportCompileErrors(): Unit

var reportedFeature: Set[Global.Symbol]

def runCheckers(): Unit

def runIsAt(ph: Phase): Boolean

def runIsAtOptimiz: Boolean

def runIsPast(ph: Phase): Boolean

var seenMacroExpansionsFallingBack: Boolean

Has any macro expansion used a fallback during this run?

def size: Int

def skipPhase(name: String): Boolean

val specializePhase: Phase

def stopPhase(name: String): Boolean

val symData: HashMap[Global.Symbol, PickleBuffer]

A map from compiled top-level symbols to their picklers

val symSource: HashMap[Global.Symbol, AbstractFile]

A map from compiled top-level symbols to their source files

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

def toString(): String

object trackerFactory extends SymbolTrackers

def typeCheck(unit: Global.CompilationUnit): Unit

val typerPhase: Phase

def uncheckedWarnings: List[(Global.Position, String)]

val uncheckedWarnings0: Global.ConditionalWarning

val uncurryPhase: Phase

def units: Iterator[Global.CompilationUnit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

val self: Any

val self: Any

def resetProjectClasses(root: Global.Symbol): Unit

Reset all classes contained in current project, as determined by the clearOnNextRun hook

def x: TyperRun

def x: TyperRun