ILoopInterpreter

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addImports(ids: String*): Result

def afterTyper[T](op: ⇒ T): T

def aliasForType(path: String): Option[String]

Parse the ScalaSig to find type aliases

def allDefinedNames: List[Name]

def allImplicits: List[Name]

def allSeenTypes: List[String]

def apply(name: String): Symbol

Translate a repl-defined identifier into a Symbol.

final def asInstanceOf[T0]: T0

def atPickler[T](op: ⇒ T): T

def beQuietDuring[T](body: ⇒ T): T

Temporarily be quiet

def beSilentDuring[T](operation: ⇒ T): T

def bind[T](name: String, value: T)(implicit arg0: Manifest[T]): Result

def bind(p: NamedParam): Result

def bind(name: String, boundType: String, value: Any): Result

Bind a specified name to a specified value.

def bindValue(name: String, x: Any): Result

def bindValue(x: Any): Result

def classLoader: AbstractFileClassLoader

def classOfTerm(id: String): Option[JClass]

def clearExecutionWrapper(): Unit

def clone(): AnyRef

def close(): Unit

This instance is no longer needed, so release any resources it is using.

def compileSources(sources: SourceFile*): Boolean

Compile an nsc SourceFile.

def compileString(code: String): Boolean

Compile a string.

lazy val compilerClasspath: List[URL]

the compiler's classpath, as URL's

def createLineManager(): Manager

Create a line manager.

def debugging[T](msg: String)(res: T): T

def definedSymbols: Set[Symbol]

def definedTerms: List[TermName]

def definedTypes: List[TypeName]

def definitionForName(name: Name): Option[MemberHandler]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

def finalize(): Unit

def flatName(id: String): String

lazy val formatting: Formatting

def generatedName(simpleName: String): Option[String]

Given a simple repl-defined name, returns the real name of the class representing it, e.

   $line19.$read$$iw$$iw$$iw$$iw$$iw$$iw$$iw$$iw$Bippy

final def getClass(): java.lang.Class[_]

def getCompilerClass(name: String): Symbol

def getCompilerModule(name: String): Symbol

def getInterpreterClassLoader(): AbstractFileClassLoader

lazy val global: Global

the public, go through the future compiler

def handleTermRedefinition(name: TermName, old: Request, req: Request): Unit

def handleTypeRedefinition(name: TypeName, old: Request, req: Request): Unit

Stubs for work in progress.

def hashCode(): Int

def implicitSymbols: List[Symbol]

def implicitSymbolsBySource: List[(Symbol, List[Symbol])]

def importHandlers: List[ImportHandler]

def importedSymbols: List[Symbol]

def importedSymbolsBySource: List[(Symbol, List[Symbol])]

Tuples of (source, imported symbols) in the order they were imported.

def importedTermNamed(name: String): Option[TermSymbol]

def importedTermSymbols: List[TermSymbol]

def importedTerms: List[TermName]

def importedTypeSymbols: List[TypeSymbol]

def importedTypes: List[TypeName]

def importsCode(wanted: Set[Name]): ComputedImports

def initialize(postInitSignal: ⇒ Unit): Unit

def initializeSynchronous(): Unit

def interpret(line: String, synthetic: Boolean): Result

def interpret(line: String): Result

Interpret one line of input.

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

def isNoImports: T

def isNoPredef: Boolean

def isParseable(line: String): Boolean

lazy val isettings: ISettings

interpreter settings

def languageSymbols: List[Symbol]

def languageWildcardHandlers: List[ImportHandler]

def languageWildcardSyms: List[Symbol]

Symbols whose contents are language-defined to be imported.

def languageWildcards: List[Type]

lazy val lineManager: Manager

lazy val memberHandlers: MemberHandlers { val intp: ILoopInterpreter.this.type }

def mostRecentVar: String

Returns the name of the most recent interpreter result.

object naming extends Naming

final def ne(arg0: AnyRef): Boolean

def newCompiler(settings: Settings, reporter: Reporter): Global

Instantiate a compiler.

final def notify(): Unit

final def notifyAll(): Unit

def onlyTerms(xs: List[Name]): List[TermName]

def onlyTypes(xs: List[Name]): List[TypeName]

def optCompilerClass(name: String): Option[Symbol]

def optCompilerModule(name: String): Option[Symbol]

def optFlatName(id: String): Option[String]

val out: JPrintWriter

def parentClassLoader: ClassLoader

Parent classloader.

def parse(line: String): Option[List[Tree]]

def pathToName(name: Name): String

def pathToTerm(id: String): String

def pathToType(id: String): String

def prevRequestList: List[Request]

def quietBind(p: NamedParam): Result

def quietImport(ids: String*): Result

def quietRun[T](code: String): Result

def rebind(p: NamedParam): Result

def recordRequest(req: Request): Unit

lazy val repllog: Logger

lazy val reporter: ConsoleReporter

def requestForIdent(line: String): Option[Request]

def requestForName(name: Name): Option[Request]

def requestHistoryForName(name: Name): List[Request]

def reset(): Unit

Reset this interpreter, forgetting all user-specified requests.

def resetClassLoader(): Unit

def runtimeClassAndTypeOfTerm(id: String): Option[(JClass, Type)]

def runtimeTypeOfTerm(id: String): Option[Type]

def safeClass(name: String): Option[Symbol]

def safeModule(name: String): Option[Symbol]

def sessionImportedSymbols: List[Symbol]

def sessionWildcards: List[Type]

Types which have been wildcard imported, such as: val x = "abc" ; import x.

def setContextClassLoader(): Unit

def setExecutionWrapper(code: String): Unit

val settings: Settings

def showCodeIfDebugging(code: String): Unit

def symbolDefString(sym: Symbol): String

def symbolOfTerm(id: String): Symbol

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

def terms(name: String): Symbol

def toString(): String

def typeCleanser(sym: Symbol, memberName: Name): Type

def typeOfExpression(expr: String, silent: Boolean = true): Option[Type]

def typeOfTerm(id: String): Option[Type]

def types(name: String): Symbol

def unqualifiedIds: List[String]

Another entry point for tab-completion, ids in scope

def valueOfTerm(id: String): Option[AnyRef]

val virtualDirectory: VirtualDirectory { def show(): Unit }

directory to save .

def visibleTermNames: List[Name]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wildcardTypes: List[Type]

def withoutUnwrapping(op: ⇒ Unit): Unit

lazy val compiler: ILoopInterpreter.this.global.type