ILoopInterpreter

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def allDefinedNames: List[Global.Name]

def allHandlers: collection.immutable.List[(memberHandlers)#MemberHandler]

def allImportedNames: collection.immutable.List[Global.Name]

final def asInstanceOf[T0]: T0

def backticked(s: String): String

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

Temporarily be quiet

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

def bind[T](name: String, value: T)(implicit arg0: reflect.api.JavaUniverse.TypeTag[T], arg1: ClassTag[T]): Results.Result

def bind(p: NamedParam): Results.Result

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

Bind a specified name to a specified value.

def classLoader: AbstractFileClassLoader

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

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

def cleanTypeAfterTyper(sym: ⇒ Global.Symbol): Global.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.

def compilerClasspath: Seq[URL]

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

object deconstruct extends StructuredTypeStrings

def definedSymbolList: collection.immutable.List[Global.Symbol]

def definedTerms: collection.immutable.List[Global.TermName]

def definedTypes: List[Global.TypeName]

def directBind[T](name: String, value: T)(implicit arg0: reflect.api.JavaUniverse.TypeTag[T], arg1: ClassTag[T]): Results.Result

def directBind(p: NamedParam): Results.Result

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

def echoTypeSignature: ((sym: _2184.intp.global.Symbol, verbose: Boolean)Unit) forSome {val _2184: IMainOps}

def echoTypeStructure: ((sym: _2190.intp.global.Symbol)Unit) forSome {val _2190: IMainOps}

final def ensureClassLoader(): Unit

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

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

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

def ensuring(cond: Boolean): ILoopInterpreter

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

object exprTyper extends ExprTyper

def finalize(): Unit

object flatOp extends PhaseDependentOps

def flatPath(sym: Global.Symbol): String

def formatted(fmtstr: String): String

lazy val formatting: Formatting

final def getClass(): Class[_]

def getClassIfDefined(path: String): Global.Symbol

def getModuleIfDefined(path: String): Global.Symbol

lazy val global: Global

the public, go through the future compiler

def hashCode(): Int

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

def implicitsCommand(line: String): String

def importHandlers: collection.immutable.List[(memberHandlers)#ImportHandler]

def importedSymbols: collection.immutable.List[Global.Symbol]

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

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

def importedTermSymbols: collection.immutable.List[Global.TermSymbol]

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

def initialize(postInitSignal: ⇒ Unit): Unit

def initializeSynchronous(): Unit

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

def interpret(line: String): Results.Result

Interpret one line of input.

def interpretSynthetic(line: String): Results.Result

val intp: IMain

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

lazy val isettings: ISettings

interpreter settings

def languageSymbols: collection.immutable.List[Global.Symbol]

def languageWildcardHandlers: collection.immutable.List[(memberHandlers)#ImportHandler]

def languageWildcardSyms: List[Global.Symbol]

Symbols whose contents are language-defined to be imported.

def lastRequest: Request

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

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

def mostRecentVar: String

Returns the name of the most recent interpreter result.

def namedDefinedTerms: collection.immutable.List[Global.TermName]

object naming extends Naming

final def ne(arg0: AnyRef): Boolean

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

Instantiate a compiler.

def normalizeNonPublic(tp: Global.Type): Global.Type

final def notify(): Unit

final def notifyAll(): Unit

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

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

def originalPath(sym: Global.Symbol): String

def originalPath(name: Global.Name): String

def originalPath(name: String): String

val out: JPrintWriter

def parentClassLoader: ClassLoader

Parent classloader.

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

def prevRequestList: collection.immutable.List[Request]

def printAfterTyper(msg: ⇒ String): Unit

def quietBind(p: NamedParam): Results.Result

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

def rebind(p: NamedParam): Results.Result

def recordRequest(req: Request): Unit

object replOutput extends ReplOutput

def replScope: Global.Scope

lazy val reporter: ReplReporter

def reset(): Unit

Reset this interpreter, forgetting all user-specified requests.

def resetClassLoader(): Unit

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

lazy val runtimeMirror: reflect.api.JavaUniverse.Mirror

def runtimeTypeOfTerm(id: String): Global.Type

def sessionImportedSymbols: collection.immutable.List[Global.Symbol]

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

def symbolDefString(sym: Global.Symbol): String

def symbolOfIdent(id: String): Global.Symbol

def symbolOfLine(code: String): Global.Symbol

def symbolOfName(id: Global.Name): Global.Symbol

def symbolOfTerm(id: String): Global.Symbol

def symbolOfType(id: String): Global.Symbol

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

def toString(): String

def translateEnclosingClass(n: String): Option[String]

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

def tryTwice(op: ⇒ Global.Symbol): Global.Symbol

It's a bit of a shotgun approach, but for now we will gain in robustness.

def typeCommandInternal(expr: String, verbose: Boolean): Unit

TODO - -n normalize -l label with case class parameter names -c complete - leave nothing out

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

def typeOfTerm(id: String): Global.Type

object typerOp extends PhaseDependentOps

def unqualifiedIds: List[String]

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withoutUnwrapping(op: ⇒ Unit): Unit

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

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

val self: Any

val self: Any

def virtualDirectory: ReplDir

def x: ILoopInterpreter

def x: ILoopInterpreter