IMain

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addImports(ids: String*): Result

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

Parse the ScalaSig to find type aliases

def allDefHandlers: List[MemberDefHandler]

def allDefSymbols: List[Symbol]

def allDefinedNames: List[Name]

def allHandlers: List[MemberHandler]

def allImplicits: List[Name { ... /* 5 definitions in type refinement */ }]

def allImportedNames: List[Name]

def allSeenTypes: List[String]

def apply[T](implicit arg0: ClassTag[T]): Symbol

def apply(name: String): Symbol

Translate a repl-defined identifier into a Symbol.

final def asInstanceOf[T0]: T0

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

Temporarily be quiet

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

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

def bind(p: NamedParam): Result

def bind(name: String, boundType: String, value: Any, modifiers: List[String] = Nil): Result

Bind a specified name to a specified value.

def bindSyntheticValue(x: Any): Result

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

def bindValue(x: Any): Result

def classLoader: AbstractFileClassLoader

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

def classSymbols: List[ClassSymbol]

def cleanMemberDecl(owner: Symbol, member: Name): Type

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 compileSourcesKeepingRun(sources: SourceFile*): (Boolean, Run)

def compileString(code: String): Boolean

Compile a string.

lazy val compiler: IMain.this.global.type

def compilerClasspath: Seq[URL]

def createLineManager(classLoader: ClassLoader): Manager

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

object deconstruct extends StructuredTypeStrings

def definedSymbolList: List[Symbol]

def definedSymbols: Set[Symbol]

def definedTerms: List[TermName]

def definedTypes: List[TypeName]

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

def directBind[T](name: String, value: T)(implicit arg0: ClassTag[T]): Result

def directBind(p: NamedParam): Result

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

final def ensureClassLoader(): Unit

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

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

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

def ensuring(cond: Boolean): IMain

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

object exprTyper extends ExprTyper

def finalize(): Unit

def flatName(id: String): String

def formatted(fmtstr: 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(): Class[_]

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): Symbol

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 interpretSynthetic(line: String): Result

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

def isNoImports: Boolean

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]

def lastRequest: Request

def lastWarnings: List[(Position, String)]

def lineManager: Manager

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

def methodSymbols: List[MethodSymbol]

def mostRecentLine: String

def mostRecentVar: String

Returns the name of the most recent interpreter result.

def namedDefinedTerms: List[TermName]

object naming extends Naming

final def ne(arg0: AnyRef): Boolean

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

Instantiate a compiler.

def noLineManager: Boolean

Create a line manager.

def normalizeNonPublic(tp: Type): Type

final def notify(): Unit

final def notifyAll(): Unit

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

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

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 prettyPrint(code: String): Unit

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

object replTokens extends ReplTokens

lazy val repllog: Logger

lazy val reporter: ReplReporter

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

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

def requestForReqId(id: Int): Option[Request]

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

def rerunForWarnings: Result

def rerunWith(names: String*): Result

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): Type

def savingSettings[T](fn: (Settings) ⇒ Unit)(body: ⇒ T): T

val self: Any

val self: Any

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

def settings: Settings

def showCodeIfDebugging(code: String): Unit

def symbolDefString(sym: Symbol): String

def symbolOfLine(code: String): Symbol

def symbolOfTerm(id: String): Symbol

def symbolOfType(id: String): Symbol

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

def terms[T](implicit arg0: ClassTag[T]): Symbol

def terms(name: String): Symbol

def toString(): String

def treesForRequestId(id: Int): List[Tree]

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

def typeOfTerm(id: String): Type

def types[T](implicit arg0: ClassTag[T]): Symbol

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

Leading with the eagerly evaluated.

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

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

def x: IMain

def x: IMain