Members removed from the repl.

There were a whole lot of these.

32 files changed, 25 insertions, 512 deletions

diff --git a/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala b/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala
index 014661e525..48890a21c6 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala
@@ -38,25 +38,5 @@ object ByteCode {
     }
     yield names
 
-  /** Attempts to retrieve case parameter names for given class name.
-   */
-  def caseParamNamesForPath(path: String) =
-    for {
-      module <- DECODER
-      method <- decoderMethod("caseParamNames", classOf[String])
-      names <- method.invoke(module, path).asInstanceOf[Option[List[String]]]
-    }
-    yield names
-
   def aliasesForPackage(pkg: String) = aliasMap flatMap (_(pkg))
-
-  /** Attempts to find type aliases in package objects.
-   */
-  def aliasForType(path: String): Option[String] = {
-    val (pkg, name) = (path lastIndexOf '.') match {
-      case -1   => return None
-      case idx  => (path take idx, path drop (idx + 1))
-    }
-    aliasesForPackage(pkg) flatMap (_ get name)
-  }
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/CommandLine.scala b/src/compiler/scala/tools/nsc/interpreter/CommandLine.scala
index 8042f0aee2..0ab92ab769 100644
--- a/src/compiler/scala/tools/nsc/interpreter/CommandLine.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/CommandLine.scala
@@ -10,5 +10,4 @@ package interpreter
  */
 class CommandLine(arguments: List[String], error: String => Unit) extends CompilerCommand(arguments, error) {
   override def cmdName = "scala"
-  override lazy val fileEndings = List(".scalaint")
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/Completion.scala b/src/compiler/scala/tools/nsc/interpreter/Completion.scala
index 1dfccbfbf7..84a5cb49ae 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Completion.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Completion.scala
@@ -23,8 +23,6 @@ object NoCompletion extends Completion {
 }
 
 object Completion {
-  def empty: Completion = NoCompletion
-
   case class Candidates(cursor: Int, candidates: List[String]) { }
   val NoCandidates = Candidates(-1, Nil)
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala b/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala
index 3a0b48ef57..3dd5d93390 100644
--- a/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala
@@ -51,31 +51,3 @@ trait CompletionAware {
     results.sorted
   }
 }
-
-object CompletionAware {
-  val Empty = new CompletionAware { def completions(verbosity: Int) = Nil }
-
-  def unapply(that: Any): Option[CompletionAware] = that match {
-    case x: CompletionAware => Some((x))
-    case _                  => None
-  }
-
-  /** Create a CompletionAware object from the given functions.
-   *  The first should generate the list of completions whenever queried,
-   *  and the second should return Some(CompletionAware) object if
-   *  subcompletions are possible.
-   */
-  def apply(terms: () => List[String], followFunction: String => Option[CompletionAware]): CompletionAware =
-    new CompletionAware {
-      def completions = terms()
-      def completions(verbosity: Int) = completions
-      override def follow(id: String) = followFunction(id)
-    }
-
-  /** Convenience factories.
-   */
-  def apply(terms: () => List[String]): CompletionAware = apply(terms, _ => None)
-  def apply(map: scala.collection.Map[String, CompletionAware]): CompletionAware =
-    apply(() => map.keys.toList, map.get _)
-}
-
diff --git a/src/compiler/scala/tools/nsc/interpreter/CompletionOutput.scala b/src/compiler/scala/tools/nsc/interpreter/CompletionOutput.scala
index 13880bb8af..c647ef6f51 100644
--- a/src/compiler/scala/tools/nsc/interpreter/CompletionOutput.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/CompletionOutput.scala
@@ -38,7 +38,6 @@ trait CompletionOutput {
 
     def relativize(str: String): String = quietString(str stripPrefix (pkg + "."))
     def relativize(tp: Type): String    = relativize(tp.normalize.toString)
-    def relativize(sym: Symbol): String = relativize(sym.info)
 
     def braceList(tparams: List[String]) = if (tparams.isEmpty) "" else (tparams map relativize).mkString("[", ", ", "]")
     def parenList(params: List[Any])  = params.mkString("(", ", ", ")")
diff --git a/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala b/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala
index b5850d901c..48af261937 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala
@@ -9,15 +9,10 @@ package interpreter
 import scala.tools.jline.console.{ ConsoleReader, CursorBuffer }
 
 trait ConsoleReaderHelper extends ConsoleReader {
-  def currentLine = "" + getCursorBuffer.buffer
-  def currentPos  = getCursorBuffer.cursor
   def terminal    = getTerminal()
   def width       = terminal.getWidth()
   def height      = terminal.getHeight()
-  def paginate    = isPaginationEnabled()
-  def paginate_=(value: Boolean) = setPaginationEnabled(value)
 
-  def goBack(num: Int): Unit
   def readOneKey(prompt: String): Int
   def eraseLine(): Unit
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/Delimited.scala b/src/compiler/scala/tools/nsc/interpreter/Delimited.scala
index 80debfacb9..e88a044931 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Delimited.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Delimited.scala
@@ -26,7 +26,6 @@ trait Delimited {
 
   def delimited: Char => Boolean
   def escapeChars: List[Char] = List('\\')
-  def quoteChars: List[(Char, Char)] = List(('\'', '\''), ('"', '"'))
 
   /** Break String into args based on delimiting function.
    */
@@ -39,6 +38,4 @@ trait Delimited {
 
   def isDelimiterChar(ch: Char) = delimited(ch)
   def isEscapeChar(ch: Char): Boolean = escapeChars contains ch
-  def isQuoteStart(ch: Char): Boolean = quoteChars map (_._1) contains ch
-  def isQuoteEnd(ch: Char): Boolean = quoteChars map (_._2) contains ch
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala
index 5ebaf6e031..b087547cf8 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala
@@ -42,10 +42,6 @@ trait ExprTyper {
       else Some(trees)
     }
   }
-  // def parsesAsExpr(line: String) = {
-  //   import codeParser._
-  //   (opt expr line).isDefined
-  // }
 
   def symbolOfLine(code: String): Symbol = {
     def asExpr(): Symbol = {
diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
index 74549ef558..612a90f3ea 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
@@ -14,7 +14,6 @@ import scala.util.Properties.{ jdkHome, javaVersion, versionString, javaVmName }
 import scala.tools.util.{ Javap }
 import util.{ ClassPath, Exceptional, stringFromWriter, stringFromStream }
 import io.{ File, Directory }
-import scala.reflect.NameTransformer._
 import util.ScalaClassLoader
 import ScalaClassLoader._
 import scala.tools.util._
@@ -71,13 +70,9 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
     intp.reporter printUntruncatedMessage msg
   }
 
-  def isAsync = !settings.Yreplsync.value
   lazy val power = new Power(intp, new StdReplVals(this))(tagOfStdReplVals, classTag[StdReplVals])
   def history = in.history
 
-  /** The context class loader at the time this object was created */
-  protected val originalClassLoader = Thread.currentThread.getContextClassLoader
-
   // classpath entries added via :cp
   var addedClasspath: String = ""
 
@@ -131,20 +126,18 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
   def helpCommand(line: String): Result = {
     if (line == "") helpSummary()
     else uniqueCommand(line) match {
-      case Some(lc) => echo("\n" + lc.longHelp)
+      case Some(lc) => echo("\n" + lc.help)
       case _        => ambiguousError(line)
     }
   }
   private def helpSummary() = {
     val usageWidth  = commands map (_.usageMsg.length) max
-    val formatStr   = "%-" + usageWidth + "s %s %s"
+    val formatStr   = "%-" + usageWidth + "s %s"
 
     echo("All commands can be abbreviated, e.g. :he instead of :help.")
-    echo("Those marked with a * have more detailed help, e.g. :help imports.\n")
 
     commands foreach { cmd =>
-      val star = if (cmd.hasLongHelp) "*" else " "
-      echo(formatStr.format(cmd.usageMsg, star, cmd.help))
+      echo(formatStr.format(cmd.usageMsg, cmd.help))
     }
   }
   private def ambiguousError(cmd: String): Result = {
@@ -194,10 +187,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
     out println msg
     out.flush()
   }
-  protected def echoNoNL(msg: String) = {
-    out print msg
-    out.flush()
-  }
 
   /** Search the history */
   def searchHistory(_cmdline: String) {
@@ -208,8 +197,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
       echo("%d %s".format(index + offset, line))
   }
 
-  private var currentPrompt = Properties.shellPromptString
-  def setPrompt(prompt: String) = currentPrompt = prompt
+  private val currentPrompt = Properties.shellPromptString
+
   /** Prompt to print when awaiting input */
   def prompt = currentPrompt
 
@@ -684,7 +673,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
   def process(settings: Settings): Boolean = savingContextLoader {
     this.settings = settings
     createInterpreter()
-    var thunks: List[() => Unit] = Nil
 
     // sets in to some kind of reader depending on environmental cues
     in = in0.fold(chooseReader(settings))(r => SimpleReader(r, out, true))
@@ -703,22 +691,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
     true
   }
 
-  /** process command-line arguments and do as they request */
-  def process(args: Array[String]): Boolean = {
-    val command = new CommandLine(args.toList, echo)
-    def neededHelp(): String =
-      (if (command.settings.help.value) command.usageMsg + "\n" else "") +
-      (if (command.settings.Xhelp.value) command.xusageMsg + "\n" else "")
-
-    // if they asked for no help and command is valid, we call the real main
-    neededHelp() match {
-      case ""     => command.ok && process(command.settings)
-      case help   => echoNoNL(help) ; true
-    }
-  }
-
   @deprecated("Use `process` instead", "2.9.0")
-  def main(settings: Settings): Unit = process(settings)
+  def main(settings: Settings): Unit = process(settings) //used by sbt
 }
 
 object ILoop {
diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
index 0ef27ac96a..3f49e782b0 100644
--- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
@@ -63,6 +63,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
   @deprecated("Use replOutput.dir instead", "2.11.0")
   def virtualDirectory = replOutput.dir
+  // Used in a test case.
   def showDirectory() = replOutput.show(out)
 
   private[nsc] var printResults               = true      // whether to print result lines
@@ -82,20 +83,11 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   private var _classLoader: AbstractFileClassLoader = null                              // active classloader
   private val _compiler: Global                     = newCompiler(settings, reporter)   // our private compiler
 
-  private val nextReqId = {
-    var counter = 0
-    () => { counter += 1 ; counter }
-  }
-
   def compilerClasspath: Seq[URL] = (
     if (isInitializeComplete) global.classPath.asURLs
     else new PathResolver(settings).result.asURLs  // the compiler's classpath
   )
   def settings = initialSettings
-  def mostRecentLine = prevRequestList match {
-    case Nil      => ""
-    case req :: _ => req.originalLine
-  }
   // Run the code body with the given boolean settings flipped to true.
   def withoutWarnings[T](body: => T): T = beQuietDuring {
     val saved = settings.nowarn.value
@@ -110,12 +102,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def this(settings: Settings) = this(settings, new NewLinePrintWriter(new ConsoleWriter, true))
   def this() = this(new Settings())
 
-  lazy val repllog: Logger = new Logger {
-    val out: JPrintWriter = imain.out
-    val isInfo: Boolean  = BooleanProp keyExists "scala.repl.info"
-    val isDebug: Boolean = BooleanProp keyExists "scala.repl.debug"
-    val isTrace: Boolean = BooleanProp keyExists "scala.repl.trace"
-  }
   lazy val formatting: Formatting = new Formatting {
     val prompt = Properties.shellPromptString
   }
@@ -175,7 +161,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   }
 
   import global._
-  import definitions.{ ObjectClass, termMember, typeMember, dropNullaryMethod}
+  import definitions.{ ObjectClass, termMember, dropNullaryMethod}
 
   lazy val runtimeMirror = ru.runtimeMirror(classLoader)
 
@@ -189,13 +175,8 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
            noFatal(runtimeMirror staticModule path)
     orElse noFatal(rootMirror staticModule path)
   )
-  def getPathIfDefined(path: String) = (
-    if (path endsWith "$") getModuleIfDefined(path.init)
-    else getClassIfDefined(path)
-  )
 
   implicit class ReplTypeOps(tp: Type) {
-    def orElse(other: => Type): Type    = if (tp ne NoType) tp else other
     def andAlso(fn: Type => Type): Type = if (tp eq NoType) tp else fn(tp)
   }
 
@@ -211,7 +192,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       if (replScope containsName name) freshUserTermName()
       else name
     }
-    def isUserTermName(name: Name) = isUserVarName("" + name)
     def isInternalTermName(name: Name) = isInternalVarName("" + name)
   }
   import naming._
@@ -310,11 +290,8 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   abstract class PhaseDependentOps {
     def shift[T](op: => T): T
 
-    def lookup(name: Name): Symbol = shift(replScope lookup name)
     def path(name: => Name): String = shift(path(symbolOfName(name)))
     def path(sym: Symbol): String = backticked(shift(sym.fullName))
-    def name(sym: Symbol): Name   = shift(sym.name)
-    def info(sym: Symbol): Type   = shift(sym.info)
     def sig(sym: Symbol): String  = shift(sym.defString)
   }
   object typerOp extends PhaseDependentOps {
@@ -328,7 +305,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def originalPath(name: Name): String   = typerOp path name
   def originalPath(sym: Symbol): String  = typerOp path sym
   def flatPath(sym: Symbol): String      = flatOp shift sym.javaClassName
-  // def translatePath(path: String) = symbolOfPath(path).fold(Option.empty[String])(flatPath)
   def translatePath(path: String) = {
     val sym = if (path endsWith "$") symbolOfTerm(path.init) else symbolOfIdent(path)
     sym match {
@@ -354,8 +330,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       case p      => new URLClassLoader(compilerClasspath, p)
     })
 
-  def getInterpreterClassLoader() = classLoader
-
   // Set the current Java "context" class loader to this interpreter's class loader
   def setContextClassLoader() = classLoader.setAsContext()
 
@@ -405,7 +379,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     exitingTyper {
       req.defines filterNot (s => req.defines contains s.companionSymbol) foreach { newSym =>
         val companion = newSym.name.companionName
-        val found = replScope lookup companion
         replScope lookup companion andAlso { oldSym =>
           replwarn(s"warning: previously defined $oldSym is not a companion to $newSym.")
           replwarn("Companions must be defined together; you may wish to use :paste mode for this.")
@@ -423,19 +396,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       printMessage(msg)
   }
 
-  def isParseable(line: String): Boolean = {
-    beSilentDuring {
-      try parse(line) match {
-        case Some(xs) => xs.nonEmpty  // parses as-is
-        case None     => true         // incomplete
-      }
-      catch { case x: Exception =>    // crashed the compiler
-        replwarn("Exception in isParseable(\"" + line + "\"): " + x)
-        false
-      }
-    }
-  }
-
   def compileSourcesKeepingRun(sources: SourceFile*) = {
     val run = new Run()
     reporter.reset()
@@ -653,17 +613,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     quietRun("val %s = %s".format(tempName, name))
     quietRun("val %s = %s.asInstanceOf[%s]".format(name, tempName, newType))
   }
-  def quietImport(ids: String*): IR.Result = beQuietDuring(addImports(ids: _*))
-  def addImports(ids: String*): IR.Result =
-    if (ids.isEmpty) IR.Success
-    else interpret("import " + ids.mkString(", "))
-
   def quietBind(p: NamedParam): IR.Result                               = beQuietDuring(bind(p))
   def bind(p: NamedParam): IR.Result                                    = bind(p.name, p.tpe, p.value)
   def bind[T: ru.TypeTag : ClassTag](name: String, value: T): IR.Result = bind((name, value))
-  def bindSyntheticValue(x: Any): IR.Result                             = bindValue(freshInternalVarName(), x)
-  def bindValue(x: Any): IR.Result                                      = bindValue(freshUserVarName(), x)
-  def bindValue(name: String, x: Any): IR.Result                        = bind(name, TypeStrings.fromValue(x), x)
 
   /** Reset this interpreter, forgetting all user-specified requests. */
   def reset() {
@@ -719,7 +671,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
     def readPath  = pathTo(readName)
     def evalPath  = pathTo(evalName)
-    def printPath = pathTo(printName)
 
     def call(name: String, args: Any*): AnyRef = {
       val m = evalMethod(name)
@@ -734,10 +685,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       try Right(call(name, args: _*))
       catch { case ex: Throwable => Left(ex) }
 
-    def callOpt(name: String, args: Any*): Option[AnyRef] =
-      try Some(call(name, args: _*))
-      catch { case ex: Throwable => bindError(ex) ; None }
-
     class EvalException(msg: String, cause: Throwable) extends RuntimeException(msg, cause) { }
 
     private def evalError(path: String, ex: Throwable) =
@@ -749,7 +696,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     }
 
     lazy val evalClass = load(evalPath)
-    lazy val evalValue = callOpt(resultName)
 
     def compile(source: String): Boolean = compileAndSaveRun("<console>", source)
 
@@ -798,14 +744,11 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   }
 
   /** One line of code submitted by the user for interpretation */
-  // private
   class Request(val line: String, val trees: List[Tree]) {
     def defines    = defHandlers flatMap (_.definedSymbols)
     def imports    = importedSymbols
-    def references = referencedNames map symbolOfName
     def value      = Some(handlers.last) filter (h => h.definesValue) map (h => definedSymbols(h.definesTerm.get)) getOrElse NoSymbol
 
-    val reqId = nextReqId()
     val lineRep = new ReadEvalPrint()
 
     private var _originalLine: String = null
@@ -816,9 +759,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     val handlers: List[MemberHandler] = trees map (memberHandlers chooseHandler _)
     def defHandlers = handlers collect { case x: MemberDefHandler => x }
 
-    /** all (public) names defined by these statements */
-    val definedNames = handlers flatMap (_.definedNames)
-
     /** list of names used by this expression */
     val referencedNames: List[Name] = handlers flatMap (_.referencedNames)
 
@@ -836,9 +776,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     val ComputedImports(importsPreamble, importsTrailer, accessPath) =
       exitingTyper(importsCode(referencedNames.toSet))
 
-    /** The unmangled symbol name, but supplemented with line info. */
-    def disambiguated(name: Name): String = name + " (in " + lineRep + ")"
-
     /** the line of code to compute */
     def toCompute = line
 
@@ -852,13 +789,11 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
         // $intp is not bound; punt, but include the line.
         else if (path == "$intp") List(
           "def $line = " + tquoted(originalLine),
-          // "def $req = %s.requestForReqId(%s).orNull".format(path, reqId),
           "def $trees = Nil"
         )
         else List(
           "def $line  = " + tquoted(originalLine),
           "def $trees = Nil"
-          // "def $trees = if ($req eq null) Nil else $req.trees".format(lineRep.readName, path, reqId)
         )
       }
 
@@ -931,7 +866,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
     /* typeOf lookup with encoding */
     def lookupTypeOf(name: Name) = typeOf.getOrElse(name, typeOf(global.encode(name.toString)))
-    def simpleNameOfType(name: TypeName) = (compilerTypeOf get name) map (_.typeSymbolDirect.simpleName)
 
     private def typeMap[T](f: Type => T) =
       mapFrom[Name, Name, T](termNames ++ typeNames)(x => f(cleanMemberDecl(resultSymbol, x)))
@@ -1011,8 +945,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
    */
   def tryTwice(op: => Symbol): Symbol = exitingTyper(op) orElse exitingFlatten(op)
 
-  def signatureOf(sym: Symbol)           = typerOp sig sym
-  def symbolOfPath(path: String): Symbol = exitingTyper(getPathIfDefined(path))
   def symbolOfIdent(id: String): Symbol  = symbolOfTerm(id) orElse symbolOfType(id)
   def symbolOfType(id: String): Symbol   = tryTwice(replScope lookup (id: TypeName))
   def symbolOfTerm(id: String): Symbol   = tryTwice(replScope lookup (id: TermName))
@@ -1067,76 +999,30 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
   def definedTerms      = onlyTerms(allDefinedNames) filterNot isInternalTermName
   def definedTypes      = onlyTypes(allDefinedNames)
-  def definedSymbols    = prevRequestList flatMap (_.defines) toSet
   def definedSymbolList = prevRequestList flatMap (_.defines) filterNot (s => isInternalTermName(s.name))
 
   // Terms with user-given names (i.e. not res0 and not synthetic)
   def namedDefinedTerms = definedTerms filterNot (x => isUserVarName("" + x) || directlyBoundNames(x))
 
-  /** Translate a repl-defined identifier into a Symbol.
-   */
-  def apply(name: String): Symbol = types(name) orElse terms(name)
-  def types(name: String): Symbol = replScope lookup (name: TypeName) orElse getClassIfDefined(name)
-  def terms(name: String): Symbol = replScope lookup (name: TermName) orElse getModuleIfDefined(name)
-
-  def types[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
-  def terms[T: global.TypeTag] : Symbol = typeOf[T].termSymbol
-  def apply[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
-
-  lazy val DummyInfoSymbol = NoSymbol.newValue("replScopeDummy")
-  private lazy val DummyInfo = TypeRef(NoPrefix, DummyInfoSymbol, Nil)
-  private def enterDummySymbol(name: Name) = name match {
-    case x: TermName => replScope enter (NoSymbol.newValue(x) setInfo DummyInfo)
-    case x: TypeName => replScope enter (NoSymbol.newClass(x) setInfo DummyInfo)
-  }
-
   private var _replScope: Scope = _
   private def resetReplScope() {
     _replScope = newScope
   }
-  def initReplScope() {
-    languageWildcardSyms foreach { clazz =>
-      importableMembers(clazz) foreach { sym =>
-        updateReplScope(sym, isDefined = false)
-      }
-    }
-  }
   def replScope = {
     if (_replScope eq null)
       _replScope = newScope
 
     _replScope
   }
-  def lookupAll(name: String) = (replScope.lookupAll(name: TermName) ++ replScope.lookupAll(name: TypeName)).toList
-  def unlinkAll(name: String) = {
-    val syms = lookupAll(name)
-    syms foreach { sym =>
-      replScope unlink sym
-    }
-    enterDummySymbol(name: TermName)
-    enterDummySymbol(name: TypeName)
-    syms
-  }
-  def isUnlinked(name: Name) = {
-    symbolOfName(name) match {
-      case NoSymbol => false
-      case sym      => sym.info.typeSymbolDirect == DummyInfoSymbol
-    }
-  }
 
   private var executingRequest: Request = _
   private val prevRequests       = mutable.ListBuffer[Request]()
   private val directlyBoundNames = mutable.Set[Name]()
 
-  def allHandlers    = prevRequestList flatMap (_.handlers)
-  def allDefHandlers = allHandlers collect { case x: MemberDefHandler => x }
-  def allDefSymbols  = allDefHandlers map (_.symbol) filter (_ ne NoSymbol)
-
-  def lastRequest         = if (prevRequests.isEmpty) null else prevRequests.last
-  def prevRequestList     = prevRequests.toList
-  def allSeenTypes        = prevRequestList flatMap (_.typeOf.values.toList) distinct
-  def allImplicits        = allHandlers filter (_.definesImplicit) flatMap (_.definedNames)
-  def importHandlers      = allHandlers collect { case x: ImportHandler => x }
+  def allHandlers     = prevRequestList flatMap (_.handlers)
+  def lastRequest     = if (prevRequests.isEmpty) null else prevRequests.last
+  def prevRequestList = prevRequests.toList
+  def importHandlers  = allHandlers collect { case x: ImportHandler => x }
 
   def withoutUnwrapping(op: => Unit): Unit = {
     val saved = isettings.unwrapStrings
diff --git a/src/compiler/scala/tools/nsc/interpreter/ISettings.scala b/src/compiler/scala/tools/nsc/interpreter/ISettings.scala
index 302ba7a8ac..d114ca2359 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ISettings.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ISettings.scala
@@ -12,13 +12,6 @@ package interpreter
  * @author Lex Spoon, 2007/3/24
  **/
 class ISettings(intp: IMain) {
-  /** A list of paths where :load should look */
-  var loadPath = List(".")
-
-  /** Set this to true to see repl machinery under -Yrich-exceptions.
-   */
-  var showInternalStackTraces = false
-
   /** The maximum length of toString to use when printing the result
    *  of an evaluation.  0 means no maximum.  If a printout requires
    *  more than this number of characters, then the printout is
diff --git a/src/compiler/scala/tools/nsc/interpreter/Imports.scala b/src/compiler/scala/tools/nsc/interpreter/Imports.scala
index c5048ebfd8..ff7bfd432c 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Imports.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Imports.scala
@@ -15,9 +15,6 @@ trait Imports {
   import definitions.{ ObjectClass, ScalaPackage, JavaLangPackage, PredefModule }
   import memberHandlers._
 
-  def isNoImports = settings.noimports.value
-  def isNoPredef  = settings.nopredef.value
-
   /** Synthetic import handlers for the language defined imports. */
   private def makeWildcardImportHandler(sym: Symbol): ImportHandler = {
     val hd :: tl = sym.fullName.split('.').toList map newTermName
@@ -31,12 +28,9 @@ trait Imports {
 
   /** Symbols whose contents are language-defined to be imported. */
   def languageWildcardSyms: List[Symbol] = List(JavaLangPackage, ScalaPackage, PredefModule)
-  def languageWildcards: List[Type] = languageWildcardSyms map (_.tpe)
   def languageWildcardHandlers = languageWildcardSyms map makeWildcardImportHandler
 
   def allImportedNames = importHandlers flatMap (_.importedNames)
-  def importedTerms    = onlyTerms(allImportedNames)
-  def importedTypes    = onlyTypes(allImportedNames)
 
   /** Types which have been wildcard imported, such as:
    *    val x = "abc" ; import x._  // type java.lang.String
@@ -52,17 +46,11 @@ trait Imports {
   def sessionWildcards: List[Type] = {
     importHandlers filter (_.importsWildcard) map (_.targetType) distinct
   }
-  def wildcardTypes = languageWildcards ++ sessionWildcards
 
   def languageSymbols        = languageWildcardSyms flatMap membersAtPickler
   def sessionImportedSymbols = importHandlers flatMap (_.importedSymbols)
   def importedSymbols        = languageSymbols ++ sessionImportedSymbols
   def importedTermSymbols    = importedSymbols collect { case x: TermSymbol => x }
-  def importedTypeSymbols    = importedSymbols collect { case x: TypeSymbol => x }
-  def implicitSymbols        = importedSymbols filter (_.isImplicit)
-
-  def importedTermNamed(name: String): Symbol =
-    importedTermSymbols find (_.name.toString == name) getOrElse NoSymbol
 
   /** Tuples of (source, imported symbols) in the order they were imported.
    */
@@ -104,9 +92,7 @@ trait Imports {
    * last one imported is actually usable.
    */
   case class ComputedImports(prepend: String, append: String, access: String)
-  protected def importsCode(wanted0: Set[Name]): ComputedImports = {
-    val wanted = wanted0 filterNot isUnlinked
-
+  protected def importsCode(wanted: Set[Name]): ComputedImports = {
     /** Narrow down the list of requests from which imports
      *  should be taken.  Removes requests which cannot contribute
      *  useful imports for the specified set of wanted names.
diff --git a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala
index 6513381d77..28ddf2939c 100644
--- a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala
@@ -15,22 +15,16 @@ import Properties.isMac
 trait InteractiveReader {
   val interactive: Boolean
 
-  def init(): Unit
   def reset(): Unit
-
   def history: History
   def completion: Completion
-  def eraseLine(): Unit
   def redrawLine(): Unit
-  def currentLine: String
 
   def readYesOrNo(prompt: String, alt: => Boolean): Boolean = readOneKey(prompt) match {
     case 'y'  => true
     case 'n'  => false
     case _    => alt
   }
-  def readAssumingNo(prompt: String)  = readYesOrNo(prompt, false)
-  def readAssumingYes(prompt: String) = readYesOrNo(prompt, true)
 
   protected def readOneLine(prompt: String): String
   protected def readOneKey(prompt: String): Int
@@ -50,6 +44,6 @@ object InteractiveReader {
 
   def apply(): InteractiveReader = SimpleReader()
   @deprecated("Use `apply` instead.", "2.9.0")
-  def createDefault(): InteractiveReader = apply()
+  def createDefault(): InteractiveReader = apply() // used by sbt
 }
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala
index 5ee5e5526d..19fa562234 100644
--- a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala
@@ -28,9 +28,6 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput
     if (isModule) getModuleIfDefined(name)
     else getModuleIfDefined(name)
   )
-  def getType(name: String, isModule: Boolean) = getSymbol(name, isModule).tpe
-  def typeOf(name: String)                     = getType(name, false)
-  def moduleOf(name: String)                   = getType(name, true)
 
   trait CompilerCompletion {
     def tp: Type
@@ -47,7 +44,6 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput
 
     def tos(sym: Symbol): String = sym.decodedName
     def memberNamed(s: String) = exitingTyper(effectiveTp member newTermName(s))
-    def hasMethod(s: String) = memberNamed(s).isMethod
 
     // XXX we'd like to say "filterNot (_.isDeprecated)" but this causes the
     // compiler to crash for reasons not yet known.
@@ -279,10 +275,6 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput
     if (parsed.isEmpty) xs map ("." + _) else xs
   }
 
-  // generic interface for querying (e.g. interpreter loop, testing)
-  def completions(buf: String): List[String] =
-    topLevelFor(Parsed.dotted(buf + ".", buf.length + 1))
-
   def completer(): ScalaCompleter = new JLineTabCompletion
 
   /** This gets a little bit hairy.  It's no small feat delegating everything
diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala
index e033bab03b..a620c7c75a 100644
--- a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala
@@ -23,7 +23,6 @@ class JLineReader(_completion: => Completion) extends InteractiveReader {
 
   private def term = consoleReader.getTerminal()
   def reset() = term.reset()
-  def init()  = term.init()
 
   def scalaToJline(tc: ScalaCompleter): Completer = new Completer {
     def complete(_buf: String, cursor: Int, candidates: JList[CharSequence]): Int = {
@@ -35,8 +34,6 @@ class JLineReader(_completion: => Completion) extends InteractiveReader {
   }
 
   class JLineConsoleReader extends ConsoleReader with ConsoleReaderHelper {
-    // working around protected/trait/java insufficiencies.
-    def goBack(num: Int): Unit = back(num)
     def readOneKey(prompt: String) = {
       this.print(prompt)
       this.flush()
@@ -44,7 +41,6 @@ class JLineReader(_completion: => Completion) extends InteractiveReader {
     }
     def eraseLine() = consoleReader.resetPromptLine("", "", 0)
     def redrawLineAndFlush(): Unit = { flush() ; drawLine() ; flush() }
-    // override def readLine(prompt: String): String
 
     // A hook for running code after the repl is done initializing.
     lazy val postInit: Unit = {
@@ -63,11 +59,7 @@ class JLineReader(_completion: => Completion) extends InteractiveReader {
     }
   }
 
-  def currentLine = consoleReader.getCursorBuffer.buffer.toString
   def redrawLine() = consoleReader.redrawLineAndFlush()
-  def eraseLine() = consoleReader.eraseLine()
-  // Alternate implementation, not sure if/when I need this.
-  // def eraseLine() = while (consoleReader.delete()) { }
   def readOneLine(prompt: String) = consoleReader readLine prompt
   def readOneKey(prompt: String)  = consoleReader readOneKey prompt
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/Logger.scala b/src/compiler/scala/tools/nsc/interpreter/Logger.scala
index aeb25fc688..7407daf8d0 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Logger.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Logger.scala
@@ -11,8 +11,4 @@ trait Logger {
   def isDebug: Boolean
   def isTrace: Boolean
   def out: JPrintWriter
-
-  def info(msg: => Any): Unit  = if (isInfo) out println msg
-  def debug(msg: => Any): Unit = if (isDebug) out println msg
-  def trace(msg: => Any): Unit = if (isTrace) out println msg
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/LoopCommands.scala b/src/compiler/scala/tools/nsc/interpreter/LoopCommands.scala
index 60325ece30..39979c8fbe 100644
--- a/src/compiler/scala/tools/nsc/interpreter/LoopCommands.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/LoopCommands.scala
@@ -19,13 +19,8 @@ class ProcessResult(val line: String) {
   val exitCode = builder ! logger
   def lines    = buffer.toList
 
-  def show() = lines foreach println
   override def toString = "`%s` (%d lines, exit %d)".format(line, buffer.size, exitCode)
 }
-object ProcessResult {
-  implicit def processResultToOutputLines(pr: ProcessResult): List[String] = pr.lines
-  def apply(line: String): ProcessResult = new ProcessResult(line)
-}
 
 trait LoopCommands {
   protected def out: JPrintWriter
@@ -35,14 +30,6 @@ trait LoopCommands {
 
   // a single interpreter command
   abstract class LoopCommand(val name: String, val help: String) extends (String => Result) {
-    private var _longHelp: String = null
-    final def defaultHelp = usageMsg + " (no extended help available.)"
-    def hasLongHelp = _longHelp != null || longHelp != defaultHelp
-    def withLongHelp(text: String): this.type = { _longHelp = text ; this }
-    def longHelp = _longHelp match {
-      case null   => defaultHelp
-      case text   => text
-    }
     def usage: String = ""
     def usageMsg: String = ":" + name + (
       if (usage == "") "" else " " + usage
@@ -54,11 +41,6 @@ trait LoopCommands {
       "usage is " + usageMsg
       Result(true, None)
     }
-
-    def onError(msg: String) = {
-      out.println("error: " + msg)
-      showUsage()
-    }
   }
   object LoopCommand {
     def nullary(name: String, help: String, f: () => Result): LoopCommand =
@@ -67,9 +49,6 @@ trait LoopCommands {
     def cmd(name: String, usage: String, help: String, f: String => Result): LoopCommand =
       if (usage == "") new NullaryCmd(name, help, f)
       else new LineCmd(name, usage, help, f)
-
-    def varargs(name: String, usage: String, help: String, f: List[String] => Result): LoopCommand =
-      new VarArgsCmd(name, usage, help, f)
   }
 
   class NullaryCmd(name: String, help: String, f: String => Result) extends LoopCommand(name, help) {
diff --git a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
index 95482f1e46..381dfeb261 100644
--- a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
@@ -81,7 +81,6 @@ trait MemberHandlers {
     def symbol          = if (member.symbol eq null) NoSymbol else member.symbol
     def definesImplicit = false
     def definesValue    = false
-    def isLegalTopLevel = false
 
     def definesTerm     = Option.empty[TermName]
     def definesType     = Option.empty[TypeName]
@@ -152,7 +151,6 @@ trait MemberHandlers {
   class ModuleHandler(module: ModuleDef) extends MemberDefHandler(module) {
     override def definesTerm = Some(name)
     override def definesValue = true
-    override def isLegalTopLevel = true
 
     override def resultExtractionCode(req: Request) = codegenln("defined module ", name)
   }
@@ -161,7 +159,6 @@ trait MemberHandlers {
     override def definedSymbols = List(symbol, symbol.companionSymbol) filterNot (_ == NoSymbol)
     override def definesType = Some(name.toTypeName)
     override def definesTerm = Some(name.toTermName) filter (_ => mods.isCase)
-    override def isLegalTopLevel = true
 
     override def resultExtractionCode(req: Request) =
       codegenln("defined %s %s".format(keyword, name))
@@ -182,20 +179,6 @@ trait MemberHandlers {
       case sym      => sym.thisType
     }
     private def importableTargetMembers = importableMembers(targetType).toList
-    override def isLegalTopLevel = true
-
-    def createImportForName(name: Name): String = {
-      selectors foreach {
-        case sel @ ImportSelector(old, _, `name`, _)  => return "import %s.{ %s }".format(expr, sel)
-        case _ => ()
-      }
-      "import %s.%s".format(expr, name)
-    }
-    // TODO: Need to track these specially to honor Predef masking attempts,
-    // because they must be the leading imports in the code generated for each
-    // line.  We can use the same machinery as Contexts now, anyway.
-    def isPredefImport = isReferenceToPredef(expr)
-
     // wildcard imports, e.g. import foo._
     private def selectorWild    = selectors filter (_.name == nme.USCOREkw)
     // renamed imports, e.g. import foo.{ bar => baz }
diff --git a/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala b/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala
index eff0ef59c5..627a881cae 100644
--- a/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/NamedParam.scala
@@ -14,14 +14,10 @@ import scala.reflect.{ClassTag, classTag}
 trait NamedParamCreator {
   protected def freshName: () => String
 
-  def apply(name: String, tpe: String, value: Any): NamedParam = NamedParamClass(name, tpe, value)
   def apply[T: ru.TypeTag : ClassTag](name: String, x: T): NamedParam = new Typed[T](name, x)
   def apply[T: ru.TypeTag : ClassTag](x: T): NamedParam = apply(freshName(), x)
-
   def clazz(name: String, x: Any): NamedParam = new Untyped(name, x)
-  def clazz(x: Any): NamedParam = clazz(freshName(), x)
 
-  implicit def namedValue[T: ru.TypeTag : ClassTag](name: String, x: T): NamedParam = apply(name, x)
   implicit def tuple[T: ru.TypeTag : ClassTag](pair: (String, T)): NamedParam       = apply(pair._1, pair._2)
 }
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/Naming.scala b/src/compiler/scala/tools/nsc/interpreter/Naming.scala
index 0d03a8669a..41ddf23de4 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Naming.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Naming.scala
@@ -78,7 +78,6 @@ trait Naming {
   private lazy val userVar     = new NameCreator(sessionNames.res)  // var name, like res0
   private lazy val internalVar = new NameCreator(sessionNames.ires) // internal var name, like $ires0
 
-  def isLineName(name: String)        = (name startsWith sessionNames.line) && (name stripPrefix sessionNames.line forall (_.isDigit))
   def isUserVarName(name: String)     = userVar didGenerate name
   def isInternalVarName(name: String) = internalVar didGenerate name
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/Parsed.scala b/src/compiler/scala/tools/nsc/interpreter/Parsed.scala
index 24c01e9ae6..672a6fd28f 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Parsed.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Parsed.scala
@@ -17,7 +17,6 @@ class Parsed private (
 ) extends Delimited {
   def isEmpty       = args.isEmpty
   def isUnqualified = args.size == 1
-  def isQualified   = args.size > 1
   def isAtStart     = cursor <= 0
 
   private var _verbosity = 0
@@ -31,7 +30,6 @@ class Parsed private (
   def bufferTail = new Parsed(buffer drop headLength, cursor - headLength, delimited) withVerbosity verbosity
 
   def prev = new Parsed(buffer, cursor - 1, delimited) withVerbosity verbosity
-  def next = new Parsed(buffer, cursor + 1, delimited) withVerbosity verbosity
   def currentChar = buffer(cursor)
   def currentArg = args.last
   def position =
@@ -41,8 +39,6 @@ class Parsed private (
 
   def isFirstDelimiter  = !isEmpty && isDelimiterChar(buffer.head)
   def isLastDelimiter   = !isEmpty && isDelimiterChar(buffer.last)
-  def firstIfDelimiter  = if (isFirstDelimiter) buffer.head.toString else ""
-  def lastIfDelimiter   = if (isLastDelimiter) buffer.last.toString else ""
 
   def isQuoted = false // TODO
   def isEscaped = !isAtStart && isEscapeChar(currentChar) && !isEscapeChar(prev.currentChar)
@@ -56,13 +52,9 @@ object Parsed {
 
   private def onull(s: String) = if (s == null) "" else s
 
-  def apply(s: String): Parsed = apply(onull(s), onull(s).length)
   def apply(s: String, cursor: Int): Parsed = apply(onull(s), cursor, DefaultDelimiters)
   def apply(s: String, cursor: Int, delimited: Char => Boolean): Parsed =
     new Parsed(onull(s), cursor, delimited)
 
-  def dotted(s: String): Parsed = dotted(onull(s), onull(s).length)
   def dotted(s: String, cursor: Int): Parsed = new Parsed(onull(s), cursor, _ == '.')
-
-  def undelimited(s: String, cursor: Int): Parsed = new Parsed(onull(s), cursor, _ => false)
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/Phased.scala b/src/compiler/scala/tools/nsc/interpreter/Phased.scala
index e6b780f177..f625124e70 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Phased.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Phased.scala
@@ -24,7 +24,6 @@ trait Phased {
     case NoPhaseName  => false
     case name         => active = name ; true
   }
-  def getMulti = multi
   def setMulti(phases: Seq[PhaseName]): Boolean = {
     if (phases contains NoPhaseName) false
     else {
@@ -66,16 +65,8 @@ trait Phased {
     try parseInternal(str)
     catch { case _: Exception => NoPhaseName }
 
-  def apply[T](body: => T) = immutable.SortedMap[PhaseName, T](atMap(PhaseName.all)(body): _*)
-
   def atCurrent[T](body: => T): T = enteringPhase(get)(body)
   def multi[T](body: => T): Seq[T] = multi map (ph => at(ph)(body))
-  def all[T](body: => T): Seq[T] = atMulti(PhaseName.all)(body)
-  def show[T](body: => T): Seq[T] = {
-    val pairs = atMap(PhaseName.all)(body)
-    pairs foreach { case (ph, op) => Console.println("%15s -> %s".format(ph, op.toString take 240)) }
-    pairs map (_._2)
-  }
 
   def at[T](ph: PhaseName)(body: => T): T = {
     val saved = get
@@ -90,11 +81,6 @@ trait Phased {
     finally setMulti(saved)
   }
 
-  def showAt[T](phs: Seq[PhaseName])(body: => T): Unit =
-    atMap[T](phs)(body) foreach {
-      case (ph, op) => Console.println("%15s -> %s".format(ph, op.toString take 240))
-    }
-
   def atMap[T](phs: Seq[PhaseName])(body: => T): Seq[(PhaseName, T)] =
     phs zip atMulti(phs)(body)
 
@@ -112,16 +98,12 @@ trait Phased {
 
     def apply(id: Int): PhaseName = all find (_.id == id) getOrElse NoPhaseName
     implicit def apply(s: String): PhaseName = nameMap(s)
-    implicit def defaultPhaseName: PhaseName = active
   }
   sealed abstract class PhaseName {
     lazy val id   = phase.id
     lazy val name = toString.toLowerCase
     def phase     = currentRun.phaseNamed(name)
     def isEmpty   = this eq NoPhaseName
-
-    // Execute some code during this phase.
-    def apply[T](body: => T): T = enteringPhase(phase)(body)
   }
 
   case object Parser extends PhaseName
@@ -158,5 +140,4 @@ trait Phased {
   }
 
   implicit def phaseEnumToPhase(name: PhaseName): Phase = name.phase
-  implicit def phaseNameToPhase(name: String): Phase = currentRun.phaseNamed(name)
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/Power.scala b/src/compiler/scala/tools/nsc/interpreter/Power.scala
index ab0f1c0033..e517a16b32 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Power.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Power.scala
@@ -149,17 +149,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
     // And whatever else there is to do.
     init.lines foreach (intp interpret _)
   }
-  def valsDescription: String = {
-    def to_str(m: Symbol) = "%12s %s".format(
-      m.decodedName, "" + elimRefinement(m.accessedOrSelf.tpe) stripPrefix "scala.tools.nsc.")
-
-    ( rutil.info[ReplValsImpl].membersDeclared
-        filter (m => m.isPublic && !m.hasModuleFlag && !m.isConstructor)
-        sortBy (_.decodedName)
-           map to_str
-      mkString ("Name and type of values imported into the repl in power mode.\n\n", "\n", "")
-    )
-  }
 
   trait LowPriorityInternalInfo {
     implicit def apply[T: ru.TypeTag : ClassTag] : InternalInfo[T] = new InternalInfo[T](None)
@@ -172,12 +161,7 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
    *  symbol, by only implicitly installing one method, "?", and the rest
    *  of the conveniences exist on that wrapper.
    */
-  trait LowPriorityInternalInfoWrapper {
-    implicit def apply[T: ru.TypeTag : ClassTag] : InternalInfoWrapper[T] = new InternalInfoWrapper[T](None)
-  }
-  object InternalInfoWrapper extends LowPriorityInternalInfoWrapper {
-
-  }
+  trait LowPriorityInternalInfoWrapper { }
   class InternalInfoWrapper[T: ru.TypeTag : ClassTag](value: Option[T] = None) {
     def ? : InternalInfo[T] = new InternalInfo[T](value)
   }
@@ -187,7 +171,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
    *    customizable symbol filter (had to hardcode no-spec to reduce noise)
    */
   class InternalInfo[T](value: Option[T] = None)(implicit typeEvidence: ru.TypeTag[T], runtimeClassEvidence: ClassTag[T]) {
-    private def newInfo[U: ru.TypeTag : ClassTag](value: U): InternalInfo[U] = new InternalInfo[U](Some(value))
     private def isSpecialized(s: Symbol) = s.name.toString contains "$mc"
     private def isImplClass(s: Symbol)   = s.name.toString endsWith "$class"
 
@@ -198,47 +181,15 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
       || s.isAnonOrRefinementClass
       || s.isAnonymousFunction
     )
-    def symbol      = compilerSymbolFromTag(tag)
-    def tpe         = compilerTypeFromTag(tag)
-    def name        = symbol.name
-    def companion   = symbol.companionSymbol
-    def info        = symbol.info
-    def moduleClass = symbol.moduleClass
-    def owner       = symbol.owner
-    def owners      = symbol.ownerChain drop 1
-    def signature   = symbol.defString
-
-    def decls         = info.decls
-    def declsOverride = membersDeclared filter (_.isOverride)
-    def declsOriginal = membersDeclared filterNot (_.isOverride)
-
+    def symbol            = compilerSymbolFromTag(tag)
+    def tpe               = compilerTypeFromTag(tag)
     def members           = membersUnabridged filterNot excludeMember
     def membersUnabridged = tpe.members.toList
-    def membersDeclared   = members filterNot excludeMember
-    def membersInherited  = members filterNot (membersDeclared contains _)
-    def memberTypes       = members filter (_.name.isTypeName)
-    def memberMethods     = members filter (_.isMethod)
-
-    def pkg             = symbol.enclosingPackage
-    def pkgName         = pkg.fullName
-    def pkgClass        = symbol.enclosingPackageClass
-    def pkgMembers      = pkg.info.members filterNot excludeMember
-    def pkgClasses      = pkgMembers filter (s => s.isClass && s.isDefinedInPackage)
-    def pkgSymbols      = new PackageSlurper(pkgClass).slurp() filterNot excludeMember
-
-    def tag            = typeEvidence
-    def runtimeClass   = runtimeClassEvidence.runtimeClass
-    def shortClass     = runtimeClass.getName split "[$.]" last
-
-    def baseClasses                    = tpe.baseClasses
-    def baseClassDecls                 = mapFrom(baseClasses)(_.info.decls.toList.sortBy(_.name))
-    def ancestors                      = baseClasses drop 1
-    def ancestorDeclares(name: String) = ancestors filter (_.info member newTermName(name) ne NoSymbol)
-    def baseTypes                      = tpe.baseTypeSeq.toList
-
-    def <:<[U: ru.TypeTag : ClassTag](other: U) = tpe <:< newInfo(other).tpe
-    def lub[U: ru.TypeTag : ClassTag](other: U) = intp.global.lub(List(tpe, newInfo(other).tpe))
-    def glb[U: ru.TypeTag : ClassTag](other: U) = intp.global.glb(List(tpe, newInfo(other).tpe))
+    def pkg               = symbol.enclosingPackage
+    def tag               = typeEvidence
+    def runtimeClass      = runtimeClassEvidence.runtimeClass
+    def shortClass        = runtimeClass.getName split "[$.]" last
+    def baseClasses       = tpe.baseClasses
 
     override def toString = value match {
       case Some(x)  => "%s (%s)".format(x, shortClass)
@@ -264,7 +215,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
   }
   object Prettifier extends LowPriorityPrettifier {
     def stringOf(x: Any): String = scala.runtime.ScalaRunTime.stringOf(x)
-    def prettify[T](value: T): TraversableOnce[String] = default[T] prettify value
     def default[T] = new Prettifier[T] {
       def prettify(x: T): TraversableOnce[String] = AnyPrettifier prettify x
       def show(x: T): Unit = AnyPrettifier show x
@@ -274,7 +224,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
     def show(x: T): Unit
     def prettify(x: T): TraversableOnce[String]
 
-    def show(xs: TraversableOnce[T]): Unit = prettify(xs) foreach println
     def prettify(xs: TraversableOnce[T]): TraversableOnce[String] = xs flatMap (x => prettify(x))
   }
 
@@ -286,31 +235,10 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
       pretty prettify f(value) foreach (StringPrettifier show _)
 
     def freq[U](p: T => U) = (value.toSeq groupBy p mapValues (_.size)).toList sortBy (-_._2) map (_.swap)
-    def ppfreq[U](p: T => U): Unit = freq(p) foreach { case (count, key) => println("%5d %s".format(count, key)) }
-
-    def |[U](f: Seq[T] => Seq[U]): Seq[U]        = f(value)
-    def ^^[U](f: T => U): Seq[U]                 = value map f
-    def ^?[U](pf: PartialFunction[T, U]): Seq[U] = value collect pf
 
-    def >>!(implicit ord: Ordering[T]): Unit     = pp(_.sorted.distinct)
     def >>(implicit ord: Ordering[T]): Unit      = pp(_.sorted)
     def >!(): Unit                               = pp(_.distinct)
     def >(): Unit                                = pp(identity)
-
-    def >#(): Unit                               = this ># (identity[T] _)
-    def >#[U](p: T => U): Unit                   = this ppfreq p
-
-    def >?(p: T => Boolean): Unit                = pp(_ filter p)
-    def >?(s: String): Unit                      = pp(_ filter (_.toString contains s))
-    def >?(r: Regex): Unit                       = pp(_ filter (_.toString matches fixRegex(r)))
-
-    private def fixRegex(r: scala.util.matching.Regex): String = {
-      val s = r.pattern.toString
-      val prefix = if (s startsWith "^") "" else """^.*?"""
-      val suffix = if (s endsWith "$") "" else """.*$"""
-
-      prefix + s + suffix
-    }
   }
 
   class MultiPrettifierClass[T: Prettifier](val value: Seq[T]) extends PrettifierClass[T]() { }
@@ -334,17 +262,11 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
   class RichReplURL(url: URL)(implicit codec: Codec) {
     def slurp(): String = io.Streamable.slurp(url)
   }
-  class RichSymbolList(syms: List[Symbol]) {
-    def sigs  = syms map (_.defString)
-    def infos = syms map (_.info)
-  }
 
   trait Implicits1 {
     // fallback
     implicit def replPrinting[T](x: T)(implicit pretty: Prettifier[T] = Prettifier.default[T]) =
       new SinglePrettifierClass[T](x)
-
-    implicit def liftToTypeName(s: String): TypeName = newTypeName(s)
   }
   trait Implicits2 extends Implicits1 {
     class RichSymbol(sym: Symbol) {
@@ -369,26 +291,13 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
 
     implicit def replInputStream(in: InputStream)(implicit codec: Codec) = new RichInputStream(in)
     implicit def replEnhancedURLs(url: URL)(implicit codec: Codec): RichReplURL = new RichReplURL(url)(codec)
-
-    implicit def liftToTermName(s: String): TermName = newTermName(s)
-    implicit def replListOfSymbols(xs: List[Symbol]) = new RichSymbolList(xs)
   }
 
   trait ReplUtilities {
-    // [Eugene to Paul] needs review!
-    // def module[T: Manifest] = getModuleIfDefined(manifest[T].erasure.getName stripSuffix nme.MODULE_SUFFIX_STRING)
-    // def clazz[T: Manifest] = getClassIfDefined(manifest[T].erasure.getName)
     def module[T: ru.TypeTag] = ru.typeOf[T].typeSymbol.suchThat(_.isPackage)
     def clazz[T: ru.TypeTag] = ru.typeOf[T].typeSymbol.suchThat(_.isClass)
     def info[T: ru.TypeTag : ClassTag] = InternalInfo[T]
     def ?[T: ru.TypeTag : ClassTag] = InternalInfo[T]
-    def url(s: String) = {
-      try new URL(s)
-      catch { case _: MalformedURLException =>
-        if (Path(s).exists) Path(s).toURL
-        else new URL("http://" + s)
-      }
-    }
     def sanitize(s: String): String = sanitize(s.getBytes())
     def sanitize(s: Array[Byte]): String = (s map {
       case x if x.toChar.isControl  => '?'
@@ -406,11 +315,8 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
   lazy val rutil: ReplUtilities = new ReplUtilities { }
   lazy val phased: Phased       = new { val global: intp.global.type = intp.global } with Phased { }
 
-  def context(code: String) = analyzer.rootContext(unit(code))
-  def source(code: String)  = newSourceFile(code)
   def unit(code: String)    = newCompilationUnit(code)
   def trees(code: String)   = parse(code) getOrElse Nil
-  def typeOf(id: String)    = intp.typeOfExpression(id)
 
   override def toString = s"""
     |** Power mode status **
diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplConfig.scala b/src/compiler/scala/tools/nsc/interpreter/ReplConfig.scala
index 7cd0f436c4..3392ea0b5e 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ReplConfig.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ReplConfig.scala
@@ -14,9 +14,7 @@ trait ReplConfig {
   lazy val replProps = new ReplProps
 
   class TapMaker[T](x: T) {
-    def tapInfo(msg: => String): T  = tap(x => replinfo(parens(x)))
     def tapDebug(msg: => String): T = tap(x => repldbg(parens(x)))
-    def tapTrace(msg: => String): T = tap(x => repltrace(parens(x)))
     def tap[U](f: T => U): T = {
       f(x)
       x
@@ -28,12 +26,6 @@ trait ReplConfig {
     try Console println msg
     catch { case x: AssertionError => Console.println("Assertion error printing debugging output: " + x) }
 
-  private[nsc] def repldbgex(ex: Throwable): Unit = {
-    if (isReplDebug) {
-      echo("Caught/suppressing: " + ex)
-      ex.printStackTrace
-    }
-  }
   private[nsc] def repldbg(msg: => String)    = if (isReplDebug) echo(msg)
   private[nsc] def repltrace(msg: => String)  = if (isReplTrace) echo(msg)
   private[nsc] def replinfo(msg: => String)   = if (isReplInfo)  echo(msg)
@@ -45,14 +37,10 @@ trait ReplConfig {
       repltrace(stackTraceString(unwrap(t)))
       alt
   }
-  private[nsc] def substituteAndLog[T](alt: => T)(body: => T): T =
-    substituteAndLog("" + alt, alt)(body)
   private[nsc] def substituteAndLog[T](label: String, alt: => T)(body: => T): T = {
     try body
     catch logAndDiscard(label, alt)
   }
-  private[nsc] def squashAndLog(label: String)(body: => Unit): Unit =
-    substituteAndLog(label, ())(body)
 
   def isReplTrace: Boolean = replProps.trace
   def isReplDebug: Boolean = replProps.debug || isReplTrace
diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala b/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala
index bc3e7a10d7..2364918494 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala
@@ -13,15 +13,11 @@ class ReplProps {
   private def bool(name: String) = BooleanProp.keyExists(name)
   private def int(name: String) = IntProp(name)
 
-  val jlineDebug = bool("scala.tools.jline.internal.Log.debug")
-  val jlineTrace = bool("scala.tools.jline.internal.Log.trace")
-
   val info  = bool("scala.repl.info")
   val debug = bool("scala.repl.debug")
   val trace = bool("scala.repl.trace")
   val power = bool("scala.repl.power")
 
-  val replInitCode    = Prop[JFile]("scala.repl.initcode")
   val replAutorunCode = Prop[JFile]("scala.repl.autoruncode")
   val powerInitCode   = Prop[JFile]("scala.repl.power.initcode")
   val powerBanner     = Prop[JFile]("scala.repl.power.banner")
diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala b/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala
index 670bbf9bae..08472bbc64 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala
@@ -29,5 +29,4 @@ trait ReplStrings {
     "scala.runtime.ScalaRunTime.replStringOf(%s, %s)".format(x, maxlen)
 
   def words(s: String) = s.trim split "\\s+" filterNot (_ == "") toList
-  def isQuoted(s: String) = (s.length >= 2) && (s.head == s.last) && ("\"'" contains s.head)
 }
diff --git a/src/compiler/scala/tools/nsc/interpreter/RichClass.scala b/src/compiler/scala/tools/nsc/interpreter/RichClass.scala
index 4371f7fe05..36cdf65510 100644
--- a/src/compiler/scala/tools/nsc/interpreter/RichClass.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/RichClass.scala
@@ -10,7 +10,6 @@ import scala.reflect.{ ClassTag, classTag }
 
 class RichClass[T](val clazz: Class[T]) {
   def toTag: ClassTag[T] = ClassTag[T](clazz)
-  def toTypeString: String = TypeStrings.fromClazz(clazz)
 
   // Sadly isAnonymousClass does not return true for scala anonymous
   // classes because our naming scheme is not doing well against the
@@ -20,14 +19,12 @@ class RichClass[T](val clazz: Class[T]) {
     catch { case _: java.lang.InternalError => false }  // good ol' "Malformed class name"
   )
 
-  /** It's not easy... to be... me... */
-  def supermans: List[ClassTag[_]] = supers map (_.toTag)
+  def supertags: List[ClassTag[_]] = supers map (_.toTag)
   def superNames: List[String]    = supers map (_.getName)
   def interfaces: List[JClass]    = supers filter (_.isInterface)
 
   def hasAncestorName(f: String => Boolean) = superNames exists f
   def hasAncestor(f: JClass => Boolean) = supers exists f
-  def hasAncestorInPackage(pkg: String) = hasAncestorName(_ startsWith (pkg + "."))
 
   def supers: List[JClass] = {
     def loop(x: JClass): List[JClass] = x.getSuperclass match {
diff --git a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala
index bccd8158ec..2d0917d91f 100644
--- a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala
@@ -19,11 +19,8 @@ extends InteractiveReader
   val history = NoHistory
   val completion = NoCompletion
 
-  def init() = ()
   def reset() = ()
-  def eraseLine() = ()
   def redrawLine() = ()
-  def currentLine = ""
   def readOneLine(prompt: String): String = {
     if (interactive) {
       out.print(prompt)
@@ -40,4 +37,4 @@ object SimpleReader {
 
   def apply(in: BufferedReader = defaultIn, out: JPrintWriter = defaultOut, interactive: Boolean = true): SimpleReader =
     new SimpleReader(in, out, interactive)
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
index 9fb79a9d6f..239dbb8149 100644
--- a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
@@ -33,7 +33,6 @@ trait StructuredTypeStrings extends DestructureTypes {
   val NoGrouping      = Grouping("", "", "", false)
   val ListGrouping    = Grouping("(", ", ", ")", false)
   val ProductGrouping = Grouping("(", ", ", ")", true)
-  val ParamGrouping   = Grouping("(", ", ", ")", true)
   val BlockGrouping   = Grouping(" { ", "; ", "}", false)
 
   private def str(level: Int)(body: => String): String = "  " * level + body
@@ -189,7 +188,6 @@ trait TypeStrings {
       else enclClass.getName + "." + (name stripPrefix enclPre)
     )
   }
-  def scalaName(ct: ClassTag[_]): String = scalaName(ct.runtimeClass)
   def anyClass(x: Any): JClass          = if (x == null) null else x.getClass
 
   private def brackets(tps: String*): String =
@@ -220,7 +218,6 @@ trait TypeStrings {
    *  practice to rely on toString for correctness) generated the VALID string
    *  representation of the type.
    */
-  def fromTypedValue[T: ru.TypeTag : ClassTag](x: T): String = fromTag[T]
   def fromValue(value: Any): String                          = if (value == null) "Null" else fromClazz(anyClass(value))
   def fromClazz(clazz: JClass): String                       = scalaName(clazz) + tparamString(clazz)
   def fromTag[T: ru.TypeTag : ClassTag] : String             = scalaName(classTag[T].runtimeClass) + tparamString[T]
@@ -240,13 +237,6 @@ trait TypeStrings {
       case (res, (k, v)) => res.replaceAll(k, v)
     }
   }
-
-  val typeTransforms = List(
-    "java.lang." -> "",
-    "scala.collection.immutable." -> "immutable.",
-    "scala.collection.mutable." -> "mutable.",
-    "scala.collection.generic." -> "generic."
-  )
 }
 
 object TypeStrings extends TypeStrings { }
diff --git a/src/compiler/scala/tools/nsc/interpreter/package.scala b/src/compiler/scala/tools/nsc/interpreter/package.scala
index 6a2d69db2c..52a085080b 100644
--- a/src/compiler/scala/tools/nsc/interpreter/package.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/package.scala
@@ -48,7 +48,6 @@ package object interpreter extends ReplConfig with ReplStrings {
 
   private[nsc] implicit def enrichClass[T](clazz: Class[T]) = new RichClass[T](clazz)
   private[nsc] implicit def enrichAnyRefWithTap[T](x: T) = new TapMaker(x)
-  private[nsc] def tracing[T](msg: String)(x: T): T = x.tapTrace(msg)
   private[nsc] def debugging[T](msg: String)(x: T) = x.tapDebug(msg)
 
   private val ourClassloader = getClass.getClassLoader
@@ -68,39 +67,11 @@ package object interpreter extends ReplConfig with ReplStrings {
     import global.{ reporter => _, _ }
     import definitions._
 
-    lazy val tagOfStdReplVals = staticTypeTag[scala.tools.nsc.interpreter.StdReplVals]
-
     protected def echo(msg: String) = {
       Console.out println msg
       Console.out.flush()
     }
 
-    def wrapCommand(line: String): String = {
-      def failMsg = "Argument to :wrap must be the name of a method with signature [T](=> T): T"
-
-      words(line) match {
-        case Nil            =>
-          intp.executionWrapper match {
-            case ""   => "No execution wrapper is set."
-            case s    => "Current execution wrapper: " + s
-          }
-        case "clear" :: Nil =>
-          intp.executionWrapper match {
-            case ""   => "No execution wrapper is set."
-            case s    => intp.clearExecutionWrapper() ; "Cleared execution wrapper."
-          }
-        case wrapper :: Nil =>
-          intp.typeOfExpression(wrapper) match {
-            case PolyType(List(targ), MethodType(List(arg), restpe)) =>
-              setExecutionWrapper(originalPath(wrapper))
-              "Set wrapper to '" + wrapper + "'"
-            case tp =>
-              failMsg + "\nFound: <unknown>"
-          }
-        case _ => failMsg
-      }
-    }
-
     def implicitsCommand(line: String): String = {
       def p(x: Any) = intp.reporter.printMessage("" + x)
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/session/History.scala b/src/compiler/scala/tools/nsc/interpreter/session/History.scala
index daa05b86db..794d41adc7 100644
--- a/src/compiler/scala/tools/nsc/interpreter/session/History.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/session/History.scala
@@ -14,15 +14,9 @@ trait History {
   def asStrings: List[String]
   def index: Int
   def size: Int
-  def grep(s: String): List[String]
 }
 object NoHistory extends History {
   def asStrings       = Nil
-  def grep(s: String) = Nil
   def index           = 0
   def size            = 0
 }
-
-object History {
-  def empty: History = NoHistory
-}
diff --git a/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala b/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala
index 9f4e2b9df3..89998e438a 100644
--- a/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala
@@ -54,9 +54,5 @@ class SimpleHistory extends JLineHistory {
   def moveTo(idx: Int)  = (idx > 0) && (idx <= lastIndex) && setTo(idx)
   def moveToEnd(): Unit = setTo(size)
 
-  // scala legacy interface
-  def asList: List[JEntry] = toEntries().toList
-  def asJavaList           = entries()
-  def asStrings            = buf.toList
-  def grep(s: String)      = buf.toList filter (_ contains s)
+  def asStrings = buf.toList
 }