Run

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

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[ConditionalWarning]

final def asInstanceOf[T0]: T0

def canRedefine(sym: Global.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

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, unless there is a problem already, such as a plugin was passed a bad option.

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

val delambdafyPhase: Phase

def deprecationWarnings: List[(Global.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: Global.CompilationUnit): Unit

For subclasses to override.

val inlineExceptionHandlersPhase: Phase

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

val runDefinitions: reflect.internal.Definitions.definitions.RunDefinitions

Caching member symbols that are def-s in Defintions because they might change from Run to Run.

def runIsAt(ph: Phase): Boolean

def runIsAtOptimiz: Boolean

var seenMacroExpansionsFallingBack: Boolean

Has any macro expansion used a fallback during this run?

def size: Int

def skipPhase(name: String): Boolean

Should we skip the given phase?

val specializePhase: Phase

def stopPhase(name: String): Boolean

Should we stop right before entering the given phase?

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

val typerPhase: Phase

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

val uncheckedWarnings0: 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): (Run, B)

def resetProjectClasses(root: Global.Symbol): Unit

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