Run

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Run, 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: List[ConditionalWarning]

final def asInstanceOf[T0]: T0

def canRedefine(sym: Symbol): Boolean

Is this run allowed to redefine the given symbol? Usually this is true if the run does not already compile sym, but for interactive mode we have a more liberal interpretation.

def cancel(): Unit

val cleanupPhase: Phase

def clone(): AnyRef

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: 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 compileSourceFor(qual: Tree, name: Name): Boolean

Attempt to locate a source file providing the given name as a top-level definition with the given prefix, and add it to the run via compileLate if found.

def compileSourceFor(context: Context, name: Name): Boolean

Attempt to locate a source file providing the given name as a top-level definition in the given context, and add it to the run via compileLate if found.

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

Compile list of source files

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

Compile list of units, starting with phase fromPhase

val compiledFiles: HashSet[String]

def compiles(sym: Symbol): Boolean

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

var currentUnit: CompilationUnit

The currently compiled unit; set from GlobalPhase

def deprecationWarnings: List[(Position, String)]

val deprecationWarnings0: ConditionalWarning

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

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

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

def ensuring(cond: Boolean): Run

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val erasurePhase: Phase

val explicitouterPhase: Phase

val featureWarnings: 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: CompilationUnit): Unit

For subclasses to override.

val inlineclassesPhase: Phase

val inlinerWarnings: 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

var macroExpansionFailed: Boolean

A flag whether macro expansions failed

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

lazy val profiler: Profiling

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

Progress tracking.

val refchecksPhase: Phase

def registerPickle(sym: Symbol): Unit

def reportCompileErrors(): Unit

var reportedFeature: Set[Symbol]

def resetProjectClasses(root: Symbol): Unit

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

def runCheckers(): Unit

def runIsAt(ph: Phase): Boolean

def runIsPast(ph: Phase): Boolean

val self: Any

val self: Any

def size: Int

def skipPhase(name: String): Boolean

val specializePhase: Phase

def stopPhase(name: String): Boolean

val symData: HashMap[Symbol, PickleBuffer]

A map from compiled top-level symbols to their picklers

val symSource: HashMap[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

val typerPhase: Phase

def uncheckedWarnings: List[(Position, String)]

val uncheckedWarnings0: ConditionalWarning

val uncurryPhase: Phase

def units: Iterator[CompilationUnit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def x: Run

def x: Run