scala.tools.nsc.interpreter.IMain

Instance Constructors

new IMain()
new IMain(settings: Settings)

construct an interpreter that reports to Console
new IMain(settings: Settings, out: JPrintWriter)

Type Members

case class ComputedImports(prepend: String, append: String, access: String) extends Product with Serializable

Compute imports that allow definitions from previous requests to be visible in a new request.
class ReadEvalPrint extends AnyRef

Here is where we:
class Request extends AnyRef

One line of code submitted by the user for interpretation

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
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

Definition Classes
Any
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.
Bind a specified name to a specified value. The name may later be used by expressions passed to interpret.
name
the variable name to bind
boundType
the type of the variable, as a string
value
the object value to bind to it
returns
an indication of whether the binding succeeded
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

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def close(): Unit

This instance is no longer needed, so release any resources it is using.
This instance is no longer needed, so release any resources it is using. The reporter's output gets flushed.
def compileSources(sources: SourceFile*): Boolean

Compile an nsc SourceFile.
Compile an nsc SourceFile. Returns true if there are no compilation errors, or false otherwise.
def compileString(code: String): Boolean

Compile a string.
Compile a string. Returns true if there are no compilation errors, or false otherwise.
lazy val compilerClasspath: List[URL]

the compiler's classpath, as URL's
def createLineManager(): Manager

Create a line manager.
Create a line manager. Overridable.

Attributes
protected
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

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def executionWrapper: String
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
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.
Given a simple repl-defined name, returns the real name of the class representing it, e.g. for "Bippy" it may return
```
   $line19.$read$$iw$$iw$$iw$$iw$$iw$$iw$$iw$$iw$Bippy
```
final def getClass(): java.lang.Class[_]

Definition Classes
AnyRef → Any
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

Definition Classes
AnyRef → Any
def implicitSymbols: List[Symbol]

Definition Classes
Imports
def implicitSymbolsBySource: List[(Symbol, List[Symbol])]

Definition Classes
Imports
def importHandlers: List[ImportHandler]
def importedSymbols: List[Symbol]

Definition Classes
Imports
def importedSymbolsBySource: List[(Symbol, List[Symbol])]

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

Definition Classes
Imports
def importedTermNamed(name: String): Option[TermSymbol]

Definition Classes
Imports
def importedTermSymbols: List[TermSymbol]

Definition Classes
Imports
def importedTerms: List[TermName]

Definition Classes
Imports
def importedTypeSymbols: List[TypeSymbol]

Definition Classes
Imports
def importedTypes: List[TypeName]

Definition Classes
Imports
def importsCode(wanted: Set[Name]): ComputedImports

Attributes
protected
Definition Classes
Imports
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.
Interpret one line of input. All feedback, including parse errors and evaluation results, are printed via the supplied compiler's reporter. Values defined are available for future interpreted strings.
The return value is whether the line was interpreter successfully, e.g. that there were no parse errors.
def isInitializeComplete: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNoImports: T

Definition Classes
Imports
def isNoPredef: Boolean

Definition Classes
Imports
def isParseable(line: String): Boolean
lazy val isettings: ISettings

interpreter settings
def languageSymbols: List[Symbol]

Definition Classes
Imports
def languageWildcardHandlers: List[ImportHandler]

Definition Classes
Imports
def languageWildcardSyms: List[Symbol]

Symbols whose contents are language-defined to be imported.
Symbols whose contents are language-defined to be imported.

Definition Classes
Imports
def languageWildcards: List[Type]

Definition Classes
Imports
lazy val lineManager: Manager
lazy val memberHandlers: MemberHandlers { val intp: IMain.this.type }
def mostRecentVar: String

Returns the name of the most recent interpreter result.
Returns the name of the most recent interpreter result. Mostly this exists so you can conveniently invoke methods on the previous result.
object naming extends Naming
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newCompiler(settings: Settings, reporter: Reporter): Global

Instantiate a compiler.
Instantiate a compiler. Overridable.

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onlyTerms(xs: List[Name]): List[TermName]

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

Attributes
protected
def optCompilerClass(name: String): Option[Symbol]
def optCompilerModule(name: String): Option[Symbol]
def optFlatName(id: String): Option[String]
val out: JPrintWriter

Attributes
protected
def parentClassLoader: ClassLoader

Parent classloader.
Parent classloader. Overridable.

Attributes
protected
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]

Attributes
protected
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]

Definition Classes
Imports
def sessionWildcards: List[Type]

Types which have been wildcard imported, such as: val x = "abc" ; import x.
Types which have been wildcard imported, such as: val x = "abc" ; import x._ // type java.lang.String import java.lang.String._ // object java.lang.String
Used by tab completion.
XXX right now this gets import x._ and import java.lang.String._, but doesn't figure out import String._. There's a lot of ad hoc scope twiddling which should be swept away in favor of digging into the compiler scopes.

Definition Classes
Imports
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

Definition Classes
AnyRef
def terms(name: String): Symbol
def toString(): String

Definition Classes
AnyRef → Any
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 .
directory to save .class files to
def visibleTermNames: List[Name]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
def wildcardTypes: List[Type]

Definition Classes
Imports
def withoutUnwrapping(op: ⇒ Unit): Unit

Deprecated Value Members

lazy val compiler: IMain.this.global.type

Annotations
@deprecated
Deprecated
(Since version 2.9.0) Use global for access to the compiler instance.

IMain

class IMain extends Imports

Instance Constructors

new IMain()

new IMain(settings: Settings)

new IMain(settings: Settings, out: JPrintWriter)

Type Members

case class ComputedImports(prepend: String, append: String, access: String) extends Product with Serializable

class ReadEvalPrint extends AnyRef

class Request extends AnyRef

Value Members

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]

def allDefinedNames: List[Name]

def allImplicits: List[Name]

def allSeenTypes: List[String]

def apply(name: String): Symbol

final def asInstanceOf[T0]: T0

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

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

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

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

def compileSources(sources: SourceFile*): Boolean

def compileString(code: String): Boolean

lazy val compilerClasspath: List[URL]

def createLineManager(): 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]

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

def getCompilerClass(name: String): Symbol

def getCompilerModule(name: String): Symbol

def getInterpreterClassLoader(): AbstractFileClassLoader

lazy val global: Global

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

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

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])]

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

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

def isNoImports: T

def isNoPredef: Boolean