diff --git a/build.sbt b/build.sbt
index a27722235ee1..c2c5fda85b36 100644
--- a/build.sbt
+++ b/build.sbt
@@ -18,6 +18,7 @@ val `dotty-bench-bootstrapped` = Build.`dotty-bench-bootstrapped`
 val `scala-library` = Build.`scala-library`
 val `scala-compiler` = Build.`scala-compiler`
 val `scala-reflect` = Build.`scala-reflect`
+val `dotty-repl` = Build.`dotty-repl`
 val scalap = Build.scalap
 val dist = Build.dist
 val `dist-bootstrapped` = Build.`dist-bootstrapped`
diff --git a/compiler/src/dotty/tools/dotc/Bench.scala b/compiler/src/dotty/tools/dotc/Bench.scala
index 56b6dabbe4ca..ee7789c32f9f 100644
--- a/compiler/src/dotty/tools/dotc/Bench.scala
+++ b/compiler/src/dotty/tools/dotc/Bench.scala
@@ -16,8 +16,6 @@ object Bench extends Driver {
 
   @sharable private var numRuns = 1
 
-  def newCompiler(implicit ctx: Context): Compiler = new Compiler
-
   private def ntimes(n: Int)(op: => Reporter): Reporter =
     (emptyReporter /: (0 until n)) ((_, _) => op)
 
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 84d49502dc54..a6555cdcd50e 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -116,34 +116,6 @@ class Compiler {
     runId += 1; runId
   }
 
-  /** Produces the following contexts, from outermost to innermost
-   *
-   *    bootStrap:   A context with next available runId and a scope consisting of
-   *                 the RootPackage _root_
-   *    start        A context with RootClass as owner and the necessary initializations
-   *                 for type checking.
-   *    imports      For each element of RootImports, an import context
-   */
-  def rootContext(implicit ctx: Context): Context = {
-    ctx.initialize()(ctx)
-    ctx.setPhasePlan(phases)
-    val rootScope = new MutableScope
-    val bootstrap = ctx.fresh
-      .setPeriod(Period(nextRunId, FirstPhaseId))
-      .setScope(rootScope)
-    rootScope.enter(ctx.definitions.RootPackage)(bootstrap)
-    val start = bootstrap.fresh
-      .setOwner(defn.RootClass)
-      .setTyper(new Typer)
-      .addMode(Mode.ImplicitsEnabled)
-      .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
-      .setFreshNames(new FreshNameCreator.Default)
-    ctx.initialize()(start) // re-initialize the base context with start
-    def addImport(ctx: Context, refFn: () => TermRef) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
-    (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
-  }
-
   def reset()(implicit ctx: Context): Unit = {
     ctx.base.reset()
     ctx.runInfo.clear()
@@ -151,6 +123,6 @@ class Compiler {
 
   def newRun(implicit ctx: Context): Run = {
     reset()
-    new Run(this)(rootContext)
+    new Run(this, ctx)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/compiler/src/dotty/tools/dotc/Driver.scala
index f54a23ad2451..8e2c1910dcd6 100644
--- a/compiler/src/dotty/tools/dotc/Driver.scala
+++ b/compiler/src/dotty/tools/dotc/Driver.scala
@@ -13,9 +13,9 @@ import scala.util.control.NonFatal
  *  process, but in most cases you only need to call [[process]] on the
  *  existing object [[Main]].
  */
-abstract class Driver extends DotClass {
+class Driver extends DotClass {
 
-  protected def newCompiler(implicit ctx: Context): Compiler
+  protected def newCompiler(implicit ctx: Context): Compiler = new Compiler
 
   protected def emptyReporter: Reporter = new StoreReporter(null)
 
diff --git a/compiler/src/dotty/tools/dotc/FromTasty.scala b/compiler/src/dotty/tools/dotc/FromTasty.scala
index 6f74a5d46ea2..2cb0aa79456a 100644
--- a/compiler/src/dotty/tools/dotc/FromTasty.scala
+++ b/compiler/src/dotty/tools/dotc/FromTasty.scala
@@ -45,11 +45,11 @@ object FromTasty extends Driver {
 
     override def newRun(implicit ctx: Context): Run = {
       reset()
-      new TASTYRun(this)(rootContext)
+      new TASTYRun(this, ctx)
     }
   }
 
-  class TASTYRun(comp: Compiler)(implicit ctx: Context) extends Run(comp) {
+  class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
     override def compile(classNames: List[String]) = {
       units = classNames.map(new TASTYCompilationUnit(_))
       compileUnits()
diff --git a/compiler/src/dotty/tools/dotc/Main.scala b/compiler/src/dotty/tools/dotc/Main.scala
index a6844fbbc4c0..5ba3f35b0cc9 100644
--- a/compiler/src/dotty/tools/dotc/Main.scala
+++ b/compiler/src/dotty/tools/dotc/Main.scala
@@ -4,6 +4,4 @@ package dotc
 import core.Contexts.Context
 
 /** Main class of the `dotc` batch compiler. */
-object Main extends Driver {
-  override def newCompiler(implicit ctx: Context): Compiler = new Compiler
-}
+object Main extends Driver
diff --git a/compiler/src/dotty/tools/dotc/Resident.scala b/compiler/src/dotty/tools/dotc/Resident.scala
index 56f6684d0964..7f6c288cc892 100644
--- a/compiler/src/dotty/tools/dotc/Resident.scala
+++ b/compiler/src/dotty/tools/dotc/Resident.scala
@@ -27,8 +27,6 @@ class Resident extends Driver {
 
   object residentCompiler extends Compiler
 
-  override def newCompiler(implicit ctx: Context): Compiler = ???
-
   override def sourcesRequired = false
 
   private val quit = ":q"
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index e9ec9dd3d96b..f8e7967e89d8 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -6,6 +6,9 @@ import Contexts._
 import Periods._
 import Symbols._
 import Phases._
+import Types._
+import Scopes._
+import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import Decorators._
 import dotty.tools.dotc.transform.TreeTransforms.TreeTransformer
 import io.PlainFile
@@ -22,12 +25,41 @@ import dotty.tools.io.VirtualFile
 import scala.util.control.NonFatal
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler)(implicit ctx: Context) {
-
-  assert(ctx.runId <= Periods.MaxPossibleRunId)
+class Run(comp: Compiler, ictx: Context) {
 
   var units: List[CompilationUnit] = _
 
+  /** Produces the following contexts, from outermost to innermost
+   *
+   *    bootStrap:   A context with next available runId and a scope consisting of
+   *                 the RootPackage _root_
+   *    start        A context with RootClass as owner and the necessary initializations
+   *                 for type checking.
+   *    imports      For each element of RootImports, an import context
+   */
+  protected[this] def rootContext(implicit ctx: Context): Context = {
+    ctx.initialize()(ctx)
+    ctx.setPhasePlan(comp.phases)
+    val rootScope = new MutableScope
+    val bootstrap = ctx.fresh
+      .setPeriod(Period(comp.nextRunId, FirstPhaseId))
+      .setScope(rootScope)
+    rootScope.enter(ctx.definitions.RootPackage)(bootstrap)
+    val start = bootstrap.fresh
+      .setOwner(defn.RootClass)
+      .setTyper(new Typer)
+      .addMode(Mode.ImplicitsEnabled)
+      .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
+      .setFreshNames(new FreshNameCreator.Default)
+    ctx.initialize()(start) // re-initialize the base context with start
+    def addImport(ctx: Context, refFn: () => TermRef) =
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
+    (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
+  }
+
+  protected[this] implicit val ctx: Context = rootContext(ictx)
+  assert(ctx.runId <= Periods.MaxPossibleRunId)
+
   def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(fileName)
     if (f.isDirectory) {
@@ -63,7 +95,17 @@ class Run(comp: Compiler)(implicit ctx: Context) {
       compileUnits()
     }
 
-  protected def compileUnits() = Stats.monitorHeartBeat {
+  def compileUnits(us: List[CompilationUnit]): Unit = {
+    units = us
+    compileUnits()
+  }
+
+  def compileUnits(us: List[CompilationUnit], ctx: Context): Unit = {
+    units = us
+    compileUnits()(ctx)
+  }
+
+  protected def compileUnits()(implicit ctx: Context) = Stats.monitorHeartBeat {
     ctx.checkSingleThreaded()
 
     // If testing pickler, make sure to stop after pickling phase:
@@ -76,7 +118,7 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (!ctx.reporter.hasErrors) {
+      if (phase.isRunnable) {
         val start = System.currentTimeMillis
         units = phase.runOn(units)
         if (ctx.settings.Xprint.value.containsPhase(phase)) {
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 62d8d57f6f47..561ee6a00746 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -251,7 +251,7 @@ class Definitions {
     lazy val Any_getClass = enterMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.empty)), Final)
     lazy val Any_isInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     lazy val Any_asInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, TypeParamRef(_, 0), Final)
-    lazy val Any_typeTest = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final)
+    lazy val Any_typeTest = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic)
       // generated by pattern matcher, eliminated by erasure
 
     def AnyMethods = List(Any_==, Any_!=, Any_equals, Any_hashCode,
@@ -863,8 +863,8 @@ class Definitions {
   )
 
   val PredefImportFns = List[() => TermRef](
-      () => ScalaPredefModuleRef,
-      () => DottyPredefModuleRef
+    () => ScalaPredefModuleRef,
+    () => DottyPredefModuleRef
   )
 
   lazy val RootImportFns =
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index bb50c1928895..3377ef0bda23 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -64,7 +64,8 @@ object NameOps {
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
     def isStaticConstructorName = name == STATIC_CONSTRUCTOR
     def isLocalDummyName = name startsWith str.LOCALDUMMY_PREFIX
-    def isReplWrapperName = name.toString contains str.INTERPRETER_IMPORT_WRAPPER
+    def isReplWrapperName = name.toString contains str.REPL_SESSION_LINE
+    def isReplAssignName = name.toString contains str.REPL_ASSIGN_SUFFIX
     def isSetterName = name endsWith str.SETTER_SUFFIX
     def isScala2LocalSuffix = testSimple(_.endsWith(" "))
     def isSelectorName = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index 409827f39ad6..0312f94f4533 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -272,11 +272,16 @@ object Phases {
      */
     def phaseName: String
 
+    def isRunnable(implicit ctx: Context): Boolean =
+      !ctx.reporter.hasErrors
+
     /** List of names of phases that should precede this phase */
     def runsAfter: Set[Class[_ <: Phase]] = Set.empty
 
+    /** @pre `isRunnable` returns true */
     def run(implicit ctx: Context): Unit
 
+    /** @pre `isRunnable` returns true */
     def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
       units.map { unit =>
         val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 3d90d7f4a220..312ebcf1b5f7 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -30,10 +30,10 @@ object StdNames {
     final val ANON_CLASS               = "$anon"
     final val ANON_FUN                 = "$anonfun"
 
-    final val INTERPRETER_IMPORT_WRAPPER = "$iw"
-    final val INTERPRETER_LINE_PREFIX    = "line"
-    final val INTERPRETER_VAR_PREFIX     = "res"
-    final val INTERPRETER_WRAPPER_SUFFIX = "$object"
+    final val REPL_SESSION_LINE  = "rs$line$"
+    final val REPL_ASSIGN_SUFFIX = "$assign"
+    final val REPL_RES_PREFIX    = "res"
+
     final val MODULE_INSTANCE_FIELD      = "MODULE$"
 
     final val Function                   = "Function"
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index ce738357ea39..473ae32f9dc1 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1994,7 +1994,9 @@ object SymDenotations {
     }
 
     def isValidAt(phase: Phase)(implicit ctx: Context) =
-      createdAt.runId == ctx.runId && sameGroup(ctx.phases(createdAt.phaseId), phase)
+      createdAt.runId == ctx.runId &&
+      createdAt.phaseId < ctx.phases.length &&
+      sameGroup(ctx.phases(createdAt.phaseId), phase)
   }
 
   private class InvalidCache extends InheritedCache {
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 724363be41d4..32ce37b10a9f 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -154,6 +154,14 @@ object Types {
         false
     }
 
+    def isInfixType(implicit ctx: Context): Boolean = this match {
+      case TypeApplications.AppliedType(tycon, args) =>
+        args.length == 2 &&
+          !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
+          // TODO: Once we use the 2.12 stdlib, also check the @showAsInfix annotation
+      case _ => false
+    }
+
     /** Does this type refer exactly to class symbol `sym`, instead of to a subclass of `sym`?
      *  Implemented like `isRef`, but follows more types: all type proxies as well as and- and or-types
      */
diff --git a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
index 4284da2967a9..fc6def3190ee 100644
--- a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
@@ -65,35 +65,51 @@ object Interactive {
   private def safely[T](op: => List[T]): List[T] =
     try op catch { case ex: TypeError => Nil }
 
-  /** Possible completions at position `pos` */
-  def completions(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): List[Symbol] = {
+  /** Get possible completions from tree at `pos`
+   *
+   *  @return offset and list of symbols for possible completions
+   */
+  def completions(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): (Int, List[Symbol]) = {
     val path = pathTo(trees, pos)
     val boundary = enclosingDefinitionInPath(path).symbol
 
-    path.take(1).flatMap {
-      case Select(qual, _) =>
+    // FIXME: Get all declarations available in the current scope, not just
+    // those from the enclosing class
+    def scopeCompletions: List[Symbol] =
+      boundary.enclosingClass match {
+        case csym: ClassSymbol =>
+          val classRef = csym.classInfo.typeRef
+          completions(classRef, boundary)
+        case _ =>
+          Nil
+      }
+
+    path.headOption.map {
+      case sel @ Select(qual, name) =>
         // When completing "`a.foo`, return the members of `a`
-        completions(qual.tpe, boundary)
+        (sel.pos.point, completions(qual.tpe, boundary))
+      case id @ Ident(name) =>
+        (id.pos.point, scopeCompletions)
       case _ =>
-        // FIXME: Get all declarations available in the current scope, not just
-        // those from the enclosing class
-        boundary.enclosingClass match {
-          case csym: ClassSymbol =>
-            val classRef = csym.classInfo.typeRef
-            completions(classRef, boundary)
-          case _ =>
-            Nil
-        }
+        (0, scopeCompletions)
     }
+    .getOrElse((0, Nil))
   }
 
   /** Possible completions of members of `prefix` which are accessible when called inside `boundary` */
   def completions(prefix: Type, boundary: Symbol)(implicit ctx: Context): List[Symbol] =
     safely {
-      val boundaryCtx = ctx.withOwner(boundary)
-      prefix.memberDenots(completionsFilter, (name, buf) =>
-        buf ++= prefix.member(name).altsWith(d => !d.isAbsent && d.symbol.isAccessibleFrom(prefix)(boundaryCtx))
-      ).map(_.symbol).toList
+      if (boundary != NoSymbol) {
+        val boundaryCtx = ctx.withOwner(boundary)
+        prefix.memberDenots(completionsFilter, (name, buf) =>
+          buf ++= prefix.member(name).altsWith{ d =>
+            !d.isAbsent &&
+            !d.is(Synthetic) && !d.is(Artifact) &&
+            d.symbol.isAccessibleFrom(prefix)(boundaryCtx)
+          }
+        ).map(_.symbol).toList
+      }
+      else Nil
     }
 
   /** Filter for names that should appear when looking for completions. */
diff --git a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
index a27db1d5d5db..14ab4046d702 100644
--- a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
@@ -28,8 +28,6 @@ class InteractiveDriver(settings: List[String]) extends Driver {
   import tpd._
   import InteractiveDriver._
 
-  // FIXME: Change the Driver API to not require implementing this method
-  override protected def newCompiler(implicit ctx: Context): Compiler = ???
   override def sourcesRequired = false
 
   private val myInitCtx: Context = {
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index c494110201e4..f5e99390f1df 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -125,14 +125,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         ("implicit " provided isImplicit) ~ argStr ~ " => " ~ argText(args.last)
       }
 
-    def isInfixType(tp: Type): Boolean = tp match {
-      case AppliedType(tycon, args) =>
-        args.length == 2 &&
-          !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
-          // TODO: Once we use the 2.12 stdlib, also check the @showAsInfix annotation
-      case _ =>
-        false
-    }
     def toTextInfixType(op: Type, args: List[Type]): Text = {
       /* SLS 3.2.8: all infix types have the same precedence.
        * In A op B op' C, op and op' need the same associativity.
@@ -140,8 +132,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
        * needs to be parenthesized if it's an infix type, and vice versa. */
       val l :: r :: Nil = args
       val isRightAssoc = op.typeSymbol.name.endsWith(":")
-      val leftArg = if (isRightAssoc && isInfixType(l)) "(" ~ toText(l) ~ ")" else toText(l)
-      val rightArg = if (!isRightAssoc && isInfixType(r)) "(" ~ toText(r) ~ ")" else toText(r)
+      val leftArg = if (isRightAssoc && l.isInfixType) "(" ~ toText(l) ~ ")" else toText(l)
+      val rightArg = if (!isRightAssoc && r.isInfixType) "(" ~ toText(r) ~ ")" else toText(r)
 
       leftArg ~ " " ~ toTextLocal(op) ~ " " ~ rightArg
     }
@@ -154,7 +146,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
         if (defn.isFunctionClass(cls)) return toTextFunction(args, cls.name.isImplicitFunction)
         if (defn.isTupleClass(cls)) return toTextTuple(args)
-        if (isInfixType(tp)) return toTextInfixType(tycon, args)
+        if (tp.isInfixType) return toTextInfixType(tycon, args)
       case EtaExpansion(tycon) =>
         return toText(tycon)
       case tp: TypeRef =>
diff --git a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
index eb88cb64f766..759b4d9cfc8e 100644
--- a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
@@ -76,7 +76,7 @@ object SyntaxHighlighting {
           if (remaining.nonEmpty) takeChar() // drop 1 for appendLiteral
           appendString('"', next == "\"\"\"")
         } else {
-          if (n.isUpper && keywordStart) {
+          if (n.isUpper && (keywordStart || prev == '.')) {
             appendWhile(n, !typeEnders.contains(_), typeDef)
           } else if (keywordStart) {
             append(n, keywords.contains(_), { kw =>
@@ -125,7 +125,8 @@ object SyntaxHighlighting {
               takeChars(2)
               newBuf append tripleQs
               prev = '?'
-            } else if (n.isUpper && keywordStart)
+            }
+            else if (n.isUpper && keywordStart)
               appendWhile(n, !typeEnders.contains(_), typeDef)
             else if (numberStart(n))
               appendWhile(n, { x => x.isDigit || x == '.' || x == '\u0000'}, literal)
@@ -281,6 +282,7 @@ object SyntaxHighlighting {
         case '[' => true
         case ':' => true
         case '@' => true
+        case '.' => true
         case _ => false
       }
 
diff --git a/compiler/src/dotty/tools/dotc/repl/AmmoniteReader.scala b/compiler/src/dotty/tools/dotc/repl/AmmoniteReader.scala
deleted file mode 100644
index f3b68e4b039d..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/AmmoniteReader.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import core.Contexts._
-import ammonite.terminal._
-import LazyList._
-import Ansi.Color
-import filters._
-import BasicFilters._
-import GUILikeFilters._
-import util.SourceFile
-import printing.SyntaxHighlighting
-
-class AmmoniteReader(val interpreter: Interpreter)(implicit ctx: Context) extends InteractiveReader {
-  val interactive = true
-
-  def incompleteInput(str: String): Boolean =
-    interpreter.delayOutputDuring(interpreter.interpret(str)) match {
-      case Interpreter.Incomplete => true
-      case _ => false
-    }
-
-  val reader = new java.io.InputStreamReader(System.in)
-  val writer = new java.io.OutputStreamWriter(System.out)
-  val cutPasteFilter = ReadlineFilters.CutPasteFilter()
-  var history = List.empty[String]
-  val selectionFilter = GUILikeFilters.SelectionFilter(indent = 2)
-  val multilineFilter: Filter = Filter("multilineFilter") {
-    case TermState(lb ~: rest, b, c, _)
-    if (lb == 10 || lb == 13) && incompleteInput(b.mkString) =>
-      BasicFilters.injectNewLine(b, c, rest, indent = 2)
-  }
-
-  def readLine(prompt: String): String = {
-    val historyFilter = new HistoryFilter(
-      () => history.toVector,
-      Console.BLUE,
-      AnsiNav.resetForegroundColor
-    )
-
-    val allFilters = Filter.merge(
-      UndoFilter(),
-      historyFilter,
-      selectionFilter,
-      GUILikeFilters.altFilter,
-      GUILikeFilters.fnFilter,
-      ReadlineFilters.navFilter,
-      cutPasteFilter,
-      multilineFilter,
-      BasicFilters.all
-    )
-
-    Terminal.readLine(
-      Console.BLUE + prompt + Console.RESET,
-      reader,
-      writer,
-      allFilters,
-      displayTransform = (buffer, cursor) => {
-        val coloredBuffer =
-          if (ctx.useColors) SyntaxHighlighting(buffer)
-          else buffer
-
-        val ansiBuffer = Ansi.Str.parse(coloredBuffer.toVector)
-        val (newBuffer, cursorOffset) = SelectionFilter.mangleBuffer(
-          selectionFilter, ansiBuffer, cursor, Ansi.Reversed.On
-        )
-        val newNewBuffer = HistoryFilter.mangleBuffer(
-          historyFilter, newBuffer, cursor,
-          Ansi.Color.Green
-        )
-
-        (newNewBuffer, cursorOffset)
-      }
-    ) match {
-      case Some(res) =>
-        history = res :: history;
-        res
-      case None => ":q"
-    }
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/CompilingInterpreter.scala b/compiler/src/dotty/tools/dotc/repl/CompilingInterpreter.scala
deleted file mode 100644
index 85f47692f4fa..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/CompilingInterpreter.scala
+++ /dev/null
@@ -1,1024 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import java.io.{
-  File, PrintWriter, PrintStream, StringWriter, Writer, OutputStream,
-  ByteArrayOutputStream => ByteOutputStream
-}
-import java.lang.{Class, ClassLoader, Thread, System, StringBuffer}
-import java.net.{URL, URLClassLoader}
-
-import scala.collection.immutable.ListSet
-import scala.collection.mutable
-import scala.collection.mutable.{ListBuffer, HashSet, ArrayBuffer}
-
-//import ast.parser.SyntaxAnalyzer
-import io.{PlainFile, VirtualDirectory}
-import dotty.tools.io.{PlainDirectory, Directory}
-import reporting.{ConsoleReporter, Reporter}
-import core.Flags
-import util.{SourceFile, NameTransformer}
-import io.ClassPath
-import ast.Trees._
-import parsing.Parsers._
-import core._
-import dotty.tools.backend.jvm.GenBCode
-import Symbols._, Types._, Contexts._, StdNames._, Names._, NameOps._
-import Decorators._
-import scala.util.control.NonFatal
-import printing.SyntaxHighlighting
-
-/** An interpreter for Scala code which is based on the `dotc` compiler.
- *
- *  The overall approach is based on compiling the requested code and then
- *  using a Java classloader and Java reflection to run the code
- *  and access its results.
- *
- *  In more detail, a single compiler instance is used
- *  to accumulate all successfully compiled or interpreted Scala code.  To
- *  "interpret" a line of code, the compiler generates a fresh object that
- *  includes the line of code and which has public definition(s) to export
- *  all variables defined by that code.  To extract the result of an
- *  interpreted line to show the user, a second "result object" is created
- *  which imports the variables exported by the above object and then
- *  exports a single definition named "result".  To accommodate user expressions
- *  that read from variables or methods defined in previous statements, "import"
- *  statements are used.
- *
- * This interpreter shares the strengths and weaknesses of using the
- *  full compiler-to-Java.  The main strength is that interpreted code
- *  behaves exactly as does compiled code, including running at full speed.
- *  The main weakness is that redefining classes and methods is not handled
- *  properly, because rebinding at the Java level is technically difficult.
- *
- * @author Moez A. Abdel-Gawad
- * @author Lex Spoon
- * @author Martin Odersky
- *
- * @param out   The output to use for diagnostics
- * @param ictx  The context to use for initialization of the interpreter,
- *              needed to access the current classpath.
- */
-class CompilingInterpreter(
-  out: PrintWriter,
-  ictx: Context,
-  parentClassLoader: Option[ClassLoader]
-) extends Compiler with Interpreter {
-  import ast.untpd._
-  import CompilingInterpreter._
-
-  ictx.base.initialize()(ictx)
-
-  /** directory to save .class files to */
-  val virtualDirectory =
-    if (ictx.settings.d.isDefault(ictx)) new VirtualDirectory("(memory)", None)
-    else new PlainDirectory(new Directory(new java.io.File(ictx.settings.d.value(ictx)))) // for now, to help debugging
-
-  /** A GenBCode phase that uses `virtualDirectory` for its output */
-  private class REPLGenBCode extends GenBCode {
-    override def outputDir(implicit ctx: Context) = virtualDirectory
-  }
-
-  /** Phases of this compiler use `REPLGenBCode` instead of `GenBCode`. */
-  override def phases = Phases.replace(
-    classOf[GenBCode], _ => new REPLGenBCode :: Nil, super.phases)
-
-  /** whether to print out result lines */
-  private var printResults: Boolean = true
-  private var delayOutput: Boolean = false
-
-  val previousOutput = ListBuffer.empty[String]
-
-  override def lastOutput() = {
-    val prev = previousOutput.toList
-    previousOutput.clear()
-    prev
-  }
-
-  override def delayOutputDuring[T](operation: => T): T = {
-    val old = delayOutput
-    try {
-      delayOutput = true
-      operation
-    } finally {
-      delayOutput = old
-    }
-  }
-
-  /** Temporarily be quiet */
-  override def beQuietDuring[T](operation: => T): T = {
-    val wasPrinting = printResults
-    try {
-      printResults = false
-      operation
-    } finally {
-      printResults = wasPrinting
-    }
-  }
-
-  private def newReporter =
-    new ConsoleReporter(Console.in, out) {
-      override def printMessage(msg: String) =
-        if (!delayOutput) {
-          out.print(/*clean*/(msg) + "\n")
-          // Suppress clean for now for compiler messages
-          // Otherwise we will completely delete all references to
-          // line$object$ module classes. The previous interpreter did not
-          // have the project because the module class was written without the final `$'
-          // and therefore escaped the purge. We can turn this back on once
-          // we drop the final `$' from module classes.
-          out.flush()
-        } else {
-          previousOutput += (/*clean*/(msg) + "\n")
-        }
-    }
-
-  /** the previous requests this interpreter has processed */
-  private val prevRequests = new ArrayBuffer[Request]()
-
-  /** the compiler's classpath, as URL's */
-  val compilerClasspath: Seq[URL] = ictx.platform.classPath(ictx).asURLs
-
-  /* A single class loader is used for all commands interpreted by this Interpreter.
-     It would also be possible to create a new class loader for each command
-     to interpret.  The advantages of the current approach are:
-
-       - Expressions are only evaluated one time.  This is especially
-         significant for I/O, e.g. "val x = Console.readLine"
-
-     The main disadvantage is:
-
-       - Objects, classes, and methods cannot be rebound.  Instead, definitions
-         shadow the old ones, and old code objects refer to the old
-         definitions.
-  */
-  /** class loader used to load compiled code */
-  val classLoader: ClassLoader = {
-    lazy val parent = new URLClassLoader(compilerClasspath.toArray,
-                                         classOf[Interpreter].getClassLoader)
-
-    new AbstractFileClassLoader(virtualDirectory, parentClassLoader.getOrElse(parent))
-  }
-
-  // Set the current Java "context" class loader to this interpreter's class loader
-  Thread.currentThread.setContextClassLoader(classLoader)
-
-  /** Parse a line into a sequence of trees. Returns None if the input is incomplete. */
-  private def parse(line: String)(implicit ctx: Context): Option[List[Tree]] = {
-    var justNeedsMore = false
-    val reporter = newReporter
-    reporter.withIncompleteHandler { _ => _ => justNeedsMore = true } {
-      // simple parse: just parse it, nothing else
-      def simpleParse(code: String)(implicit ctx: Context): List[Tree] = {
-        val source = new SourceFile("<console>", code.toCharArray())
-        val parser = new Parser(source)
-        val (selfDef, stats) = parser.templateStatSeq()
-        stats
-      }
-      val trees = simpleParse(line)(ctx.fresh.setReporter(reporter))
-      if (reporter.hasErrors) {
-        Some(Nil) // the result did not parse, so stop
-      } else if (justNeedsMore) {
-        None
-      } else {
-        Some(trees)
-      }
-    }
-  }
-
-  /** Compile a SourceFile.  Returns the root context of the run that compiled the file.
-   */
-  def compileSources(sources: List[SourceFile])(implicit ctx: Context): Context = {
-    val reporter = newReporter
-    val run = newRun(ctx.fresh.setReporter(reporter))
-    run.compileSources(sources)
-    run.runContext
-  }
-
-  /** Compile a string.  Returns true if there are no
-   *  compilation errors, or false otherwise.
-   */
-  def compileString(code: String)(implicit ctx: Context): Boolean = {
-    val runCtx = compileSources(List(new SourceFile("<script>", code.toCharArray)))
-    !runCtx.reporter.hasErrors
-  }
-
-  override def interpret(line: String)(implicit ctx: Context): Interpreter.Result = {
-    // if (prevRequests.isEmpty)
-    //  new Run(this) // initialize the compiler // (not sure this is needed)
-    // parse
-    parse(line) match {
-      case None => Interpreter.Incomplete
-      case Some(Nil) => Interpreter.Error // parse error or empty input
-      case Some(tree :: Nil) if tree.isTerm && !tree.isInstanceOf[Assign] =>
-        previousOutput.clear() // clear previous error reporting
-        interpret(s"val $newVarName =\n$line")
-      case Some(trees) =>
-        previousOutput.clear() // clear previous error reporting
-        val req = new Request(line, newLineName)
-        if (!req.compile())
-          Interpreter.Error // an error happened during compilation, e.g. a type error
-        else {
-          val (resultStrings, succeeded) = req.loadAndRun()
-          if (delayOutput)
-            previousOutput ++= resultStrings.map(clean)
-          else if (printResults || !succeeded)
-            resultStrings.foreach(x => out.print(clean(x)))
-          if (succeeded) {
-            prevRequests += req
-            Interpreter.Success
-          }
-          else Interpreter.Error
-        }
-    }
-  }
-
-  private def loadAndSetValue(objectName: String, value: AnyRef) = {
-    /** This terrible string is the wrapped class's full name inside the
-     *  classloader:
-     *  lineX$object$$iw$$iw$list$object
-     */
-    val objName: String = List(
-      currentLineName + INTERPRETER_WRAPPER_SUFFIX,
-      INTERPRETER_IMPORT_WRAPPER,
-      INTERPRETER_IMPORT_WRAPPER,
-      objectName
-    ).mkString("$")
-
-    try {
-      val resObj: Class[_] = Class.forName(objName, true, classLoader)
-      val setMethod = resObj.getDeclaredMethods.find(_.getName == "set")
-
-      setMethod.fold(false) { method =>
-        method.invoke(resObj, value) == null
-      }
-    } catch {
-      case NonFatal(_) =>
-        // Unable to set value on object due to exception during reflection
-        false
-    }
-  }
-
-  /** This bind is implemented by creating an object with a set method and a
-   *  field `value`. The value is then set via Java reflection.
-   *
-   *  Example: We want to bind a value `List(1,2,3)` to identifier `list` from
-   *  sbt. The bind method accomplishes this by creating the following:
-   *  {{{
-   *    object ContainerObjectWithUniqueID {
-   *      var value: List[Int] = _
-   *      def set(x: Any) = value = x.asInstanceOf[List[Int]]
-   *    }
-   *    val list = ContainerObjectWithUniqueID.value
-   *  }}}
-   *
-   *  Between the object being created and the value being assigned, the value
-   *  inside the object is set via reflection.
-   */
-  override def bind(id: String, boundType: String, value: AnyRef)(implicit ctx: Context): Interpreter.Result =
-    interpret(
-      """
-        |object %s {
-        |  var value: %s = _
-        |  def set(x: Any) = value = x.asInstanceOf[%s]
-        |}
-      """.stripMargin.format(id + INTERPRETER_WRAPPER_SUFFIX, boundType, boundType)
-    ) match {
-      case Interpreter.Success if loadAndSetValue(id + INTERPRETER_WRAPPER_SUFFIX, value) =>
-        val line = "val %s = %s.value".format(id, id + INTERPRETER_WRAPPER_SUFFIX)
-        interpret(line)
-      case Interpreter.Error | Interpreter.Incomplete =>
-        out.println("Set failed in bind(%s, %s, %s)".format(id, boundType, value))
-        Interpreter.Error
-    }
-
-  /** Trait collecting info about one of the statements of an interpreter request */
-  private trait StatementInfo {
-    /** The statement */
-    def statement: Tree
-
-    /** The names defined previously and referred to in the statement */
-    def usedNames: List[Name]
-
-    /** The names defined in the statement */
-    val boundNames: List[Name]
-
-    /** Statement is an import that contains a wildcard */
-    val importsWildcard: Boolean
-
-    /** The names imported by the statement (if it is an import clause) */
-    val importedNames: Seq[Name]
-
-    /** Statement defines an implicit calue or method */
-    val definesImplicit: Boolean
-  }
-
-  /** One line of code submitted by the user for interpretation */
-  private class Request(val line: String, val lineName: String)(implicit ctx: Context) {
-    private val trees = {
-      val parsed = parse(line)
-      previousOutput.clear() // clear previous error reporting
-      parsed match {
-        case Some(ts) => ts
-        case None => Nil
-      }
-    }
-
-    /** name to use for the object that will compute "line" */
-    private def objectName = lineName + INTERPRETER_WRAPPER_SUFFIX
-
-    /** name of the object that retrieves the result from the above object */
-    private def resultObjectName = "RequestResult$" + objectName
-
-    private def chooseHandler(stat: Tree): StatementHandler = stat match {
-      case stat: DefDef => new DefHandler(stat)
-      case stat: ValDef => new ValHandler(stat)
-      case stat: PatDef => new PatHandler(stat)
-      case stat @ Assign(Ident(_), _) => new AssignHandler(stat)
-      case stat: ModuleDef => new ModuleHandler(stat)
-      case stat: TypeDef if stat.isClassDef => new ClassHandler(stat)
-      case stat: TypeDef => new TypeAliasHandler(stat)
-      case stat: Import => new ImportHandler(stat)
-//    case DocDef(_, documented) => chooseHandler(documented)
-      case stat => new GenericHandler(stat)
-    }
-
-    private val handlers: List[StatementHandler] = trees.map(chooseHandler)
-
-    /** all (public) names defined by these statements */
-    private val boundNames = ListSet(handlers.flatMap(_.boundNames): _*).toList
-
-    /** list of names used by this expression */
-    private val usedNames: List[Name] = handlers.flatMap(_.usedNames)
-
-    private val (importsPreamble, importsTrailer, accessPath) =
-      importsCode(usedNames.toSet)
-
-    /** Code to access a variable with the specified name */
-    private def fullPath(vname: String): String = s"$objectName$accessPath.`$vname`"
-
-    /** Code to access a variable with the specified name */
-    private def fullPath(vname: Name): String = fullPath(vname.toString)
-
-    /** the line of code to compute */
-    private def toCompute = line
-
-    /** generate the source code for the object that computes this request
-     *  TODO Reformulate in a functional way
-     */
-    private def objectSourceCode: String =
-      stringFrom { code =>
-        // header for the wrapper object
-        code.println(s"object $objectName{")
-        code.print(importsPreamble)
-        code.println(toCompute)
-        handlers.foreach(_.extraCodeToEvaluate(this,code))
-        code.println(importsTrailer)
-        //end the wrapper object
-        code.println(";}")
-      }
-
-    /** Types of variables defined by this request.  They are computed
-        after compilation of the main object */
-    private var typeOf: Map[Name, String] = _
-
-    /** generate source code for the object that retrieves the result
-        from objectSourceCode */
-    private def resultObjectSourceCode: String =
-      stringFrom(code => {
-        code.println(s"object $resultObjectName")
-        code.println("{ val result: String = {")
-        code.println(s"$objectName$accessPath;")  // evaluate the object, to make sure its constructor is run
-        code.print("(\"\"")  // print an initial empty string, so later code can
-                            // uniformly be: + morestuff
-        handlers.foreach(_.resultExtractionCode(this, code))
-        code.println("\n)}")
-        code.println(";}")
-      })
-
-
-    /** Compile the object file.  Returns whether the compilation succeeded.
-     *  If all goes well, the "types" map is computed. */
-    def compile(): Boolean = {
-      val compileCtx = compileSources(
-        List(new SourceFile("<console>", objectSourceCode.toCharArray)))
-      !compileCtx.reporter.hasErrors && {
-        this.typeOf = findTypes(compileCtx)
-        val resultCtx = compileSources(
-          List(new SourceFile("<console>", resultObjectSourceCode.toCharArray)))
-        !resultCtx.reporter.hasErrors
-      }
-    }
-
-    /** Dig the types of all bound variables out of the compiler run.
-     *  TODO: Change the interface so that we typecheck, and then transform
-     *  directly. Treating the compiler as less of a blackbox will require
-     *  much less magic here.
-     */
-    private def findTypes(implicit ctx: Context): Map[Name, String] = {
-      def valAndVarNames = handlers.flatMap(_.valAndVarNames)
-      def defNames = handlers.flatMap(_.defNames)
-
-      def getTypes(names: List[Name], nameMap: Name => Name): Map[Name, String] = {
-        /** the outermost wrapper object */
-        val outerResObjSym: Symbol =
-          defn.EmptyPackageClass.info.decl(objectName.toTermName).symbol
-
-        /** the innermost object inside the wrapper, found by
-          * following accessPath into the outer one. */
-        val resObjSym =
-          (accessPath.split("\\.")).foldLeft(outerResObjSym) { (sym,str) =>
-            if (str.isEmpty) sym
-            else
-              ctx.atPhase(ctx.typerPhase.next) { implicit ctx =>
-                sym.info.member(str.toTermName).symbol
-              }
-          }
-
-        names.foldLeft(Map.empty[Name,String]) { (map, name) =>
-          val rawType =
-            ctx.atPhase(ctx.typerPhase.next) { implicit ctx =>
-              resObjSym.info.member(name).info
-            }
-
-          // the types are all =>T; remove the =>
-          val cleanedType = rawType.widenExpr match {
-            case tp: MethodType => tp.resultType
-            case tp => tp
-          }
-
-          map + (name ->
-            ctx.atPhase(ctx.typerPhase.next) { implicit ctx =>
-              cleanedType.show
-            })
-        }
-      }
-
-      val names1 = getTypes(valAndVarNames, n => n.toTermName.fieldName)
-      val names2 = getTypes(defNames, identity)
-      names1 ++ names2
-    }
-
-    /** Sets both System.{out,err} and Console.{out,err} to supplied
-     *  `os: OutputStream`
-     */
-    private def withOutput[T](os: ByteOutputStream)(op: ByteOutputStream => T) = {
-      val ps     = new PrintStream(os)
-      val oldOut = System.out
-      val oldErr = System.err
-      System.setOut(ps)
-      System.setErr(ps)
-
-      try {
-        Console.withOut(os)(Console.withErr(os)(op(os)))
-      } finally {
-        System.setOut(oldOut)
-        System.setErr(oldErr)
-      }
-    }
-
-    /** load and run the code using reflection.
-     *  @return  A pair consisting of the run's result as a `List[String]`, and
-     *           a boolean indicating whether the run succeeded without throwing
-     *           an exception.
-     */
-    def loadAndRun(): (List[String], Boolean) = {
-      val interpreterResultObject: Class[_] =
-        Class.forName(resultObjectName, true, classLoader)
-      val valMethodRes: java.lang.reflect.Method =
-        interpreterResultObject.getMethod("result")
-      try {
-        withOutput(new ByteOutputStream) { ps =>
-          val rawRes = valMethodRes.invoke(interpreterResultObject).toString
-          val res =
-            if (ictx.useColors) new String(SyntaxHighlighting(rawRes).toArray)
-            else rawRes
-          val prints = ps.toString("utf-8")
-          val printList = if (prints != "") prints :: Nil else Nil
-
-          if (!delayOutput) out.print(prints)
-
-          (printList :+ res, true)
-        }
-      } catch {
-        case NonFatal(ex) =>
-          def cause(ex: Throwable): Throwable =
-            if (ex.getCause eq null) ex else cause(ex.getCause)
-          val orig = cause(ex)
-          (stringFrom(str => orig.printStackTrace(str)) :: Nil, false)
-      }
-    }
-
-    /** Compute imports that allow definitions from previous
-     *  requests to be visible in a new request.  Returns
-     *  three pieces of related code as strings:
-     *
-     *  1. A _preamble_: An initial code fragment that should go before
-     *  the code of the new request.
-     *
-     *  2. A _trailer_: A code fragment that should go after the code
-     *  of the new request.
-     *
-     *  3. An _access path_ which can be traversed to access
-     *  any bindings inside code wrapped by #1 and #2 .
-     *
-     *  The argument is a set of Names that need to be imported.
-     *
-     *  Limitations: This method is not as precise as it could be.
-     *  (1) It does not process wildcard imports to see what exactly
-     *  they import.
-     *  (2) If it imports any names from a request, it imports all
-     *  of them, which is not really necessary.
-     *  (3) It imports multiple same-named implicits, but only the
-     *  last one imported is actually usable.
-     */
-    private def importsCode(wanted: Set[Name]): (String, String, String) = {
-      /** 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.
-       */
-      def reqsToUse: List[(Request, StatementInfo)] = {
-        /** Loop through a list of StatementHandlers and select
-         *  which ones to keep.  'wanted' is the set of
-         *  names that need to be imported.
-         */
-        def select(reqs: List[(Request, StatementInfo)], wanted: Set[Name]): List[(Request, StatementInfo)] = {
-          reqs match {
-            case Nil => Nil
-
-            case (req, handler) :: rest =>
-              val keepit =
-                (handler.definesImplicit ||
-                  handler.importsWildcard ||
-                  handler.importedNames.exists(wanted.contains(_)) ||
-                  handler.boundNames.exists(wanted.contains(_)))
-
-              val newWanted =
-                if (keepit) {
-                  (wanted
-                    ++ handler.usedNames
-                    -- handler.boundNames
-                    -- handler.importedNames)
-                } else {
-                  wanted
-                }
-
-              val restToKeep = select(rest, newWanted)
-
-              if (keepit)
-                (req, handler) :: restToKeep
-              else
-                restToKeep
-          }
-        }
-
-        val rhpairs = for {
-          req <- prevRequests.toList.reverse
-          handler <- req.handlers
-        } yield (req, handler)
-
-        select(rhpairs, wanted).reverse
-      }
-
-      val preamble = new StringBuffer
-      val trailingBraces = new StringBuffer
-      val accessPath = new StringBuffer
-      val impname = INTERPRETER_IMPORT_WRAPPER
-      val currentImps = mutable.Set[Name]()
-
-      // add code for a new object to hold some imports
-      def addWrapper(): Unit = {
-        preamble.append("object " + impname + "{\n")
-        trailingBraces.append("}\n")
-        accessPath.append("." + impname)
-        currentImps.clear()
-      }
-
-      addWrapper()
-
-      // loop through previous requests, adding imports
-      // for each one
-      for ((req, handler) <- reqsToUse) {
-        // If the user entered an import, then just use it
-
-        // add an import wrapping level if the import might
-        // conflict with some other import
-        if (handler.importsWildcard ||
-          currentImps.exists(handler.importedNames.contains))
-          if (!currentImps.isEmpty)
-            addWrapper()
-
-        if (handler.statement.isInstanceOf[Import])
-          preamble.append(handler.statement.show + ";\n")
-
-        // give wildcard imports a import wrapper all to their own
-        if (handler.importsWildcard)
-          addWrapper()
-        else
-          currentImps ++= handler.importedNames
-
-        // For other requests, import each bound variable.
-        // import them explicitly instead of with _, so that
-        // ambiguity errors will not be generated. Also, quote
-        // the name of the variable, so that we don't need to
-        // handle quoting keywords separately.
-        for (imv <- handler.boundNames) {
-          if (currentImps.contains(imv))
-            addWrapper()
-          preamble.append("import ")
-          preamble.append(req.objectName + req.accessPath + ".`" + imv + "`;\n")
-          currentImps += imv
-        }
-      }
-
-      addWrapper() // Add one extra wrapper, to prevent warnings
-      // in the frequent case of redefining
-      // the value bound in the last interpreter
-      // request.
-
-      (preamble.toString, trailingBraces.toString, accessPath.toString)
-    }
-
-    // ------ Handlers ------------------------------------------
-
-    /** Class to handle one statement among all the statements included
-     *  in a single interpreter request.
-     */
-    private sealed abstract class StatementHandler(val statement: Tree) extends StatementInfo {
-      val usedNames: List[Name] = {
-        val ivt = new UntypedTreeAccumulator[mutable.Set[Name]] {
-          override def apply(ns: mutable.Set[Name], tree: Tree)(implicit ctx: Context) =
-            tree match {
-              case Ident(name) => ns += name
-              case _ => foldOver(ns, tree)
-            }
-        }
-        ivt.foldOver(HashSet(), statement).toList
-      }
-      val boundNames: List[Name] = Nil
-      def valAndVarNames: List[Name] = Nil
-      def defNames: List[Name] = Nil
-      val importsWildcard = false
-      val importedNames: Seq[Name] = Nil
-      val definesImplicit = statement match {
-        case tree: MemberDef => tree.mods.is(Flags.Implicit)
-        case _ => false
-      }
-
-      def extraCodeToEvaluate(req: Request, code: PrintWriter) = {}
-      def resultExtractionCode(req: Request, code: PrintWriter) = {}
-    }
-
-    private class GenericHandler(statement: Tree) extends StatementHandler(statement)
-
-    private abstract class ValOrPatHandler(statement: Tree)
-        extends StatementHandler(statement) {
-      override val boundNames: List[Name] = _boundNames
-      override def valAndVarNames = boundNames
-
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        if (!shouldShowResult(req)) return
-        val resultExtractors = boundNames.map(name => resultExtractor(req, name))
-        code.print(resultExtractors.mkString(""))
-      }
-
-      private val ListReg = """^.*List\[(\w+)\]$""".r
-      private val MapReg = """^.*Map\[(\w+),[ ]*(\w+)\]$""".r
-      private val LitReg = """^.*\((.+)\)$""".r
-
-      private def resultExtractor(req: Request, varName: Name): String = {
-        val prettyName = varName.decode
-        // FIXME: `varType` is prettified to abbreviate common types where
-        // appropriate, and to also prettify literal types
-        //
-        // This should be rewritten to use the actual types once we have a
-        // semantic representation available to the REPL
-        val varType = string2code(req.typeOf(varName)) match {
-          // Extract List's paremeter from full path
-          case ListReg(param) => s"List[$param]"
-          // Extract Map's paremeters from full path
-          case MapReg(k, v) => s"Map[$k, $v]"
-          // Extract literal type from literal type representation. Example:
-          //
-          // ```
-          // scala> val x: 42 = 42
-          // val x: Int(42) = 42
-          // scala> val y: "hello" = "hello"
-          // val y: String("hello") = "hello"
-          // ```
-          case LitReg(lit) => lit
-          // When the type is a singleton value like None, don't show `None$`
-          // instead show `None.type`.
-          case x if x.lastOption == Some('$') => x.init + ".type"
-          case x => x
-        }
-        val fullPath = req.fullPath(varName)
-
-        val varOrVal = statement match {
-          case v: ValDef if v.mods is Flags.Mutable => "var"
-          case _ => "val"
-        }
-
-        s""" + "$varOrVal $prettyName: $varType = " + {
-           |  if ($fullPath.asInstanceOf[AnyRef] != null) {
-           |    (if ($fullPath.toString().contains('\\n')) "\\n" else "") + {
-           |      import dotty.Show._
-           |      (new ShowValue($fullPath)).show /*toString()*/ + "\\n"
-           |    }
-           |  } else {
-           |    "null\\n"
-           |  }
-           |}""".stripMargin
-      }
-
-      protected def _boundNames: List[Name]
-      protected def shouldShowResult(req: Request): Boolean
-    }
-
-    private class ValHandler(statement: ValDef) extends ValOrPatHandler(statement) {
-      override def _boundNames = List(statement.name)
-
-      override def shouldShowResult(req: Request): Boolean =
-        !statement.mods.is(Flags.AccessFlags) &&
-          !(isGeneratedVarName(statement.name.toString) &&
-            req.typeOf(statement.name) == "Unit")
-    }
-
-
-    private class PatHandler(statement: PatDef) extends ValOrPatHandler(statement) {
-      override def _boundNames = statement.pats.flatMap(findVariableNames)
-
-      override def shouldShowResult(req: Request): Boolean =
-        !statement.mods.is(Flags.AccessFlags)
-
-      private def findVariableNames(tree: Tree): List[Name] = tree match {
-        case Ident(name) if name.toString != "_" => List(name)
-        case _ => VariableNameFinder(Nil, tree).reverse
-      }
-
-      private object VariableNameFinder extends UntypedDeepFolder[List[Name]](
-        (acc: List[Name], t: Tree) => t match {
-          case _: BackquotedIdent => acc
-          case Ident(name) if name.isVariableName && name.toString != "_" => name :: acc
-          case Bind(name, _) if name.isVariableName => name :: acc
-          case _ => acc
-        }
-      )
-    }
-
-    private class DefHandler(defDef: DefDef) extends StatementHandler(defDef) {
-      override val boundNames = List(defDef.name)
-      override def defNames = boundNames
-
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        /** TODO: This is the result of the state of the REPL - this would be
-          * entirely unnecessary with a better structure where we could just
-          * use the type printer
-          *
-          * @see `def findTypes` for an explanation of what should be done
-          */
-        if (!defDef.mods.is(Flags.AccessFlags)) {
-          // Take the DefDef and remove the `rhs` and ascribed type `tpt`
-          val copy = ast.untpd.cpy.DefDef(defDef)(
-            rhs = EmptyTree,
-            tpt = TypeTree()
-          )
-
-          val tpt = defDef.tpt match {
-            // ascribed TypeExpr e.g: `def foo: Int = 5`
-            case Ident(tpt) if defDef.vparamss.isEmpty =>
-              ": " + tpt.show
-            case tpt =>
-              ": " + req.typeOf(defDef.name)
-          }
-          code.print {
-            "+\"" + string2code(copy.show) + tpt + "\\n\""
-          }
-        }
-      }
-    }
-
-    private class AssignHandler(statement: Assign) extends StatementHandler(statement) {
-      val lhs = statement.lhs.asInstanceOf[Ident] // an unfortunate limitation
-
-      val helperName = newInternalVarName().toTermName
-      override val valAndVarNames = List(helperName)
-
-      override def extraCodeToEvaluate(req: Request, code: PrintWriter): Unit = {
-        code.println(i"val $helperName = ${statement.lhs};")
-      }
-
-      /** Print out lhs instead of the generated varName */
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        code.print(" + \"" + lhs.show + ": " +
-          string2code(req.typeOf(helperName)) +
-          " = \" + " +
-          string2code(req.fullPath(helperName))
-          + " + \"\\n\"")
-      }
-    }
-
-    private class ModuleHandler(module: ModuleDef) extends StatementHandler(module) {
-      override val boundNames = List(module.name)
-
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        code.println(" + \"defined module " +
-          string2code(module.name.toString)
-          + "\\n\"")
-      }
-    }
-
-    private class ClassHandler(classdef: TypeDef)
-      extends StatementHandler(classdef) {
-      override val boundNames =
-        List(classdef.name) :::
-          (if (classdef.mods.is(Flags.Case))
-            List(classdef.name.toTermName)
-          else
-            Nil)
-
-      // TODO: MemberDef.keyword does not include "trait";
-      // otherwise it could be used here
-      def keyword: String =
-        if (classdef.mods.is(Flags.Trait)) "trait" else "class"
-
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        code.print(
-          " + \"defined " +
-            keyword +
-            " " +
-            string2code(classdef.name.toString) +
-            "\\n\"")
-      }
-    }
-
-    private class TypeAliasHandler(typeDef: TypeDef)
-      extends StatementHandler(typeDef) {
-      override val boundNames =
-        if (!typeDef.mods.is(Flags.AccessFlags) && !typeDef.rhs.isInstanceOf[TypeBoundsTree])
-          List(typeDef.name)
-        else
-          Nil
-
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        code.println(" + \"defined type alias " +
-          string2code(typeDef.name.toString) + "\\n\"")
-      }
-    }
-
-    private class ImportHandler(imp: Import) extends StatementHandler(imp) {
-      override def resultExtractionCode(req: Request, code: PrintWriter): Unit = {
-        code.println("+ \"" + imp.show + "\\n\"")
-      }
-
-      def isWildcardSelector(tree: Tree) = tree match {
-        case Ident(nme.USCOREkw) => true
-        case _ => false
-      }
-
-      /** Whether this import includes a wildcard import */
-      override val importsWildcard = imp.selectors.exists(isWildcardSelector)
-
-      /** The individual names imported by this statement */
-      override val importedNames: Seq[Name] =
-        imp.selectors.filterNot(isWildcardSelector).flatMap {
-          case sel: RefTree => List(sel.name.toTypeName, sel.name.toTermName)
-          case _ => Nil
-        }
-    }
-
-  } // end Request
-
-  // ------- String handling ----------------------------------
-
-  /** next line number to use */
-  private var nextLineNo = 0
-
-  /** allocate a fresh line name */
-  private def newLineName = {
-    val num = nextLineNo
-    nextLineNo += 1
-    INTERPRETER_LINE_PREFIX + num
-  }
-
-  private def currentLineName =
-    INTERPRETER_LINE_PREFIX + (nextLineNo - 1)
-
-  /** next result variable number to use */
-  private var nextVarNameNo = 0
-
-  /** allocate a fresh variable name */
-  private def newVarName = {
-    val num = nextVarNameNo
-    nextVarNameNo += 1
-    INTERPRETER_VAR_PREFIX + num
-  }
-
-  /** next internal variable number to use */
-  private var nextInternalVarNo = 0
-
-  /** allocate a fresh internal variable name */
-  private def newInternalVarName() = {
-    val num = nextVarNameNo
-    nextVarNameNo += 1
-    INTERPRETER_SYNTHVAR_PREFIX + num
-  }
-
-  /** Check if a name looks like it was generated by newVarName */
-  private def isGeneratedVarName(name: String): Boolean =
-    name.startsWith(INTERPRETER_VAR_PREFIX) && {
-      val suffix = name.drop(INTERPRETER_VAR_PREFIX.length)
-      suffix.forall(_.isDigit)
-    }
-
-  /** generate a string using a routine that wants to write on a stream */
-  private def stringFrom(writer: PrintWriter => Unit): String = {
-    val stringWriter = new StringWriter()
-    val stream = new NewLinePrintWriter(stringWriter)
-    writer(stream)
-    stream.close()
-    stringWriter.toString
-  }
-
-  /** Truncate a string if it is longer than settings.maxPrintString */
-  private def truncPrintString(str: String)(implicit ctx: Context): String = {
-    val maxpr = ctx.settings.XreplLineWidth.value
-
-    if (maxpr <= 0)
-      return str
-
-    if (str.length <= maxpr)
-      return str
-
-    val trailer = "..."
-    if (maxpr >= trailer.length-1)
-      str.substring(0, maxpr-3) + trailer + "\n"
-    else
-      str.substring(0, maxpr-1)
-  }
-
-  /** Clean up a string for output */
-  private def clean(str: String)(implicit ctx: Context) =
-    truncPrintString(stripWrapperGunk(str))
-}
-
-/** Utility methods for the Interpreter. */
-object CompilingInterpreter {
-  val INTERPRETER_WRAPPER_SUFFIX = "$object"
-  val INTERPRETER_LINE_PREFIX = "line"
-  val INTERPRETER_VAR_PREFIX = "res"
-  val INTERPRETER_IMPORT_WRAPPER = "$iw"
-  val INTERPRETER_SYNTHVAR_PREFIX = "synthvar$"
-
-  /** Delete a directory tree recursively.  Use with care!
-   */
-  private[repl] def deleteRecursively(path: File): Unit = {
-    path match  {
-      case _ if !path.exists =>
-        ()
-      case _ if path.isDirectory =>
-        for (p <- path.listFiles)
-          deleteRecursively(p)
-        path.delete
-      case _ =>
-        path.delete
-    }
-  }
-
-  /** Heuristically strip interpreter wrapper prefixes
-   *  from an interpreter output string.
-   */
-  def stripWrapperGunk(str: String): String = {
-    val wrapregex = "(line[0-9]+\\$object[$.])?(\\$iw[$.])*"
-    str.replaceAll(wrapregex, "")
-  }
-
-  /** Convert a string into code that can recreate the string.
-   *  This requires replacing all special characters by escape
-   *  codes. It does not add the surrounding " marks.  */
-  def string2code(str: String): String = {
-    /** Convert a character to a backslash-u escape */
-    def char2uescape(c: Char): String = {
-      var rest = c.toInt
-      val buf = new StringBuilder
-      for (i <- 1 to 4) {
-	      buf ++= (rest % 16).toHexString
-	      rest = rest / 16
-      }
-      "\\" + "u" + buf.toString.reverse
-    }
-    val res = new StringBuilder
-    for (c <- str) {
-      if ("'\"\\" contains c) {
-	      res += '\\'
-	      res += c
-      } else if (!c.isControl) {
-	      res += c
-      } else {
-	      res ++= char2uescape(c)
-      }
-    }
-    res.toString
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/ConsoleWriter.scala b/compiler/src/dotty/tools/dotc/repl/ConsoleWriter.scala
deleted file mode 100644
index 325aab628ed7..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/ConsoleWriter.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-import java.io.Writer
-
-/** A Writer that writes onto the Scala Console.
- *
- *  @author  Lex Spoon
- *  @version 1.0
- */
-class ConsoleWriter extends Writer {
-  def close() = flush()
-
-  def flush() = Console.flush()
-
-  def write(cbuf: Array[Char], off: Int, len: Int): Unit =
-    if (len > 0)
-      write(new String(cbuf, off, len))
-
-  override def write(str: String): Unit = Console.print(str)
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/InteractiveReader.scala b/compiler/src/dotty/tools/dotc/repl/InteractiveReader.scala
deleted file mode 100644
index 07ce23717079..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/InteractiveReader.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import dotc.core.Contexts.Context
-
-/** Reads lines from an input stream */
-trait InteractiveReader {
-  def readLine(prompt: String): String
-  val interactive: Boolean
-}
-
-/** The current Scala REPL know how to do this flexibly.
- */
-object InteractiveReader {
-  /** Create an interactive reader */
-  def createDefault(in: Interpreter)(implicit ctx: Context): InteractiveReader = {
-    new AmmoniteReader(in)
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/Interpreter.scala b/compiler/src/dotty/tools/dotc/repl/Interpreter.scala
deleted file mode 100644
index edcc5b153142..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/Interpreter.scala
+++ /dev/null
@@ -1,45 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import core.Contexts.Context
-
-/** This object defines the type of interpreter results */
-object Interpreter {
-
-  /** A result from interpreting one line of input. */
-  abstract sealed class Result
-
-  /** The line was interpreted successfully. */
-  case object Success extends Result
-
-  /** The line was erroneous in some way. */
-  case object Error extends Result
-
-  /** The input was incomplete.  The caller should request more input.
-   */
-  case object Incomplete extends Result
-}
-
-/** The exported functionality of the interpreter */
-trait Interpreter {
-  import Interpreter._
-
- /** Interpret one line of input. All feedback, including parse errors and
-  *  evaluation results, are printed via the context's reporter. Values
-  *  defined are available for future interpreted strings.
-  */
-  def interpret(line: String)(implicit ctx: Context): Result
-
-  /** Tries to bind an id to a value, returns the outcome of trying to bind */
-  def bind(id: String, boundType: String, value: AnyRef)(implicit ctx: Context): Result
-
-  /** Suppress output during evaluation of `operation`. */
-  def beQuietDuring[T](operation: => T): T
-
-  /** Suppresses output and saves it for `lastOutput` to collect */
-  def delayOutputDuring[T](operation: => T): T
-
-  /** Gets the last output not printed immediately */
-  def lastOutput(): Seq[String]
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/InterpreterLoop.scala b/compiler/src/dotty/tools/dotc/repl/InterpreterLoop.scala
deleted file mode 100644
index cfe8d892d55a..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/InterpreterLoop.scala
+++ /dev/null
@@ -1,210 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import java.io.{BufferedReader, File, FileReader, PrintWriter}
-import java.io.IOException
-import java.lang.{ClassLoader, System, Thread}
-import scala.concurrent.{Future, Await}
-import scala.concurrent.duration.Duration
-import reporting.Reporter
-import core._
-import Contexts._
-import annotation.tailrec
-import scala.concurrent.ExecutionContext.Implicits.global
-
-/** The interactive shell.  It provides a read-eval-print loop around
- *  the Interpreter class.
- *  After instantiation, clients should call the `run` method.
- *
- *  @author Moez A. Abdel-Gawad
- *  @author Lex Spoon
- *  @author Martin Odersky
- */
-class InterpreterLoop(compiler: Compiler, config: REPL.Config)(implicit ctx: Context) {
-  import config._
-
-  val interpreter = compiler.asInstanceOf[Interpreter]
-
-  private var in = input(interpreter)
-
-  /** The context class loader at the time this object was created */
-  protected val originalClassLoader =
-    Thread.currentThread.getContextClassLoader
-
-  /** A reverse list of commands to replay if the user
-    * requests a :replay */
-  var replayCommandsRev: List[String] = Nil
-
-  /** A list of commands to replay if the user requests a :replay */
-  def replayCommands = replayCommandsRev.reverse
-
-  /** Record a command for replay should the user request a :replay */
-  def addReplay(cmd: String) =
-    replayCommandsRev = cmd :: replayCommandsRev
-
-  /** Close the interpreter */
-  def closeInterpreter()(implicit ctx: Context): Unit = {
-    ctx.reporter.flush()
-    Thread.currentThread.setContextClassLoader(originalClassLoader)
-  }
-
-  /** print a friendly help message */
-  def printHelp(): Unit = {
-    printWelcome()
-    output.println("Type :load followed by a filename to load a Scala file.")
-    output.println("Type :replay to reset execution and replay all previous commands.")
-    output.println("Type :quit to exit the interpreter.")
-  }
-
-  /** Print a welcome message */
-  def printWelcome(): Unit = {
-    output.println(s"Welcome to Scala$version " + " (" +
-                System.getProperty("java.vm.name") + ", Java " + System.getProperty("java.version") + ")." )
-    output.println("Type in expressions to have them evaluated.")
-    output.println("Type :help for more information.")
-    output.flush()
-  }
-
-  val gitHash = ManifestInfo.attributes.getOrElse("Git-Hash", "unknown")
-  val version = s".next (pre-alpha, git-hash: $gitHash)"
-
-  /** The main read-eval-print loop for the interpreter.  It calls
-   *  `command()` for each line of input.
-   */
-  @tailrec final def repl(line: String = in.readLine(prompt)): Unit =
-    if (line != null) {
-      val (keepGoing, finalLineOpt) = command(line)
-      if (keepGoing) {
-        finalLineOpt.foreach(addReplay)
-        output.flush()
-        repl()
-      }
-    }
-
-  /** interpret all lines from a specified file */
-  def interpretAllFrom(filename: String): Unit = {
-    import java.nio.file.{Files, Paths}
-    import scala.collection.JavaConversions._
-    try {
-      val lines = Files.readAllLines(Paths.get(filename)).mkString("\n")
-      output.println("Loading " + filename + "...")
-      output.flush
-      interpreter.interpret(lines)
-    } catch {
-      case _: IOException =>
-        output.println("Error opening file: " + filename)
-    }
-  }
-
-  /** create a new interpreter and replay all commands so far */
-  def replay(): Unit = {
-    for (cmd <- replayCommands) {
-      output.println("Replaying: " + cmd)
-      output.flush()  // because maybe cmd will have its own output
-      command(cmd)
-      output.println
-    }
-  }
-
-  /** Run one command submitted by the user.  Three values are returned:
-    * (1) whether to keep running, (2) the line to record for replay,
-    * if any. */
-  def command(line: String): (Boolean, Option[String]) = {
-    def withFile(command: String)(action: String => Unit): Unit = {
-      val spaceIdx = command.indexOf(' ')
-      if (spaceIdx <= 0) {
-        output.println("That command requires a filename to be specified.")
-        return
-      }
-      val filename = command.substring(spaceIdx).trim
-      if (!new File(filename).exists) {
-        output.println("That file does not exist")
-        return
-      }
-      action(filename)
-    }
-
-    val helpRegexp    = ":h(e(l(p)?)?)?"
-    val quitRegexp    = ":q(u(i(t)?)?)?"
-    val loadRegexp    = ":l(o(a(d)?)?)?.*"
-    val replayRegexp  = ":r(e(p(l(a(y)?)?)?)?)?.*"
-    val lastOutput    = interpreter.lastOutput()
-
-    var shouldReplay: Option[String] = None
-
-    if (line.matches(helpRegexp))
-      printHelp()
-    else if (line.matches(quitRegexp))
-      return (false, None)
-    else if (line.matches(loadRegexp)) {
-      withFile(line)(f => {
-        interpretAllFrom(f)
-        shouldReplay = Some(line)
-      })
-    }
-    else if (line matches replayRegexp)
-      replay()
-    else if (line startsWith ":")
-      output.println("Unknown command.  Type :help for help.")
-    else
-      shouldReplay = lastOutput match { // don't interpret twice
-        case Nil => interpretStartingWith(line)
-        case oldRes =>
-          oldRes foreach output.print
-          Some(line)
-      }
-
-    (true, shouldReplay)
-  }
-
-  def silentlyRun(cmds: List[String]): Unit = cmds.foreach { cmd =>
-    interpreter.beQuietDuring(interpreter.interpret(cmd))
-  }
-
-  def silentlyBind(values: Array[(String, Any)]): Unit = values.foreach { case (id, value) =>
-    interpreter.beQuietDuring(
-      interpreter.bind(id, value.asInstanceOf[AnyRef].getClass.getName, value.asInstanceOf[AnyRef]))
-  }
-
-  /** Interpret expressions starting with the first line.
-    * Read lines until a complete compilation unit is available
-    * or until a syntax error has been seen.  If a full unit is
-    * read, go ahead and interpret it.  Return the full string
-    * to be recorded for replay, if any.
-    */
-  def interpretStartingWith(code: String): Option[String] =
-    interpreter.interpret(code) match {
-      case Interpreter.Success => Some(code)
-      case _ => None
-    }
-/*
-  def loadFiles(settings: Settings) {
-    settings match {
-      case settings: GenericRunnerSettings =>
-        for (filename <- settings.loadfiles.value) {
-          val cmd = ":load " + filename
-          command(cmd)
-          replayCommandsRev = cmd :: replayCommandsRev
-          output.println()
-        }
-      case _ =>
-    }
-  }
-*/
-  def run(): Reporter = {
-    // loadFiles(settings)
-    try {
-      if (!ctx.reporter.hasErrors) { // if there are already errors, no sense to continue
-        printWelcome()
-        silentlyRun(config.initialCommands)
-        silentlyBind(config.boundValues)
-        repl(in.readLine(prompt))
-        silentlyRun(config.cleanupCommands)
-      }
-    } finally {
-      closeInterpreter()
-    }
-    ctx.reporter
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/Main.scala b/compiler/src/dotty/tools/dotc/repl/Main.scala
deleted file mode 100644
index 48ed3e7885a5..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/Main.scala
+++ /dev/null
@@ -1,28 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-/* This REPL was adapted from an old (2008-ish) version of the Scala
- * REPL. The original version from which the adaptation was done is found in:
- *
- *      https://github.com/odersky/legacy-svn-scala/tree/spoon
- *
- * The reason this version was picked instead of a more current one is that
- * the older version is much smaller, therefore easier to port. It is also
- * considerably less intertwined with nsc than later versions.
- *
- * There are a number of TODOs:
- *
- *  - figure out why we can launch REPL only with `java`, not with `scala`.
- *  - make a doti command (urgent, easy)
- *  - create or port REPL tests (urgent, intermediate)
- *  - copy improvements of current Scala REPL wrt to this version
- *    (somewhat urgent, intermediate)
- *  - re-enable bindSettings (not urgent, easy, see TODO in InterpreterLoop.scala)
- *  - make string generation more functional (not urgent, easy)
- *  - better handling of ^C (not urgent, intermediate)
- *  - syntax highlighting (not urgent, intermediate)
- *  - integrate with presentation compiler for command completion (not urgent, hard)
- */
-/** The main entry point of the REPL */
-object Main extends REPL
diff --git a/compiler/src/dotty/tools/dotc/repl/ManifestInfo.scala b/compiler/src/dotty/tools/dotc/repl/ManifestInfo.scala
deleted file mode 100644
index 206dccd67075..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/ManifestInfo.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-package dotty.tools.dotc.repl
-
-import java.net.JarURLConnection
-import scala.collection.JavaConversions._
-
-object ManifestInfo {
-
-  val attributes: Map[String, String] = {
-    for {
-      resourceUrl <- Option(getClass.getResource(getClass.getSimpleName + ".class"))
-      urlConnection = resourceUrl.openConnection() if urlConnection.isInstanceOf[JarURLConnection]
-      manifest <- Option(urlConnection.asInstanceOf[JarURLConnection].getManifest)
-    } yield {
-      manifest.getMainAttributes.foldLeft(Map[String, String]())(
-        (map, attribute) => map + (attribute._1.toString -> attribute._2.toString)
-      )
-    }
-  }.getOrElse(Map())
-
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/NewLinePrintWriter.scala b/compiler/src/dotty/tools/dotc/repl/NewLinePrintWriter.scala
deleted file mode 100644
index 8e36a0ae47a0..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/NewLinePrintWriter.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-import java.io.{Writer, PrintWriter}
-
-class NewLinePrintWriter(out: Writer, autoFlush: Boolean)
-extends PrintWriter(out, autoFlush) {
-  def this(out: Writer) = this(out, false)
-  override def println(): Unit = { print("\n"); flush() }
-}
-
diff --git a/compiler/src/dotty/tools/dotc/repl/REPL.scala b/compiler/src/dotty/tools/dotc/repl/REPL.scala
deleted file mode 100644
index 11ea7636d1a4..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/REPL.scala
+++ /dev/null
@@ -1,100 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import core.Contexts.Context
-import reporting.Reporter
-import io.{AbstractFile, PlainFile, VirtualDirectory}
-import dotty.tools.io.{PlainDirectory, Directory}
-import java.io.{BufferedReader, File => JFile, FileReader, PrintWriter}
-import java.net.{URL, URLClassLoader}
-
-/** A compiler which stays resident between runs.
- *  Usage:
- *
- *  > scala dotty.tools.dotc.Resident <options> <initial files>
- *
- *  dotc> "more options and files to compile"
- *
- *  ...
- *
- *  dotc> :reset  // reset all options to the ones passed on the command line
- *
- *  ...
- *
- *  dotc> :q     // quit
- */
-class REPL extends Driver {
-
-  lazy val config = new REPL.Config
-
-  override def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
-    val (strs, ctx) = super.setup(args, rootCtx)
-    (strs, config.context(ctx))
-  }
-
-  override def newCompiler(implicit ctx: Context): Compiler =
-    new repl.CompilingInterpreter(config.output, ctx, config.classLoader)
-
-  override def sourcesRequired = false
-
-  override def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter = {
-    if (fileNames.isEmpty)
-      new InterpreterLoop(compiler, config).run()
-    else
-      ctx.error(s"don't now what to do with $fileNames%, %")
-    ctx.reporter
-  }
-}
-
-object REPL {
-  class Config {
-    val prompt             = "scala> "
-    val continuationPrompt = "       "
-    val version            = ".next (pre-alpha)"
-
-    def context(ctx: Context): Context = ctx
-
-    /** The first interpreted commands always take a couple of seconds due to
-     *  classloading. To bridge the gap, we warm up the interpreter by letting
-     *  it interpret at least a dummy line while waiting for the first line of
-     *  input to be entered.
-     */
-    val initialCommands: List[String] =
-      "val theAnswerToLifeInTheUniverseAndEverything = 21 * 2" :: Nil
-
-    /** Before exiting, the interpreter will also run the cleanup commands
-     *  issued in the variable below. This is useful if your REPL creates
-     *  things during its run that should be dealt with before shutdown.
-     */
-    val cleanupCommands: List[String] = Nil
-
-    /** Initial values in the REPL can also be bound from runtime. Override
-     *  this variable in the following manner to bind a variable at the start
-     *  of the REPL session:
-     *
-     *  {{{
-     *  override val boundValues = Array("exampleList" -> List(1, 1, 2, 3, 5))
-     *  }}}
-     *
-     *  This is useful if you've integrated the REPL as part of your project
-     *  and already have objects available during runtime that you'd like to
-     *  inspect.
-     */
-    val boundValues: Array[(String, Any)] = Array.empty[(String, Any)]
-
-    /** To pass a custom ClassLoader to the Dotty REPL, overwride this value */
-    val classLoader: Option[ClassLoader] = None
-
-    /** The default input reader */
-    def input(in: Interpreter)(implicit ctx: Context): InteractiveReader = {
-      val emacsShell = System.getProperty("env.emacs", "") != ""
-      //println("emacsShell="+emacsShell) //debug
-      if (emacsShell) new SimpleReader()
-      else InteractiveReader.createDefault(in)
-    }
-
-    /** The default output writer */
-    def output: PrintWriter = new NewLinePrintWriter(new ConsoleWriter, true)
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/SimpleReader.scala b/compiler/src/dotty/tools/dotc/repl/SimpleReader.scala
deleted file mode 100644
index 5fab47bbe897..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/SimpleReader.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-
-import java.io.{BufferedReader, PrintWriter}
-import dotc.core.Contexts.Context
-
-
-/** Reads using standard JDK API */
-class SimpleReader(
-  in: BufferedReader,
-  out: PrintWriter,
-  val interactive: Boolean)
-extends InteractiveReader {
-  def this() = this(Console.in, new PrintWriter(Console.out), true)
-
-  def readLine(prompt: String) = {
-    if (interactive) {
-      out.print(prompt)
-      out.flush()
-    }
-    in.readLine()
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/Filter.scala b/compiler/src/dotty/tools/dotc/repl/ammonite/Filter.scala
deleted file mode 100644
index 9d34bb0f234b..000000000000
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/Filter.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-package dotty.tools
-package dotc
-package repl
-package ammonite.terminal
-
-object Filter {
-  def apply(id: String)(f: PartialFunction[TermInfo, TermAction]): Filter =
-    new Filter {
-      val op = f.lift
-      def identifier = id
-    }
-
-  def wrap(id: String)(f: TermInfo => Option[TermAction]): Filter =
-    new Filter {
-      val op = f
-      def identifier = id
-    }
-
-  /** Merges multiple [[Filter]]s into one. */
-  def merge(pfs: Filter*) = new Filter {
-    val op = (v1: TermInfo) => pfs.iterator.map(_.op(v1)).find(_.isDefined).flatten
-    def identifier = pfs.iterator.map(_.identifier).mkString(":")
-  }
-
-  val empty = Filter.merge()
-}
-
-/**
-  * The way you configure your terminal behavior; a trivial wrapper around a
-  * function, though you should provide a good `.toString` method to make
-  * debugging easier. The [[TermInfo]] and [[TermAction]] types are its
-  * interface to the terminal.
-  *
-  * [[Filter]]s are composed sequentially: if a filter returns `None` the next
-  * filter is tried, while if a filter returns `Some` that ends the cascade.
-  * While your `op` function interacts with the terminal purely through
-  * immutable case classes, the Filter itself is free to maintain its own state
-  * and mutate it whenever, even when returning `None` to continue the cascade.
-  */
-trait Filter {
-  val op: TermInfo => Option[TermAction]
-
-  /**
-    * the `.toString` of this object, except by making it separate we force
-    * the implementer to provide something and stop them from accidentally
-    * leaving it as the meaningless default.
-    */
-  def identifier: String
-  override def toString = identifier
-}
-
-/**
-  * A filter as an abstract class, letting you provide a [[filter]] instead of
-  * an `op`, automatically providing a good `.toString` for debugging, and
-  * providing a reasonable "place" inside the inheriting class/object to put
-  * state or helpers or other logic associated with the filter.
-  */
-abstract class DelegateFilter() extends Filter {
-  def filter: Filter
-  val op = filter.op
-}
diff --git a/compiler/test/dotty/tools/DottyTest.scala b/compiler/test/dotty/tools/DottyTest.scala
index edae187a6b44..6d2076d0e85c 100644
--- a/compiler/test/dotty/tools/DottyTest.scala
+++ b/compiler/test/dotty/tools/DottyTest.scala
@@ -59,7 +59,6 @@ trait DottyTest extends ContextEscapeDetection {
 
   def checkCompile(checkAfterPhase: String, source: String)(assertion: (tpd.Tree, Context) => Unit): Context = {
     val c = compilerWithChecker(checkAfterPhase)(assertion)
-    c.rootContext(ctx)
     val run = c.newRun
     run.compile(source)
     run.runContext
@@ -67,7 +66,6 @@ trait DottyTest extends ContextEscapeDetection {
 
   def checkCompile(checkAfterPhase: String, sources: List[String])(assertion: (tpd.Tree, Context) => Unit): Context = {
     val c = compilerWithChecker(checkAfterPhase)(assertion)
-    c.rootContext(ctx)
     val run = c.newRun
     run.compile(sources)
     run.runContext
diff --git a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala
index 799c550ec7e9..4542db0d54a0 100644
--- a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala
+++ b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala
@@ -71,14 +71,12 @@ trait DottyBytecodeTest extends DottyTest {
   /** Checks source code from raw string */
   def checkBCode(source: String)(assertion: Directory => Unit) = {
     val comp = bCodeCheckingComp(new TestGenBCode(outPath(source)))(assertion)
-    comp.rootContext(ctx)
     comp.newRun.compile(source)
   }
 
   /** Checks actual _files_ referenced in `sources` list */
   def checkBCode(sources: List[String])(assertion: Directory => Unit) = {
     val comp = bCodeCheckingComp(new TestGenBCode(outPath(sources)))(assertion)
-    comp.rootContext(ctx)
     comp.newRun.compile(sources)
   }
 
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index a772434d1093..7c65516ba015 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -197,7 +197,7 @@ class CompilationTests extends ParallelTesting {
     compileDir("../compiler/src/dotty/tools/dotc/config", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/parsing", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/printing", picklingOptions) +
-    compileDir("../compiler/src/dotty/tools/dotc/repl", picklingOptions) +
+    compileDir("../repl/src/dotty/tools/repl", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/rewrite", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/transform", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/typer", picklingOptions) +
@@ -275,7 +275,6 @@ class CompilationTests extends ParallelTesting {
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/config", opt) +
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/parsing", opt) +
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/printing", opt) +
-        compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/repl", opt) +
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/reporting", opt) +
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/rewrite", opt) +
         compileShallowFilesInDir("../compiler/src/dotty/tools/dotc/transform", opt) +
diff --git a/compiler/test/dotty/tools/dotc/CompilerTest.scala b/compiler/test/dotty/tools/dotc/CompilerTest.scala
index 962afb96f16d..b32428362cb4 100644
--- a/compiler/test/dotty/tools/dotc/CompilerTest.scala
+++ b/compiler/test/dotty/tools/dotc/CompilerTest.scala
@@ -1,6 +1,5 @@
 package dotty.tools.dotc
 
-import repl.TestREPL
 import core.Contexts._
 import interfaces.Diagnostic.ERROR
 import reporting._
diff --git a/compiler/test/dotty/tools/dotc/repl/TestREPL.scala b/compiler/test/dotty/tools/dotc/repl/TestREPL.scala
deleted file mode 100644
index c79c02603b54..000000000000
--- a/compiler/test/dotty/tools/dotc/repl/TestREPL.scala
+++ /dev/null
@@ -1,90 +0,0 @@
-package dotty
-package tools.dotc
-package repl
-
-import core.Contexts.Context
-import collection.mutable
-import java.io.{StringWriter, PrintStream}
-import dotty.tools.io.{ PlainFile, Directory }
-import org.junit.Test
-
-/** A subclass of REPL used for testing.
- *  It takes a transcript of a REPL session in `script`. The transcript
- *  starts with the first input prompt `scala> ` and ends with `scala> :quit` and a newline.
- *  Invoking `process()` on the `TestREPL` runs all input lines and
- *  collects then interleaved with REPL output in a string writer `out`.
- *  Invoking `check()` checks that the collected output matches the original
- *  `script`.
- */
-class TestREPL(script: String) extends REPL {
-
-  private val out = new StringWriter()
-
-  override lazy val config = new REPL.Config {
-    override val output = new NewLinePrintWriter(out)
-
-    override def context(ctx: Context) = {
-      val fresh = ctx.fresh
-      fresh.setSetting(ctx.settings.color, "never")
-      fresh.setSetting(ctx.settings.classpath, Jars.dottyReplDeps.mkString(":"))
-      fresh.initialize()(fresh)
-      fresh
-    }
-
-    override def input(in: Interpreter)(implicit ctx: Context) = new InteractiveReader {
-      val lines = script.lines.buffered
-      def readLine(prompt: String): String = {
-        val line = lines.next()
-        val buf = new StringBuilder
-        if (line.startsWith(prompt)) {
-          output.println(line)
-          buf append line.drop(prompt.length)
-          while (lines.hasNext && lines.head.startsWith(continuationPrompt)) {
-            val continued = lines.next()
-            output.println(continued)
-            buf append System.lineSeparator()
-            buf append continued.drop(continuationPrompt.length)
-          }
-          buf.toString
-        }
-        else readLine(prompt)
-      }
-      val interactive = false
-    }
-  }
-
-  def check() = {
-    out.close()
-    val printed = out.toString
-    val transcript = printed.drop(printed.indexOf(config.prompt))
-    if (transcript.toString.lines.toList != script.lines.toList) {
-      println("input differs from transcript (copy is repl.transcript):")
-      println(transcript)
-      val s = new PrintStream("repl.transcript")
-      s.print(transcript)
-      s.close()
-      assert(false)
-    }
-  }
-}
-
-class REPLTests {
-  def replFile(prefix: String, fileName: String): Unit = {
-    val path = s"$prefix$fileName"
-    val f = new PlainFile(path)
-    val repl = new TestREPL(new String(f.toCharArray))
-    repl.process(Array[String]())
-    repl.check()
-  }
-
-  def replFiles(path: String): Unit = {
-    val dir = Directory(path)
-    val fileNames = dir.files.toArray.map(_.jfile.getName).filter(_ endsWith ".check")
-    for (name <- fileNames) {
-      println(s"testing $path$name")
-      replFile(path, name)
-    }
-  }
-
-  @Test def replAll = replFiles("../tests/repl/")
-}
diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
index a3901fbf8f0d..24b056b69653 100644
--- a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
+++ b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
@@ -373,10 +373,8 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
 
       val driver =
-        if (times == 1) new Driver { def newCompiler(implicit ctx: Context) = new Compiler }
+        if (times == 1) new Driver
         else new Driver {
-          def newCompiler(implicit ctx: Context) = new Compiler
-
           private def ntimes(n: Int)(op: Int => Reporter): Reporter =
             (emptyReporter /: (1 to n)) ((_, i) => op(i))
 
diff --git a/doc-tool/test/DottyDocTest.scala b/doc-tool/test/DottyDocTest.scala
index 4535b772b73b..ae515a68a144 100644
--- a/doc-tool/test/DottyDocTest.scala
+++ b/doc-tool/test/DottyDocTest.scala
@@ -80,21 +80,18 @@ trait DottyDocTest extends MessageRendering {
 
   def checkSource(source: String)(assertion: Map[String, Package] => Unit): Unit = {
     val c = compilerWithChecker(assertion)
-    c.rootContext(ctx)
     val run = c.newRun
     run.compileSources(sourceFileFromString(callingMethod, source) :: Nil)
   }
 
   def checkFiles(sources: List[String])(assertion: Map[String, Package] => Unit): Unit = {
     val c = compilerWithChecker(assertion)
-    c.rootContext(ctx)
     val run = c.newRun
     run.compile(sources)
   }
 
   def checkSources(sourceFiles: List[SourceFile])(assertion: Map[String, Package] => Unit): Unit = {
     val c = compilerWithChecker(assertion)
-    c.rootContext(ctx)
     val run = c.newRun
     run.compileSources(sourceFiles)
   }
diff --git a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala
index 1dcac81137ea..10445ac00bd1 100644
--- a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala
+++ b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala
@@ -200,7 +200,7 @@ class DottyLanguageServer extends LanguageServer
     implicit val ctx = driver.currentCtx
 
     val pos = sourcePosition(driver, uri, params.getPosition)
-    val items = Interactive.completions(driver.openedTrees(uri), pos)
+    val items = Interactive.completions(driver.openedTrees(uri), pos)._2
 
     JEither.forRight(new CompletionList(
       /*isIncomplete = */ false, items.map(completionItem).asJava))
diff --git a/project/Build.scala b/project/Build.scala
index 69229dbab7e7..fe0313f2c1ae 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -307,6 +307,9 @@ object Build {
     connectInput in run := true,
     outputStrategy := Some(StdoutOutput),
 
+    // enable verbose exception messages for JUnit
+    testOptions in Test += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
+
     javaOptions ++= (javaOptions in `dotty-compiler`).value,
     fork in run := true,
     fork in Test := true,
@@ -355,6 +358,47 @@ object Build {
     )
   )
 
+  lazy val `dotty-repl` = project.in(file("repl")).
+    dependsOn(
+      `dotty-compiler`,
+      `dotty-compiler` % "test->test"
+    ).
+    settings(commonNonBootstrappedSettings).
+    settings(
+      // set system in/out for repl
+      connectInput in run := true,
+      outputStrategy := Some(StdoutOutput),
+
+      // enable verbose exception messages for JUnit
+      testOptions in Test += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
+
+      resourceDirectory in Test := baseDirectory.value / "test-resources",
+
+      run := Def.inputTaskDyn {
+        val classPath =
+          (packageAll in `dotty-compiler-bootstrapped`).value("dotty-library") + ":" +
+          (packageAll in `dotty-compiler-bootstrapped`).value("dotty-interfaces")
+
+        val args: Seq[String] = spaceDelimited("<arg>").parsed
+
+        val fullArgs = args.span(_ != "-classpath") match {
+          case (beforeCp, Nil) => beforeCp ++ ("-classpath" :: classPath :: Nil)
+          case (beforeCp, rest) => beforeCp ++ rest
+        }
+
+        (runMain in Compile).toTask(
+          s" dotty.tools.repl.Main " + fullArgs.mkString(" ")
+        )
+      }.evaluated,
+
+      repl := run.evaluated,
+
+      javaOptions ++= (javaOptions in `dotty-compiler`).value,
+      fork in run := true,
+      fork in Test := true,
+      parallelExecution in Test := false
+    )
+
   lazy val `dotty-doc` = project.in(file("doc-tool")).
     dependsOn(`dotty-compiler`, `dotty-compiler` % "test->test").
     settings(commonNonBootstrappedSettings).
@@ -473,6 +517,13 @@ object Build {
                                   "com.novocode" % "junit-interface" % "0.11" % "test",
                                   "org.scala-lang" % "scala-library" % scalacVersion % "test"),
 
+      // Repl subproject shouldn't be distributed on its own yet, so the
+      // sources need to be included in the dotty compiler to be available to
+      // the sbt bridge
+      unmanagedSourceDirectories in Compile += baseDirectory.value / ".." / "repl" / "src",
+      unmanagedSourceDirectories in Test += baseDirectory.value / ".." / "repl" / "test",
+      unmanagedResourceDirectories in Test += baseDirectory.value / ".." / "repl" / "test-resources",
+
       // enable improved incremental compilation algorithm
       incOptions := incOptions.value.withNameHashing(true),
 
@@ -481,14 +532,6 @@ object Build {
       // .. but not when running test
       baseDirectory in (Test, run) := baseDirectory.value,
 
-      repl := Def.inputTaskDyn {
-        val args: Seq[String] = spaceDelimited("<arg>").parsed
-        val dottyLib = packageAll.value("dotty-library")
-        (runMain in Compile).toTask(
-          s" dotty.tools.dotc.repl.Main -classpath $dottyLib " + args.mkString(" ")
-        )
-      }.evaluated,
-
       test in Test := {
         // Exclude legacy tests by default
         (testOnly in Test).toTask(" -- --exclude-categories=java.lang.Exception").value
diff --git a/compiler/src/dotty/tools/dotc/repl/AbstractFileClassLoader.scala b/repl/src/dotty/tools/repl/AbstractFileClassLoader.scala
similarity index 83%
rename from compiler/src/dotty/tools/dotc/repl/AbstractFileClassLoader.scala
rename to repl/src/dotty/tools/repl/AbstractFileClassLoader.scala
index a3a463717311..42330cf7a52f 100644
--- a/compiler/src/dotty/tools/dotc/repl/AbstractFileClassLoader.scala
+++ b/repl/src/dotty/tools/repl/AbstractFileClassLoader.scala
@@ -1,5 +1,4 @@
 package dotty.tools
-package dotc
 package repl
 
 import io.AbstractFile
@@ -28,4 +27,10 @@ extends ClassLoader(parent)
     val bytes = file.toByteArray
     defineClass(name, bytes, 0, bytes.length)
   }
+
+  override def loadClass(name: String): Class[_] =
+    try findClass(name)
+    catch {
+      case _: ClassNotFoundException => super.loadClass(name)
+    }
 }
diff --git a/repl/src/dotty/tools/repl/AmmoniteReader.scala b/repl/src/dotty/tools/repl/AmmoniteReader.scala
new file mode 100644
index 000000000000..ffbc7e61d100
--- /dev/null
+++ b/repl/src/dotty/tools/repl/AmmoniteReader.scala
@@ -0,0 +1,142 @@
+package dotty.tools
+package repl
+
+import java.io.{
+  InputStream, InputStreamReader, OutputStream, OutputStreamWriter
+}
+
+import dotc.core.Contexts.Context
+import dotc.printing.SyntaxHighlighting
+import dotc.printing.Highlighting
+import dotc.interactive.InteractiveDriver
+
+import terminal._
+import terminal.filters._
+import GUILikeFilters._
+import LazyList._
+import AmmoniteReader._
+
+/** Adaptation of the Ammonite shell emulator to fit the Dotty REPL
+ *
+ *  Credit for the code in the `terminal` goes to Li Haoyi
+ *  who wrote most of it as part of Ammonite.
+ *
+ *  @param history is a list of the previous input with the latest entry as head
+ *  @param complete takes a function from cursor point and input string to
+ *                  `Completions`
+ */
+private[repl] class AmmoniteReader(out: OutputStream,
+                                   history: History,
+                                   complete: (Int, String) => Completions)
+                                  (implicit ctx: Context) {
+
+  private[this] val reader = new InputStreamReader(System.in)
+  private[this] val writer = new OutputStreamWriter(out)
+
+  private[this] val cutPasteFilter  = ReadlineFilters.CutPasteFilter()
+  private[this] val selectionFilter = GUILikeFilters.SelectionFilter(indent = 2)
+  private[this] val multilineFilter = Filter.partial("multilineFilter") {
+    case TermState(lb ~: rest, b, c, d) if (lb == 10 || lb == 13) =>
+      val source = b.mkString
+
+      if (ParseResult.isIncomplete(source))
+        BasicFilters.injectNewLine(b, c, rest, indent = 2)
+      else
+        Result(source) // short-circuit the filters
+  }
+
+  /** Blockingly read line from `System.in`
+   *
+   *  This entry point into Ammonite handles everything to do with terminal
+   *  emulation. This includes:
+   *
+   *  - Multiline support
+   *  - Copy-pasting
+   *  - History
+   *  - Syntax highlighting
+   *
+   *  To facilitate this, filters are used. The terminal emulation, however,
+   *  does not render output - simply input.
+   */
+  def prompt: ParseResult = {
+    val historyFilter = new HistoryFilter(
+      () => history.toVector,
+      Console.BLUE,
+      AnsiNav.resetForegroundColor
+    )
+
+    val autocompleteFilter: Filter = Filter.action("autocompleteFilter")(SpecialKeys.Tab :: Nil) {
+      case TermState(rest, b, c, _) =>
+        val Completions(newCursor, completions, details) = complete(c, b.mkString)
+        lazy val prefixDetails = FrontEndUtils.findPrefix(details)
+        val details2 = details.map { det =>
+          val (left, right) = det.splitAt(prefixDetails.length)
+          (Highlighting.Green(left) + Highlighting.Cyan(right)).toString
+        }
+
+        lazy val prefixComp = FrontEndUtils.findPrefix(completions)
+        val completions2: Seq[String] = for(comp <- completions) yield {
+          val (left, right) = comp.splitAt(prefixComp.length)
+          (Highlighting.Green(left).toString ++ right)
+        }
+
+        val stdout = FrontEndUtils.printCompletions(completions2, details2).mkString
+
+        if (details.nonEmpty || completions.isEmpty)
+          Printing(TermState(rest, b, c), stdout)
+        else {
+          val newBuffer = b.take(newCursor) ++ prefixComp ++ b.drop(c)
+          Printing(TermState(rest, newBuffer, newCursor + prefixComp.length), stdout)
+        }
+    }
+
+    val allFilters = Filter.merge(
+      UndoFilter(),
+      historyFilter,
+      selectionFilter,
+      GUILikeFilters.altFilter,
+      GUILikeFilters.fnFilter,
+      ReadlineFilters.navFilter,
+      cutPasteFilter,
+      autocompleteFilter,
+      multilineFilter,
+      BasicFilters.all
+    )
+
+    def displayTransform(buffer: Vector[Char], cursor: Int): (Ansi.Str, Int) = {
+      val coloredBuffer =
+        SyntaxHighlighting(buffer)
+
+      val ansiBuffer = Ansi.Str.parse(coloredBuffer.toVector)
+      val (newBuffer, cursorOffset) = SelectionFilter.mangleBuffer(
+        selectionFilter, ansiBuffer, cursor, Ansi.Reversed.On
+      )
+      val newNewBuffer = HistoryFilter.mangleBuffer(
+        historyFilter, newBuffer, cursor,
+        Ansi.Color.Green
+      )
+
+      (newNewBuffer, cursorOffset)
+    }
+
+    val prompt = Console.BLUE + "scala> " + Console.RESET
+
+    Terminal
+      .readLine(prompt, reader, writer, allFilters, displayTransform)
+      .map {
+        case Result(source) => ParseResult(source)
+        case Interrupt => SigKill
+      }
+      .getOrElse(Quit)
+  }
+}
+
+object AmmoniteReader {
+  type History = List[String]
+
+  def apply(out: OutputStream,
+            history: History,
+            complete: (Int, String) => Completions)
+           (implicit ctx: Context) =
+    new AmmoniteReader(out, history, complete)
+}
diff --git a/repl/src/dotty/tools/repl/Main.scala b/repl/src/dotty/tools/repl/Main.scala
new file mode 100644
index 000000000000..725395dcdb3c
--- /dev/null
+++ b/repl/src/dotty/tools/repl/Main.scala
@@ -0,0 +1,7 @@
+package dotty.tools.repl
+
+/** Main entry point to the REPL */
+object Main {
+  def main(args: Array[String]): Unit =
+    new ReplDriver(args).runUntilQuit()
+}
diff --git a/repl/src/dotty/tools/repl/ParseResult.scala b/repl/src/dotty/tools/repl/ParseResult.scala
new file mode 100644
index 000000000000..e2ad3f3609e9
--- /dev/null
+++ b/repl/src/dotty/tools/repl/ParseResult.scala
@@ -0,0 +1,148 @@
+package dotty.tools
+package repl
+
+import dotc.reporting.diagnostic.MessageContainer
+import dotc.core.Contexts.Context
+import dotc.parsing.Parsers.Parser
+import dotc.util.SourceFile
+import dotc.ast.untpd
+import dotc.reporting._
+
+import results._
+
+/** A parsing result from string input */
+sealed trait ParseResult
+
+/** An error free parsing resulting in a list of untyped trees */
+case class Parsed(sourceCode: String, trees: List[untpd.Tree]) extends ParseResult
+
+/** A parsing result containing syntax `errors` */
+case class SyntaxErrors(sourceCode: String,
+                        errors: List[MessageContainer],
+                        trees: List[untpd.Tree]) extends ParseResult
+
+/** Parsed result is simply a newline */
+case object Newline extends ParseResult
+
+/** `ctrl-c` obtained from input string */
+case object SigKill extends ParseResult
+
+/** A command is on the format:
+ *
+ *  ```none
+ *  :commandName <optional arguments...>
+ *  ```
+ *  The `Command` trait denotes these commands
+ */
+sealed trait Command extends ParseResult
+
+/** An unknown command that will not be handled by the REPL */
+case class UnknownCommand(cmd: String) extends Command
+
+/** `:load <path>` interprets a scala file as if entered line-by-line into
+ *  the REPL
+ */
+case class Load(path: String) extends Command
+object Load {
+  val command = ":load"
+}
+
+/** To find out the type of an expression you may simply do:
+ *
+ * ```
+ * scala> :type (1 * 54).toString
+ * String
+ * ```
+ */
+case class TypeOf(expr: String) extends Command
+object TypeOf {
+  val command = ":type"
+}
+
+/** `:imports` lists the imports that have been explicitly imported during the
+ *  session
+ */
+case object Imports extends Command {
+  val command = ":imports"
+}
+
+/** Reset the session to the initial state from when the repl program was
+ *  started
+ */
+case object Reset extends Command {
+  val command = ":reset"
+}
+
+/** `:quit` exits the repl */
+case object Quit extends Command {
+  val command = ":quit"
+}
+
+/** `:help` shows the different commands implemented by the Dotty repl */
+case object Help extends Command {
+  val command = ":help"
+  val text =
+    """The REPL has several commands available:
+      |
+      |:help                    print this summary
+      |:load <path>             interpret lines in a file
+      |:quit                    exit the interpreter
+      |:type <expression>       evaluate the type of the given expression
+      |:imports                 show import history
+      |:reset                   reset the repl to its initial state, forgetting all session entries
+    """.stripMargin
+}
+
+object ParseResult {
+
+  private[this] val CommandExtract = """(:[\S]+)\s*(.*)""".r
+
+  /** Extract a `ParseResult` from the string `sourceCode` */
+  def apply(sourceCode: String)(implicit ctx: Context): ParseResult =
+    sourceCode match {
+      case "" => Newline
+      case CommandExtract(cmd, arg) => cmd match {
+        case Quit.command => Quit
+        case Help.command => Help
+        case Reset.command => Reset
+        case Imports.command => Imports
+        case Load.command => Load(arg)
+        case TypeOf.command => TypeOf(arg)
+        case _ => UnknownCommand(cmd)
+      }
+      case _ => {
+        val source = new SourceFile("<console>", sourceCode.toCharArray)
+        val parser = new Parser(source)
+
+        val (_, stats) = parser.templateStatSeq()
+
+        if (ctx.reporter.hasErrors) {
+          SyntaxErrors(sourceCode,
+                       ctx.flushBufferedMessages(),
+                       stats)
+        }
+        else
+          Parsed(sourceCode, stats)
+      }
+    }
+
+  /** Check if the input is incomplete
+   *
+   *  This can be used in order to check if a newline can be inserted without
+   *  having to evaluate the expression
+   */
+  def isIncomplete(sourceCode: String)(implicit ctx: Context): Boolean =
+    sourceCode match {
+      case CommandExtract(_) | "" => false
+      case _ => {
+        val reporter = storeReporter
+        var needsMore = false
+        reporter.withIncompleteHandler(_ => _ => needsMore = true) {
+          val source = new SourceFile("<console>", sourceCode.toCharArray)
+          val parser = new Parser(source)(ctx.fresh.setReporter(reporter))
+          parser.templateStatSeq()
+          !reporter.hasErrors && needsMore
+        }
+      }
+    }
+}
diff --git a/repl/src/dotty/tools/repl/Rendering.scala b/repl/src/dotty/tools/repl/Rendering.scala
new file mode 100644
index 000000000000..1f7167845b4e
--- /dev/null
+++ b/repl/src/dotty/tools/repl/Rendering.scala
@@ -0,0 +1,79 @@
+package dotty.tools
+package repl
+
+import java.lang.ClassLoader
+
+import scala.util.control.NonFatal
+
+import dotc.core.Types._
+import dotc.core.Contexts.Context
+import dotc.core.Denotations.Denotation
+import dotc.core.Flags
+import dotc.core.Symbols.Symbol
+import dotc.core.StdNames.str
+
+/** This rendering object uses `ClassLoader`s to accomplish crossing the 4th
+ *  wall (i.e. fetching back values from the compiled class files put into a
+ *  specific class loader capable of loading from memory) and rendering them.
+ *
+ *  @pre this object should be paired with a compiler session, i.e. when
+ *       `ReplDriver#resetToInitial` is called, the accompanying instance of
+ *       `Rendering` is no longer valid.
+ */
+private[repl] class Rendering(compiler: ReplCompiler,
+                              private var currentClassLoader: Option[ClassLoader] = None) {
+
+  private def classLoader()(implicit ctx: Context) =
+    currentClassLoader.getOrElse {
+      import java.net.{URL, URLClassLoader}
+
+      /** the compiler's classpath, as URL's */
+      val compilerClasspath: Seq[URL] = ctx.platform.classPath(ctx).asURLs
+
+      def parent = new URLClassLoader(compilerClasspath.toArray,
+                                      classOf[ReplDriver].getClassLoader)
+
+      val newClsLoader = new AbstractFileClassLoader(compiler.directory,
+                                  currentClassLoader.getOrElse(parent))
+
+      Thread.currentThread.setContextClassLoader(newClsLoader)
+      currentClassLoader = Some(newClsLoader)
+      newClsLoader
+    }
+
+  /** Load the value of the symbol using reflection
+   *
+   *  Calling this method evaluates the expression using reflection
+   */
+  private[this] def valueOf(sym: Symbol)(implicit ctx: Context): Option[String] = {
+    val defn = ctx.definitions
+    val objectName = sym.owner.fullName.encode.toString.dropRight(1) // gotta drop the '$'
+    val resObj: Class[_] = Class.forName(objectName, true, classLoader())
+
+    val res =
+      resObj
+        .getDeclaredMethods.find(_.getName == sym.name.toString + "Show").get
+        .invoke(null).toString
+
+    if (!sym.is(Flags.Method) && sym.info == defn.UnitType)
+      None
+    else if (res.startsWith(str.REPL_SESSION_LINE))
+      Some(res.drop(str.REPL_SESSION_LINE.length).dropWhile(c => c.isDigit || c == '$'))
+    else
+      Some(res)
+  }
+
+  /** Render method definition result */
+  def renderMethod(d: Denotation)(implicit ctx: Context): String =
+    d.symbol.showUser
+
+  /** Render value definition result */
+  def renderVal(d: Denotation)(implicit ctx: Context): Option[String] = {
+    val dcl = d.symbol.showUser
+    val resultValue =
+      if (d.symbol.is(Flags.Lazy)) Some("<lazy>")
+      else valueOf(d.symbol)
+
+    resultValue.map(value => s"$dcl = $value")
+  }
+}
diff --git a/repl/src/dotty/tools/repl/ReplCompiler.scala b/repl/src/dotty/tools/repl/ReplCompiler.scala
new file mode 100644
index 000000000000..e1a649c1258c
--- /dev/null
+++ b/repl/src/dotty/tools/repl/ReplCompiler.scala
@@ -0,0 +1,296 @@
+package dotty.tools
+package repl
+
+import java.io.{ File => JFile }
+
+import dotc.ast.Trees._
+import dotc.ast.{ untpd, tpd }
+import dotc.{ Run, CompilationUnit, Compiler }
+import dotc.core.Decorators._, dotc.core.Flags._, dotc.core.Phases
+import dotc.core.Names._, dotc.core.Contexts._, dotc.core.StdNames._
+import dotc.core.Constants.Constant
+import dotc.util.SourceFile
+import dotc.typer.{ ImportInfo, FrontEnd }
+import backend.jvm.GenBCode
+import dotc.core.NameOps._
+import dotc.util.Positions._
+import dotc.reporting.diagnostic.{ messages, MessageContainer }
+import dotc.reporting._
+import io._
+
+import results._
+
+/** This subclass of `Compiler` replaces the appropriate phases in order to
+ *  facilitate the REPL
+ *
+ *  Specifically it replaces the front end with `REPLFrontEnd`, and adds a
+ *  custom subclass of `GenBCode`. The custom `GenBCode`, `REPLGenBCode`, works
+ *  in conjunction with a specialized class loader in order to load virtual
+ *  classfiles.
+ */
+class ReplCompiler(val directory: AbstractFile) extends Compiler {
+
+
+  /** A GenBCode phase that outputs to a virtual directory */
+  private class REPLGenBCode extends GenBCode {
+    override def phaseName = "replGenBCode"
+    override def outputDir(implicit ctx: Context) = directory
+  }
+
+  override def phases = {
+    val replacedFrontend = Phases.replace(
+      classOf[FrontEnd],
+      _ => new REPLFrontEnd :: Nil,
+      super.phases
+    )
+
+    Phases.replace(
+      classOf[GenBCode],
+      _ => new REPLGenBCode :: Nil,
+      replacedFrontend
+    )
+  }
+
+  private[this] var objectNames = Map.empty[Int, TermName]
+  private def objectName(state: State) =
+    objectNames.get(state.objectIndex).getOrElse {
+      val newName = (str.REPL_SESSION_LINE + state.objectIndex).toTermName
+      objectNames = objectNames + (state.objectIndex -> newName)
+      newName
+    }
+
+  sealed case class Definitions(stats: List[untpd.Tree], state: State)
+
+  def definitions(trees: List[untpd.Tree], state: State): Result[Definitions] = {
+    import untpd._
+
+    implicit val ctx: Context = state.run.runContext
+
+    def createShow(name: TermName, pos: Position) = {
+      val showName = name ++ "Show"
+      val select = Select(Ident(name), "show".toTermName)
+      val valAsAnyRef = TypeApply(Select(Ident(name), nme.asInstanceOf_),
+                                  List(Ident(tpnme.AnyRef)))
+      val cond = InfixOp(valAsAnyRef,
+                         Ident(nme.EQ),
+                         Literal(Constant(null)))
+      val showWithNullCheck = If(cond, Literal(Constant("null")), select)
+      DefDef(showName, Nil, Nil, TypeTree(), showWithNullCheck).withFlags(Synthetic).withPos(pos)
+    }
+
+    val (exps, other) = trees.partition(_.isTerm)
+    val resX = exps.zipWithIndex.flatMap { case (exp, i) =>
+      val resName = (str.REPL_RES_PREFIX + (i + state.valIndex)).toTermName
+      val show = createShow(resName, exp.pos)
+
+      exp match {
+        case exp @ Assign(id: Ident, rhs) =>
+          val assignName = (id.name ++ str.REPL_ASSIGN_SUFFIX).toTermName
+          val assign = ValDef(assignName, TypeTree(), id).withPos(exp.pos)
+
+          exp :: assign :: createShow(assignName, exp.pos) :: Nil
+        case _ =>
+          List(ValDef(resName, TypeTree(), exp).withPos(exp.pos), show)
+      }
+    }
+
+    val othersWithShow = other.flatMap {
+      case t: ValDef =>
+        List(t, createShow(t.name, t.pos))
+      case t: PatDef => {
+        val variables = t.pats.flatMap {
+          case Ident(name) if name != nme.WILDCARD => List((name.toTermName, t.pos))
+          case pat =>
+            new UntypedDeepFolder[List[(TermName, Position)]](
+            (acc: List[(TermName, Position)], t: Tree) => t match {
+              case _: BackquotedIdent =>
+                acc
+              case Ident(name) if name.isVariableName && name.toString != "_" =>
+                (name.toTermName, t.pos) :: acc
+              case Bind(name, _) if name.isVariableName =>
+                (name.toTermName, t.pos) :: acc
+              case _ =>
+                acc
+            }
+          ).apply(Nil, pat).reverse
+        }
+
+        t :: variables.map { case (name, pos) => createShow(name, pos) }
+      }
+      case t => List(t)
+    }
+
+    val newObjectIndex = state.objectIndex + {
+      if (resX.nonEmpty || othersWithShow.nonEmpty) 1 else 0
+    }
+    val newValIndex = state.valIndex + exps.filterNot(_.isInstanceOf[Assign]).length
+
+    Definitions(
+      state.imports.map(_._1) ++ resX ++ othersWithShow,
+      state.copy(objectIndex = newObjectIndex, valIndex = newValIndex)
+    ).result
+  }
+
+  /** Wrap trees in an object and add imports from the previous compilations
+   *
+   *  The resulting structure is something like:
+   *
+   *  ```
+   *  package <none> {
+   *    object rs$line$nextId {
+   *      import rs$line${i <- 0 until nextId}._
+   *      import dotty.Show._
+   *
+   *      <trees>
+   *    }
+   *  }
+   *  ```
+   */
+  def wrapped(defs: Definitions): untpd.PackageDef = {
+    import untpd._
+
+    implicit val ctx: Context = defs.state.run.runContext
+
+    val module = {
+      val tmpl = Template(emptyConstructor(ctx), Nil, EmptyValDef, defs.stats)
+      List(
+        ModuleDef(objectName(defs.state), tmpl)
+          .withMods(new Modifiers(Module | Final))
+          .withPos(Position(defs.stats.head.pos.start, defs.stats.last.pos.end))
+      )
+    }
+
+    PackageDef(Ident(nme.EMPTY_PACKAGE), module)
+  }
+
+  def newRun(initCtx: Context, objectIndex: Int) = new Run(this, initCtx) {
+    override protected[this] def rootContext(implicit ctx: Context) =
+      addMagicImports(super.rootContext.fresh.setReporter(storeReporter), objectIndex)
+  }
+
+  def createUnit(defs: Definitions, sourceCode: String): Result[CompilationUnit] = {
+    val unit = new CompilationUnit(new SourceFile(objectName(defs.state).toString, sourceCode))
+    unit.untpdTree = wrapped(defs)
+    unit.result
+  }
+
+  def runCompilation(unit: CompilationUnit, state: State): Result[State] = {
+    val run = state.run
+    val reporter = state.run.runContext.reporter
+    run.compileUnits(unit :: Nil)
+
+    if (!reporter.hasErrors) state.result
+    else run.runContext.flushBufferedMessages().errors
+  }
+
+  def compile(parsed: Parsed)(implicit state: State): Result[(CompilationUnit, State)] = {
+    for {
+      defs  <- definitions(parsed.trees, state)
+      unit  <- createUnit(defs, parsed.sourceCode)
+      state <- runCompilation(unit, defs.state)
+    } yield (unit, state)
+  }
+
+  private[this] def addMagicImports(initCtx: Context, objectIndex: Int): Context = {
+    def addImport(path: TermName)(implicit ctx: Context) = {
+      val ref = tpd.ref(ctx.requiredModuleRef(path.toTermName))
+      val symbol = ctx.newImportSymbol(ctx.owner, ref)
+      val importInfo =
+        new ImportInfo(implicit ctx => symbol, untpd.Ident(nme.WILDCARD) :: Nil, None)
+      ctx.fresh.setNewScope.setImportInfo(importInfo)
+    }
+
+    List
+      .range(1, objectIndex + 1)
+      .foldLeft(addImport("dotty.Show".toTermName)(initCtx)) { (ictx, i) =>
+        addImport(nme.EMPTY_PACKAGE ++ "." ++ objectNames(i))(ictx)
+      }
+  }
+
+  def typeOf(expr: String)(implicit state: State): Result[String] =
+    typeCheck(expr).map { tree =>
+      import dotc.ast.Trees._
+      implicit val ctx = state.run.runContext
+      tree.rhs match {
+        case Block(xs, _) => xs.last.tpe.widen.show
+        case _ =>
+          """Couldn't compute the type of your expression, so sorry :(
+            |
+            |Please report this to my masters at Github.com/lampepfl/dotty
+          """.stripMargin
+      }
+    }
+
+  def typeCheck(expr: String, errorsAllowed: Boolean = false)(implicit state: State): Result[tpd.ValDef] = {
+
+    def wrapped(expr: String, sourceFile: SourceFile, state: State)(implicit ctx: Context): Result[untpd.PackageDef] = {
+      def wrap(trees: Seq[untpd.Tree]): untpd.PackageDef = {
+        import untpd._
+
+        val valdef =
+          ValDef("expr".toTermName, TypeTree(), Block(trees.toList, untpd.unitLiteral))
+
+        val tmpl = Template(emptyConstructor,
+                            List(Ident(tpnme.Any)),
+                            EmptyValDef,
+                            state.imports.map(_._1) :+ valdef)
+
+        PackageDef(Ident(nme.EMPTY_PACKAGE),
+          TypeDef("EvaluateExpr".toTypeName, tmpl)
+            .withMods(new Modifiers(Final))
+            .withPos(Position(trees.head.pos.start, trees.last.pos.end)) :: Nil
+        )
+      }
+
+      ParseResult(expr) match {
+        case Parsed(sourceCode, trees) =>
+          wrap(trees).result
+        case SyntaxErrors(_, reported, trees) =>
+          if (errorsAllowed) wrap(trees).result
+          else reported.errors
+        case _ => List(
+          new messages.Error(
+            s"Couldn't parse '$expr' to valid scala",
+            sourceFile.atPos(Position(0, expr.length))
+          )
+        ).errors
+      }
+    }
+
+    def unwrapped(tree: tpd.Tree, sourceFile: SourceFile)(implicit ctx: Context): Result[tpd.ValDef] = {
+      def error: Result[tpd.ValDef] =
+        List(new messages.Error(s"Invalid scala expression",
+          sourceFile.atPos(Position(0, sourceFile.content.length)))).errors
+
+      import tpd._
+      tree match {
+        case PackageDef(_, List(TypeDef(_, tmpl: Template))) =>
+          tmpl.body
+              .collectFirst { case dd: ValDef if dd.name.show == "expr" => dd.result }
+              .getOrElse(error)
+        case _ =>
+          error
+      }
+    }
+
+
+    val run = state.run
+    val reporter = state.run.runContext.reporter
+    val src = new SourceFile(s"EvaluateExpr", expr)
+    val runCtx =
+      run.runContext.fresh
+         .setSetting(run.runContext.settings.YstopAfter, List("replFrontEnd"))
+
+    wrapped(expr, src, state)(runCtx).flatMap { pkg =>
+      val unit = new CompilationUnit(src)
+      unit.untpdTree = pkg
+      run.compileUnits(unit :: Nil, runCtx.fresh.setReporter(storeReporter))
+
+      if (errorsAllowed || !reporter.hasErrors)
+        unwrapped(unit.tpdTree, src)(runCtx)
+      else {
+        reporter.removeBufferedMessages(runCtx).errors
+      }
+    }
+  }
+}
diff --git a/repl/src/dotty/tools/repl/ReplDriver.scala b/repl/src/dotty/tools/repl/ReplDriver.scala
new file mode 100644
index 000000000000..e0ba8f9d78ee
--- /dev/null
+++ b/repl/src/dotty/tools/repl/ReplDriver.scala
@@ -0,0 +1,377 @@
+package dotty.tools
+package repl
+
+import java.io.{ InputStream, PrintStream }
+
+import scala.annotation.tailrec
+
+import dotc.reporting.MessageRendering
+import dotc.reporting.diagnostic.MessageContainer
+import dotc.ast.untpd
+import dotc.ast.tpd
+import dotc.interactive.{ SourceTree, Interactive }
+import dotc.core.Contexts.Context
+import dotc.{ CompilationUnit, Run }
+import dotc.core.Mode
+import dotc.core.Flags._
+import dotc.core.Types._
+import dotc.core.StdNames._
+import dotc.core.Names.Name
+import dotc.core.NameOps._
+import dotc.core.Symbols.{ Symbol, NoSymbol, defn }
+import dotc.core.Denotations.Denotation
+import dotc.core.Types.{ ExprType, ConstantType }
+import dotc.core.NameKinds.SimpleNameKind
+import dotc.config.CompilerCommand
+import dotc.{ Compiler, Driver }
+import dotc.printing.SyntaxHighlighting
+import dotc.util.Positions.Position
+import io._
+
+import AmmoniteReader._
+import results._
+
+/** The state of the REPL contains necessary bindings instead of having to have
+ *  mutation
+ *
+ *  The compiler in the REPL needs to do some wrapping in order to compile
+ *  valid code. This wrapping occurs when a single `MemberDef` that cannot be
+ *  top-level needs to be compiled. In order to do this, we need some unique
+ *  identifier for each of these wrappers. That identifier is `objectIndex`.
+ *
+ *  Free expressions such as `1 + 1` needs to have an assignment in order to be
+ *  of use. These expressions are therefore given a identifier on the format
+ *  `resX` where `X` starts at 0 and each new expression that needs an
+ *  identifier is given the increment of the old identifier. This identifier is
+ *  `valIndex`.
+ *
+ *  @param objectIndex the index of the next wrapper
+ *  @param valIndex the index of next value binding for free expressions
+ *  @param history a list of user inputs as strings
+ *  @param imports a list of tuples of imports on tree form and shown form
+ *  @param run the latest run initiated at the start of interpretation. This
+ *             run and its context should be used in order to perform any
+ *             manipulation on `Tree`s and `Symbol`s.
+ */
+case class State(objectIndex: Int,
+                 valIndex: Int,
+                 history: History,
+                 imports: List[(untpd.Import, String)],
+                 run: Run) {
+
+  def withHistory(newEntry: String) = copy(history = newEntry :: history)
+
+  def withHistory(h: History) = copy(history = h)
+
+  def newRun(comp: ReplCompiler, rootCtx: Context): State =
+    copy(run = comp.newRun(rootCtx, objectIndex))
+}
+
+/** A list of possible completions at the index of `cursor`
+ *
+ *  @param cursor the index of the users cursor in the input
+ *  @param suggestions the suggested completions as a filtered list of strings
+ */
+case class Completions(cursor: Int,
+                       suggestions: List[String],
+                       details: List[String])
+
+/** Main REPL instance, orchestrating input, compilation and presentation */
+class ReplDriver(settings: Array[String],
+                 protected val out: PrintStream = System.out,
+                 protected val classLoader: Option[ClassLoader] = None) extends Driver {
+
+  /** Overridden to `false` in order to not have to give sources on the
+   *  commandline
+   */
+  override def sourcesRequired = false
+
+  /** Create a fresh and initialized context with IDE mode enabled */
+  private[this] def initialCtx = {
+    val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive)
+    val ictx = setup(settings.toArray, rootCtx)._2.fresh
+    ictx.base.initialize()(ictx)
+    ictx
+  }
+
+  /** the initial, empty state of the REPL session */
+  protected[this] def initState = State(0, 0, Nil, Nil, compiler.newRun(rootCtx, 0))
+
+  /** Reset state of repl to the initial state
+   *
+   *  This method is responsible for performing an all encompassing reset. As
+   *  such, when the user enters `:reset` this method should be called to reset
+   *  everything properly
+   */
+  protected[this] def resetToInitial(): Unit = {
+    rootCtx = initialCtx
+    val outDir: AbstractFile = {
+      if (rootCtx.settings.d.isDefault(rootCtx))
+        new VirtualDirectory("(memory)", None)
+      else
+        new PlainDirectory(new Directory(new JFile(rootCtx.settings.d.value(rootCtx))))
+    }
+    compiler = new ReplCompiler(outDir)
+    rendering = new Rendering(compiler, classLoader)
+  }
+
+  protected[this] var rootCtx: Context = _
+  protected[this] var compiler: ReplCompiler = _
+  protected[this] var rendering: Rendering = _
+
+  // initialize the REPL session as part of the constructor so that once `run`
+  // is called, we're in business
+  resetToInitial()
+
+  /** Run REPL with `state` until `:quit` command found
+   *
+   *  This method is the main entry point into the REPL. Its effects are not
+   *  observable outside of the CLI, for this reason, most helper methods are
+   *  `protected final` to facilitate testing.
+   */
+  @tailrec final def runUntilQuit(state: State = initState): State = {
+    val res = readLine()(state)
+
+    if (res == Quit) state
+    else {
+      // readLine potentially destroys the run, so a new one is needed for the
+      // rest of the interpretation:
+      implicit val freshState = state.newRun(compiler, rootCtx)
+      runUntilQuit(interpret(res))
+    }
+  }
+
+  final def run(input: String)(implicit state: State): State =
+    run(ParseResult(input)(state.run.runContext))(state.newRun(compiler, rootCtx))
+
+  final def run(res: ParseResult)(implicit state: State): State =
+    interpret(res)
+
+  /** Extract possible completions at the index of `cursor` in `expr` */
+  protected[this] final def completions(cursor: Int, expr: String, state0: State): Completions = {
+    // TODO move some of this logic to `Interactive`
+    implicit val state = state0.newRun(compiler, rootCtx)
+    compiler
+      .typeCheck(expr, errorsAllowed = true)
+      .map { tree =>
+        implicit val ctx: Context = state.run.runContext
+        val file = new dotc.util.SourceFile("compl", expr)
+        val srcPos = dotc.util.SourcePosition(file, Position(cursor))
+        val (startOffset, completions) = Interactive.completions(SourceTree(tree, file) :: Nil, srcPos)(ctx)
+        val query =
+          if (startOffset < cursor) expr.substring(startOffset, cursor) else ""
+
+        def filterCompletions(name: String) =
+          (query == "." || name.startsWith(query)) && name != query
+
+
+        Completions(
+          Math.min(startOffset, cursor) + { if (query == ".") 1 else 0 },
+          completions.map(_.name.show).distinct.filter(filterCompletions),
+          Nil
+        )
+      }
+      .fold(_ => Completions(cursor, Nil, Nil), x => x)
+  }
+
+  /** Blockingly read a line, getting back a parse result and new history */
+  private def readLine()(implicit state: State): ParseResult =
+    AmmoniteReader(out, state.history, completions(_, _, state))(state.run.runContext).prompt
+
+  private def extractImports(trees: List[untpd.Tree])(implicit context: Context): List[(untpd.Import, String)] =
+    trees.collect { case imp: untpd.Import => (imp, imp.show) }
+
+  private def interpret(res: ParseResult)(implicit state: State): State =
+    res match {
+      case parsed: Parsed =>
+        compile(parsed)
+          .withHistory(parsed.sourceCode :: state.history)
+          .newRun(compiler, rootCtx)
+
+      case SyntaxErrors(src, errs, _) =>
+        displayErrors(errs)
+        state.withHistory(src :: state.history)
+
+      case Newline | SigKill => state
+
+      case cmd: Command => interpretCommand(cmd)
+    }
+
+  /** Compile `parsed` trees and evolve `state` in accordance */
+  protected[this] final def compile(parsed: Parsed)(implicit state: State): State = {
+    import dotc.ast.Trees.PackageDef
+    import untpd.{ PackageDef => _, _ }
+    def extractNewestWrapper(tree: Tree): Name = tree match {
+      case PackageDef(_, (obj: ModuleDef) :: Nil) => obj.name.moduleClassName
+      case _ => nme.NO_NAME
+    }
+
+    compiler
+      .compile(parsed)
+      .fold(
+        displayErrors,
+        {
+          case (unit: CompilationUnit, newState: State) => {
+            val newestWrapper = extractNewestWrapper(unit.untpdTree)
+            val newImports = newState.imports ++ extractImports(parsed.trees)(newState.run.runContext)
+            val newStateWithImports = newState.copy(imports = newImports)
+
+            displayDefinitions(unit.tpdTree, newestWrapper)(newStateWithImports)
+          }
+        }
+      )
+  }
+
+  /** Display definitions from `tree` */
+  private def displayDefinitions(tree: tpd.Tree, newestWrapper: Name)(implicit state: State): State = {
+    implicit val ctx = state.run.runContext
+
+    def resAndUnit(denot: Denotation) = {
+      import scala.util.{ Try, Success }
+      val sym = denot.symbol
+      val name = sym.name.show
+      val hasValidNumber = Try(name.drop(3).toInt) match {
+        case Success(num) => num < state.valIndex
+        case _ => false
+      }
+      name.startsWith(str.REPL_RES_PREFIX) && hasValidNumber && sym.info == defn.UnitType
+    }
+
+    def displayMembers(symbol: Symbol) = if (tree.symbol.info.exists) {
+      val info = symbol.info
+      val defs =
+        info.bounds.hi.finalResultType
+          .membersBasedOnFlags(Method, Accessor | ParamAccessor | Synthetic | Private)
+          .filterNot { denot =>
+            denot.symbol.owner == defn.AnyClass ||
+            denot.symbol.owner == defn.ObjectClass ||
+            denot.symbol.isConstructor
+          }
+
+      val vals =
+        info.fields
+          .filterNot(_.symbol.is(ParamAccessor | Private | Synthetic | Module))
+          .filter(_.symbol.name.is(SimpleNameKind))
+
+      val typeAliases =
+        info.bounds.hi.typeMembers.filter(_.symbol.info.isInstanceOf[TypeAlias])
+
+      (
+        typeAliases.map("// defined alias " + _.symbol.showUser) ++
+        defs.map(rendering.renderMethod) ++
+        vals.map(rendering.renderVal).flatten
+      ).foreach(str => out.println(SyntaxHighlighting(str)))
+
+      state.copy(valIndex = state.valIndex - vals.filter(resAndUnit).length)
+    }
+    else state
+
+    def isSyntheticCompanion(sym: Symbol) =
+      sym.is(Module) && sym.is(Synthetic)
+
+    def displayTypeDefs(sym: Symbol) = sym.info.memberClasses
+      .collect {
+        case x if !isSyntheticCompanion(x.symbol) && !x.symbol.name.isReplWrapperName =>
+          x.symbol
+      }
+      .foreach { sym =>
+        out.println(SyntaxHighlighting("// defined " + sym.showUser))
+      }
+
+
+    ctx.atPhase(ctx.typerPhase.next) { implicit ctx =>
+
+      // Display members of wrapped module:
+      tree.symbol.info.memberClasses
+        .find(_.symbol.name == newestWrapper.moduleClassName)
+        .map { wrapperModule =>
+          displayTypeDefs(wrapperModule.symbol)
+          displayMembers(wrapperModule.symbol)
+        }
+        .getOrElse {
+          // user defined a trait/class/object, so no module needed
+          state
+        }
+    }
+  }
+
+  /** Interpret `cmd` to action and propagate potentially new `state` */
+  private def interpretCommand(cmd: Command)(implicit state: State): State = cmd match {
+    case UnknownCommand(cmd) => {
+      out.println(s"""Unknown command: "$cmd", run ":help" for a list of commands""")
+      state.withHistory(s"$cmd")
+    }
+
+    case Help => {
+      out.println(Help.text)
+      state.withHistory(Help.command)
+    }
+
+    case Reset => {
+      resetToInitial()
+      initState
+    }
+
+    case Imports => {
+      state.imports foreach { case (_, i) => println(SyntaxHighlighting(i)) }
+      state.withHistory(Imports.command)
+    }
+
+    case Load(path) =>
+      val loadCmd = s"${Load.command} $path"
+      val file = new java.io.File(path)
+      if (file.exists) {
+        val contents = scala.io.Source.fromFile(path).mkString
+        ParseResult(contents)(state.run.runContext) match {
+          case parsed: Parsed =>
+            compile(parsed).withHistory(loadCmd)
+          case SyntaxErrors(_, errors, _) =>
+            displayErrors(errors).withHistory(loadCmd)
+          case _ =>
+            state.withHistory(loadCmd)
+        }
+      }
+      else {
+        out.println(s"""Couldn't find file "${file.getCanonicalPath}"""")
+        state.withHistory(loadCmd)
+      }
+
+    case TypeOf(expr) => {
+      compiler.typeOf(expr).fold(
+        displayErrors,
+        res => out.println(SyntaxHighlighting(res))
+      )
+      state.withHistory(s"${TypeOf.command} $expr")
+    }
+
+    case Quit =>
+      // end of the world!
+      state
+  }
+
+  /** A `MessageRenderer` without file positions */
+  private val messageRenderer = new MessageRendering {
+    import dotc.reporting.diagnostic._
+    import dotc.util._
+    override def messageAndPos(msg: Message, pos: SourcePosition, diagnosticLevel: String)(implicit ctx: Context): String = {
+      val sb = scala.collection.mutable.StringBuilder.newBuilder
+      if (pos.exists) {
+        val (srcBefore, srcAfter, offset) = sourceLines(pos)
+        val marker = columnMarker(pos, offset)
+        val err = errorMsg(pos, msg.msg, offset)
+        sb.append((srcBefore ::: marker :: err :: outer(pos, " " * (offset - 1)) ::: srcAfter).mkString("\n"))
+      }
+      sb.toString
+    }
+  }
+
+  /** Render messages using the `MessageRendering` trait */
+  private def renderMessage(cont: MessageContainer): Context => String =
+    messageRenderer.messageAndPos(cont.contained(), cont.pos, messageRenderer.diagnosticLevel(cont))(_)
+
+  /** Output errors to `out` */
+  private def displayErrors(errs: Seq[MessageContainer])(implicit state: State): State = {
+    errs.map(renderMessage(_)(state.run.runContext)).foreach(out.println)
+    state
+  }
+}
diff --git a/repl/src/dotty/tools/repl/ReplFrontEnd.scala b/repl/src/dotty/tools/repl/ReplFrontEnd.scala
new file mode 100644
index 000000000000..e02053dacd92
--- /dev/null
+++ b/repl/src/dotty/tools/repl/ReplFrontEnd.scala
@@ -0,0 +1,30 @@
+package dotty.tools
+package repl
+
+import dotc.typer.FrontEnd
+import dotc.CompilationUnit
+import dotc.core.Contexts.Context
+
+/** A customized `FrontEnd` for the REPL
+ *
+ *  This customized front end does not perform parsing as part of its `runOn`
+ *  method. This allows us to keep the parsing separate from the rest of the
+ *  compiler pipeline.
+ */
+private[repl] class REPLFrontEnd extends FrontEnd {
+  override def phaseName = "replFrontEnd"
+
+  override def isRunnable(implicit ctx: Context) = true
+
+  override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
+    val unitContexts = for (unit <- units) yield ctx.fresh.setCompilationUnit(unit)
+    var remaining = unitContexts
+    while (remaining.nonEmpty) {
+      enterSyms(remaining.head)
+      remaining = remaining.tail
+    }
+    unitContexts.foreach(enterAnnotations(_))
+    unitContexts.foreach(typeCheck(_))
+    unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
+  }
+}
diff --git a/repl/src/dotty/tools/repl/UserFacingPrinter.scala b/repl/src/dotty/tools/repl/UserFacingPrinter.scala
new file mode 100644
index 000000000000..ac2c3f48e5e5
--- /dev/null
+++ b/repl/src/dotty/tools/repl/UserFacingPrinter.scala
@@ -0,0 +1,139 @@
+package dotty.tools
+package repl
+
+import dotc.ast.Trees.{ Untyped, Tree }
+import dotc.core.Annotations.Annotation
+import dotc.core.Constants.Constant
+import dotc.core.Contexts.Context
+import dotc.core.Denotations.{ Denotation, MultiDenotation, SingleDenotation }
+import dotc.core.Flags._
+import dotc.core.TypeApplications.{ AppliedType, EtaExpansion }
+import dotc.core.Names._
+import dotc.core.NameOps._
+import dotc.core.StdNames._
+import dotc.core.Decorators._
+import dotc.core.Scopes.Scope
+import dotc.core.Symbols.{ Symbol, ClassSymbol, defn }
+import dotc.core.SymDenotations.NoDenotation
+import dotc.core.Types._
+import dotc.printing.Texts._
+import dotc.printing.{ GlobalPrec, DotPrec, Printer, PlainPrinter }
+import dotc.typer.Implicits.SearchResult
+import dotc.typer.ImportInfo
+
+class UserFacingPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
+
+  private def panic(msg: String): Nothing = throw new AssertionError(msg)
+
+  private[this] def getPkgCls(path: String) =
+    _ctx.requiredPackage(path).moduleClass.asClass
+
+  private lazy val collectionPkg = getPkgCls("scala.collection")
+  private lazy val immutablePkg  = getPkgCls("scala.collection.immutable")
+  private lazy val scalaPkg      = defn.ScalaPackageClass
+  private lazy val javaLangPkg   = defn.JavaLangPackageVal.moduleClass.asClass
+
+  def wellKnownPkg(pkgSym: Symbol) = pkgSym match {
+    case `scalaPkg` | `collectionPkg` | `immutablePkg` | `javaLangPkg` => true
+    case pkgSym =>
+      pkgSym.name.toTermName == nme.EMPTY_PACKAGE ||
+      pkgSym.name.isReplWrapperName
+  }
+
+  override protected def keyString(sym: Symbol): String = {
+    val flags = sym.flags
+    if (flags is Package) ""
+    else if (sym.isPackageObject) "package object"
+    else if (flags.is(Module) && flags.is(Case)) "case object"
+    else if (sym.isClass && flags.is(Case)) "case class"
+    else if (flags.is(Lazy)) "lazy val"
+    else if (flags is Module) "object"
+    else super.keyString(sym)
+  }
+
+  override def nameString(name: Name): String =
+    if (name.isReplAssignName) name.decode.toString.takeWhile(_ != '$')
+    else name.decode.toString
+
+  override def toText(sym: Symbol): Text =
+    if (sym.name.isReplAssignName) nameString(sym.name)
+    else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
+
+  override def dclText(sym: Symbol): Text =
+    toText(sym) ~ {
+      if (sym.is(Method)) toText(sym.info)
+      else if (sym.isClass) ""
+      else if (sym.isType && sym.info.isInstanceOf[TypeAlias]) " =" ~~ toText(sym.info)
+      else if (sym.isType) ""
+      else {
+        ":" ~~ toText(sym.info)
+      }
+    }
+
+  override def toText(denot: Denotation): Text = denot match {
+    case NoDenotation =>
+      panic("NoDenotation encountered in UserFacingPrinter")
+    case denot: MultiDenotation =>
+      panic("MultiDenotation not allowed in UserFacingPrinter")
+    case _ =>
+      toText(denot.symbol)
+  }
+
+  override def toText(const: Constant): Text = Str(const.value.toString)
+
+  override def toText(tp: Type): Text = tp match {
+    case tp: AnnotatedType => toText(tp.tpe) ~~ toText(tp.annot)
+    case tp: ConstantType => toText(tp.value)
+    case tp: TypeAlias => toText(tp.underlying)
+    case ExprType(result) => ":" ~~ toText(result)
+    case TypeBounds(lo, hi) => "_"
+    case tp: TypeRef => tp.info match {
+      case TypeAlias(alias) => toText(alias)
+      case _ => toText(tp.info)
+    }
+    case tp: ParamRef => {
+      val name = tp.paramName.unexpandedName.invariantName.toString
+      if (tp.isInstanceOf[TermParamRef]) name ~ ".type"
+      else name
+    }
+    case EtaExpansion(tycon) => toText(tycon)
+    case PolyType(params, res) =>
+      "[" ~ Fluid(params.map(tl => toText(tl.toArg)).intersperse(Str(", "))) ~ "]" ~ toText(res)
+    case tp: MethodType => {
+      def paramText(name: TermName, tp: Type) = toText(name) ~ ": " ~ toText(tp)
+      changePrec(GlobalPrec) {
+        (if (tp.isImplicit) "(implicit " else "(") ~
+          Text((tp.paramNames, tp.paramInfos).zipped map paramText, ", ") ~
+        (if (tp.resultType.isInstanceOf[MethodType]) ")" else "): ") ~
+        toText(tp.resultType)
+      }
+    }
+    case AppliedType(tycon, args) => {
+      def toTextInfixType(tycon: Type, args: List[Type]): Text = {
+        // TODO: blatant copy from `RefinedPrinter`
+        val l :: r :: Nil = args
+        val isRightAssoc = tycon.typeSymbol.name.endsWith(":")
+        val leftArg = if (isRightAssoc && l.isInfixType) "(" ~ toText(l) ~ ")" else toText(l)
+        val rightArg = if (!isRightAssoc && r.isInfixType) "(" ~ toText(r) ~ ")" else toText(r)
+        leftArg ~~ atPrec(DotPrec) { tycon.toText(this) } ~~ rightArg
+      }
+      if (tp.isInfixType) toTextInfixType(tycon, args)
+      else {
+        toText(tycon) ~ "[" ~ Fluid(args.reverse.map(toText).intersperse(Str(", "))) ~ "]"
+      }
+    }
+    case tp: ClassInfo => {
+      if (wellKnownPkg(tp.cls.owner))
+        nameString(tp.cls.name)
+      else {
+        def printPkg(sym: ClassSymbol): Text =
+          if (sym.owner == defn.RootClass) toText(sym)
+          else printPkg(sym.owner.asClass) ~ "." ~ toText(sym)
+
+        printPkg(tp.cls.owner.asClass) ~ "." ~ nameString(tp.cls.name)
+      }
+    }
+  }
+
+  override lazy val plain = new PlainPrinter(_ctx)
+}
diff --git a/repl/src/dotty/tools/repl/package.scala b/repl/src/dotty/tools/repl/package.scala
new file mode 100644
index 000000000000..f1fa141e0cb1
--- /dev/null
+++ b/repl/src/dotty/tools/repl/package.scala
@@ -0,0 +1,40 @@
+package dotty.tools
+
+import dotc.core.Contexts.Context
+import dotc.core.Symbols.Symbol
+import dotc.core.Denotations.Denotation
+import dotc.reporting.diagnostic.MessageContainer
+
+import dotc.reporting.{
+  StoreReporter,
+  UniqueMessagePositions,
+  HideNonSensicalMessages
+}
+
+package object repl {
+  /** Create empty outer store reporter */
+  private[repl] def storeReporter: StoreReporter =
+    new StoreReporter(null)
+    with UniqueMessagePositions with HideNonSensicalMessages
+
+  private[repl] implicit class ListOps[A](val nel: List[A]) extends AnyVal {
+    def intersperse(a: A): List[A] =
+      nel.flatMap(a :: _ :: Nil).tail
+  }
+
+  private[repl] implicit class ShowUser(val s: Symbol) extends AnyVal {
+    def showUser(implicit ctx: Context): String = {
+      val printer = new UserFacingPrinter(ctx)
+      val text = printer.dclText(s)
+      text.mkString(ctx.settings.pageWidth.value)
+    }
+  }
+
+  private[repl] implicit class StoreReporterContext(val ctx: Context) extends AnyVal {
+    def flushBufferedMessages(): List[MessageContainer] =
+      ctx.reporter match {
+        case rep: StoreReporter => rep.removeBufferedMessages(ctx)
+        case _ => Nil
+      }
+  }
+}
diff --git a/repl/src/dotty/tools/repl/results.scala b/repl/src/dotty/tools/repl/results.scala
new file mode 100644
index 000000000000..28c6fb2fd92a
--- /dev/null
+++ b/repl/src/dotty/tools/repl/results.scala
@@ -0,0 +1,24 @@
+package dotty.tools
+package repl
+
+import dotc.reporting.diagnostic.MessageContainer
+
+/** Contains the different data and type structures used to model results
+ *  in the REPL
+ */
+object results {
+
+  /** Type alias for `List[MessageContainer]` */
+  type Errors = List[MessageContainer]
+
+  /** Result is a type alias for an Either with left value `Errors` */
+  type Result[+A] = scala.util.Either[Errors, A]
+
+  implicit class ResultConversionA[A](val a: A) extends AnyVal {
+    def result: Result[A] = scala.util.Right(a)
+  }
+
+  implicit class ResultConversionErr(val xs: Errors) extends AnyVal {
+    def errors[A]: Result[A] = scala.util.Left(xs)
+  }
+}
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/Ansi.scala b/repl/src/dotty/tools/repl/terminal/Ansi.scala
similarity index 99%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/Ansi.scala
rename to repl/src/dotty/tools/repl/terminal/Ansi.scala
index 37c4de7b56c1..207d4a6c88a1 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/Ansi.scala
+++ b/repl/src/dotty/tools/repl/terminal/Ansi.scala
@@ -1,7 +1,6 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite.terminal
+package terminal
 
 object Ansi {
 
@@ -253,4 +252,6 @@ object Ansi {
       new Str(chars, colorsOut)
     }
   }
+
+
 }
diff --git a/repl/src/dotty/tools/repl/terminal/Filter.scala b/repl/src/dotty/tools/repl/terminal/Filter.scala
new file mode 100644
index 000000000000..0d9e3db85f13
--- /dev/null
+++ b/repl/src/dotty/tools/repl/terminal/Filter.scala
@@ -0,0 +1,105 @@
+package dotty.tools
+package repl
+package terminal
+
+/**
+  * The way you configure your terminal behavior; a trivial wrapper around a
+  * function, though you should provide a good `.toString` method to make
+  * debugging easier. The [[TermInfo]] and [[TermAction]] types are its
+  * interface to the terminal.
+  *
+  * [[Filter]]s are composed sequentially: if a filter returns `None` the next
+  * filter is tried, while if a filter returns `Some` that ends the cascade.
+  * While your `op` function interacts with the terminal purely through
+  * immutable case classes, the Filter itself is free to maintain its own state
+  * and mutate it whenever, even when returning `None` to continue the cascade.
+  */
+trait Filter {
+  def op(ti: TermInfo): Option[TermAction]
+
+  /**
+    * the `.toString` of this object, except by making it separate we force
+    * the implementer to provide something and stop them from accidentally
+    * leaving it as the meaningless default.
+    */
+  def identifier: String
+
+  override def toString = identifier
+}
+
+/**
+  * Convenience constructors to create [[Filter]] instances in a bunch of
+  * different ways
+  */
+object Filter {
+
+  /**
+    * Shorthand to construct a filter in the common case where you're
+    * switching on the prefix of the input stream and want to run some
+    * transformation on the buffer/cursor
+    */
+  def simple(prefixes: String*)
+            (f: (Vector[Char], Int, TermInfo) => (Vector[Char], Int)): Filter = new Filter {
+    def op(ti: TermInfo) = {
+      val matchingPrefixOpt =
+        prefixes.iterator
+                .map{ s => ti.ts.inputs.dropPrefix(s.map(_.toInt)) }
+                .collectFirst{case Some(s) => s}
+      matchingPrefixOpt.map{ rest =>
+        val (buffer1, cursor1) = f(ti.ts.buffer, ti.ts.cursor, ti)
+        TermState(
+          rest,
+          buffer1,
+          cursor1
+        )
+
+      }
+    }
+    def identifier = prefixes.mkString(":")
+  }
+  def action(id: String)
+            (prefixes: Seq[String], filter: TermInfo => Boolean = _ => true)
+            (action: TermState => TermAction = x => x): Filter = new Filter {
+    def op(ti: TermInfo) = {
+      prefixes.iterator
+              .map{ prefix => ti.ts.inputs.dropPrefix(prefix.map(_.toInt)) }
+              .collectFirst { case Some(rest) if filter(ti) => action(ti.ts.copy(inputs = rest)) }
+    }
+    def identifier: String = id
+  }
+
+  def partial(id: String)(f: PartialFunction[TermInfo, TermAction]): Filter =
+    new Filter {
+      def op(ti: TermInfo) = f.lift(ti)
+      def identifier = id
+    }
+
+  def wrap(id: String)(f: TermInfo => Option[TermAction]): Filter =
+    new Filter {
+      def op(ti: TermInfo) = f(ti)
+      def identifier = id
+    }
+
+  /**
+    * Merges multiple [[Filter]]s into one.
+    */
+  def merge(pfs: Filter*) = new Filter {
+
+    def op(v1: TermInfo) = pfs.iterator.map(_.op(v1)).find(_.isDefined).flatten
+
+    def identifier = pfs.iterator.map(_.identifier).mkString(":")
+  }
+  val empty = Filter.merge()
+}
+
+
+/**
+  * A filter as an abstract class, letting you provide a [[filter]] instead of
+  * an `op`, automatically providing a good `.toString` for debugging, and
+  * providing a reasonable "place" inside the inheriting class/object to put
+  * state or helpers or other logic associated with the filter.
+  */
+abstract class DelegateFilter(val identifier: String) extends Filter {
+  def filter: Filter
+  def op(ti: TermInfo) = filter.op(ti)
+}
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/FilterTools.scala b/repl/src/dotty/tools/repl/terminal/FilterTools.scala
similarity index 59%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/FilterTools.scala
rename to repl/src/dotty/tools/repl/terminal/FilterTools.scala
index c18b6a927844..e7f47879574a 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/FilterTools.scala
+++ b/repl/src/dotty/tools/repl/terminal/FilterTools.scala
@@ -1,7 +1,6 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite.terminal
+package terminal
 
 /**
  * A collection of helpers that to simpify the common case of building filters
@@ -25,37 +24,6 @@ object FilterTools {
     splitIndex
   }
 
-  /**
-   * Shorthand to construct a filter in the common case where you're
-   * switching on the prefix of the input stream and want to run some
-   * transformation on the buffer/cursor
-   */
-  def Case(s: String)
-          (f: (Vector[Char], Int, TermInfo) => (Vector[Char], Int)) = new Filter {
-    val op = new PartialFunction[TermInfo, TermAction] {
-      def isDefinedAt(x: TermInfo) = {
-
-        def rec(i: Int, c: LazyList[Int]): Boolean = {
-          if (i >= s.length) true
-          else if (c.head == s(i)) rec(i + 1, c.tail)
-          else false
-        }
-        rec(0, x.ts.inputs)
-      }
-
-      def apply(v1: TermInfo) = {
-        val (buffer1, cursor1) = f(v1.ts.buffer, v1.ts.cursor, v1)
-        TermState(
-          v1.ts.inputs.dropPrefix(s.map(_.toInt)).get,
-          buffer1,
-          cursor1
-        )
-      }
-
-    }.lift
-    def identifier = "Case"
-  }
-
   /** Shorthand for pattern matching on [[TermState]] */
   val TS = TermState
 
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/LICENSE b/repl/src/dotty/tools/repl/terminal/LICENSE
similarity index 100%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/LICENSE
rename to repl/src/dotty/tools/repl/terminal/LICENSE
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/Protocol.scala b/repl/src/dotty/tools/repl/terminal/Protocol.scala
similarity index 95%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/Protocol.scala
rename to repl/src/dotty/tools/repl/terminal/Protocol.scala
index 1120b7b6f395..800b745e47c5 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/Protocol.scala
+++ b/repl/src/dotty/tools/repl/terminal/Protocol.scala
@@ -1,7 +1,6 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite.terminal
+package terminal
 
 case class TermInfo(ts: TermState, width: Int)
 
@@ -36,4 +35,5 @@ object TermState {
 
 case class ClearScreen(ts: TermState) extends TermAction
 case object Exit extends TermAction
+case object Interrupt extends TermAction
 case class Result(s: String) extends TermAction
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/SpecialKeys.scala b/repl/src/dotty/tools/repl/terminal/SpecialKeys.scala
similarity index 94%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/SpecialKeys.scala
rename to repl/src/dotty/tools/repl/terminal/SpecialKeys.scala
index d834cc10b9e9..329776c66c2e 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/SpecialKeys.scala
+++ b/repl/src/dotty/tools/repl/terminal/SpecialKeys.scala
@@ -1,7 +1,6 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite.terminal
+package terminal
 
 /**
  * One place to assign all the esotic control key input snippets to
@@ -32,12 +31,16 @@ object SpecialKeys {
   val Home  = Alt+"OH"
   val End   = Alt+"OF"
 
+  val Tab = 9.toChar.toString
+
   // For some reason Screen makes these print different incantations
   // from a normal snippet, so this causes issues like
   // https://github.com/lihaoyi/Ammonite/issues/152 unless we special
   // case them
   val HomeScreen     = Alt+"[1~"
   val EndScreen      = Alt+"[4~"
+  val HomeLinuxXterm = Alt+"[7~"
+  val EndRxvt        = Alt+"[8~"
 
   val ShiftUp        = Alt+"[1;2A"
   val ShiftDown      = Alt+"[1;2B"
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/Terminal.scala b/repl/src/dotty/tools/repl/terminal/Terminal.scala
similarity index 95%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/Terminal.scala
rename to repl/src/dotty/tools/repl/terminal/Terminal.scala
index 4b18b38e3a74..dd3da9a87929 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/Terminal.scala
+++ b/repl/src/dotty/tools/repl/terminal/Terminal.scala
@@ -1,7 +1,5 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 
 import scala.annotation.tailrec
@@ -105,7 +103,6 @@ object Terminal {
   type Action    = (Vector[Char], Int) => (Vector[Char], Int)
   type MsgAction = (Vector[Char], Int) => (Vector[Char], Int, String)
 
-
   def noTransform(x: Vector[Char], i: Int) = (Ansi.Str.parse(x), i)
   /**
    * Blockingly reads a line from the given input stream and returns it.
@@ -123,7 +120,7 @@ object Terminal {
                writer: java.io.Writer,
                filters: Filter,
                displayTransform: (Vector[Char], Int) => (Ansi.Str, Int) = noTransform)
-               : Option[String] = {
+               : Option[TermAction] = {
 
     /**
       * Erases the previous line and re-draws it with the new buffer and
@@ -213,7 +210,7 @@ object Terminal {
     }
 
     @tailrec
-    def readChar(lastState: TermState, ups: Int, fullPrompt: Boolean = true): Option[String] = {
+    def readChar(lastState: TermState, ups: Int, fullPrompt: Boolean = true): Option[TermAction] = {
       val moreInputComing = reader.ready()
 
       lazy val (transformedBuffer0, cursorOffset) = displayTransform(
@@ -264,6 +261,15 @@ object Terminal {
       // `.get` because we assume that *some* filter is going to match each
       // character, even if only to dump the character to the screen. If nobody
       // matches the character then we can feel free to blow up
+      def redrawAndNewline() = {
+        redrawLine(
+          transformedBuffer, lastState.buffer.length,
+          oldCursorY + newlineUp, rowLengths, false, newlinePrompt
+        )
+        writer.write(10)
+        writer.write(13)
+        writer.flush()
+      }
       filters.op(TermInfo(lastState, actualWidth)).get match {
         case Printing(TermState(s, b, c, msg), stdout) =>
           writer.write(stdout)
@@ -274,15 +280,14 @@ object Terminal {
           val (nextUps, newState) = updateState(s, b, c, msg)
           readChar(newState, nextUps, false)
 
-        case Result(s) =>
-          redrawLine(
-            transformedBuffer, lastState.buffer.length,
-            oldCursorY + newlineUp, rowLengths, false, newlinePrompt
-          )
-          writer.write(10)
-          writer.write(13)
-          writer.flush()
-          Some(s)
+        case res: Result =>
+          redrawAndNewline()
+          Some(res)
+
+        case Interrupt =>
+          redrawAndNewline()
+          Some(Interrupt)
+
         case ClearScreen(ts) =>
           ansi.clearScreen(2)
           ansi.up(9999)
@@ -297,7 +302,8 @@ object Terminal {
     lazy val (width, _, initialConfig) = TTY.init()
     try {
       readChar(TermState(LazyList.continually(reader.read()), Vector.empty, 0, ""), 0)
-    }finally{
+    }
+    finally {
 
       // Don't close these! Closing these closes stdin/stdout,
       // which seems to kill the entire program
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/Utils.scala b/repl/src/dotty/tools/repl/terminal/Utils.scala
similarity index 69%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/Utils.scala
rename to repl/src/dotty/tools/repl/terminal/Utils.scala
index 64a2c14765b7..dad7dc61dd5f 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/Utils.scala
+++ b/repl/src/dotty/tools/repl/terminal/Utils.scala
@@ -1,7 +1,6 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite.terminal
+package terminal
 
 import java.io.{FileOutputStream, Writer, File => JFile}
 import scala.annotation.tailrec
@@ -167,3 +166,70 @@ object LazyList {
     }
   }
 }
+
+/**
+ * Created by haoyi on 8/29/15.
+ */
+object FrontEndUtils {
+  import Ansi.Str._
+
+  private[this] val newLine = System.lineSeparator()
+
+  def transpose[A](xs: List[List[A]]): List[List[A]] = {
+    @tailrec def transpose(xs: List[List[A]], result: List[List[A]]): List[List[A]] = {
+      xs.filter(_.nonEmpty) match {
+        case Nil =>  result
+        case ys: List[List[A]] => transpose(ys.map(_.tail), ys.map(_.head) :: result)
+      }
+    }
+
+    transpose(xs, Nil).reverse
+  }
+
+  def width = TTY.consoleDim("cols")
+  def height = TTY.consoleDim("lines")
+  def tabulate(snippetsRaw: Seq[Ansi.Str], width: Int): Iterator[String] = {
+    val gap = 2
+    val snippets = if (snippetsRaw.isEmpty) Seq(Ansi.Str.parse("")) else snippetsRaw
+    val maxLength = snippets.maxBy(_.length).length + gap
+    val columns = math.max(1, width / maxLength)
+
+    val grouped =
+      snippets.toList
+              .grouped(math.ceil(snippets.length * 1.0 / columns).toInt)
+              .toList
+
+    transpose(grouped).iterator.flatMap {
+      case first :+ last => first.map(
+        x => x ++ " " * (width / columns - x.length)
+      ) :+ last :+ Ansi.Str.parse(newLine)
+    }
+    .map(_.render)
+  }
+
+  @tailrec def findPrefix(strings: Seq[String], i: Int = 0): String = {
+    if (strings.count(_.length > i) == 0) strings(0).take(i)
+    else if(strings.collect{ case x if x.length > i => x(i)}.distinct.length > 1)
+      strings(0).take(i)
+    else findPrefix(strings, i + 1)
+  }
+
+  def printCompletions(completions: Seq[String],
+                       details: Seq[String]): List[String] = {
+
+    val prelude: List[String] =
+      if (details.length != 0 || completions.length != 0) List(newLine)
+      else Nil
+
+    val detailsText =
+      if (details.length == 0) Nil
+      else FrontEndUtils.tabulate(details.map(Ansi.Str.parse(_)), FrontEndUtils.width)
+
+    val completionText =
+      if (completions.length == 0) Nil
+      else FrontEndUtils.tabulate(completions.map(Ansi.Str.parse(_)), FrontEndUtils.width)
+
+    (prelude ++ detailsText ++ completionText)
+  }
+
+}
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/BasicFilters.scala b/repl/src/dotty/tools/repl/terminal/filters/BasicFilters.scala
similarity index 85%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/filters/BasicFilters.scala
rename to repl/src/dotty/tools/repl/terminal/filters/BasicFilters.scala
index faa97c348cdb..be264ce970f8 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/BasicFilters.scala
+++ b/repl/src/dotty/tools/repl/terminal/filters/BasicFilters.scala
@@ -1,15 +1,15 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 package filters
 
-import ammonite.terminal.FilterTools._
-import ammonite.terminal.LazyList._
-import ammonite.terminal.SpecialKeys._
-import ammonite.terminal.Filter
-import ammonite.terminal._
+import terminal.FilterTools._
+import terminal.LazyList._
+import terminal.SpecialKeys._
+import terminal.Filter
+import terminal._
+
+import terminal.Filter._
 
 /**
  * Filters for simple operation of a terminal: cursor-navigation
@@ -31,10 +31,10 @@ object BasicFilters {
   }
 
   def navFilter = Filter.merge(
-    Case(Up)((b, c, m) => moveUp(b, c, m.width)),
-    Case(Down)((b, c, m) => moveDown(b, c, m.width)),
-    Case(Right)((b, c, m) => (b, c + 1)),
-    Case(Left)((b, c, m) => (b, c - 1))
+    simple(Up)((b, c, m) => moveUp(b, c, m.width)),
+    simple(Down)((b, c, m) => moveDown(b, c, m.width)),
+    simple(Right)((b, c, m) => (b, c + 1)),
+    simple(Left)((b, c, m) => (b, c - 1))
   )
 
   def tabColumn(indent: Int, b: Vector[Char], c: Int, rest: LazyList[Int]) = {
@@ -45,11 +45,11 @@ object BasicFilters {
     TS(rest, lhs ++ Vector.fill(spacesToInject)(' ') ++ rhs, c + spacesToInject)
   }
 
-  def tabFilter(indent: Int): Filter = Filter("tabFilter") {
+  def tabFilter(indent: Int): Filter = Filter.partial("tabFilter") {
     case TS(9 ~: rest, b, c, _) => tabColumn(indent, b, c, rest)
   }
 
-  def loggingFilter: Filter = Filter("loggingFilter") {
+  def loggingFilter: Filter = Filter.partial("loggingFilter") {
     case TS(Ctrl('q') ~: rest, b, c, _) =>
       println("Char Display Mode Enabled! Ctrl-C to exit")
       var curr = rest
@@ -60,7 +60,7 @@ object BasicFilters {
       TS(curr, b, c)
   }
 
-  def typingFilter: Filter = Filter("typingFilter") {
+  def typingFilter: Filter = Filter.partial("typingFilter") {
     case TS(p"\u001b[3~$rest", b, c, _) =>
 //      Debug("fn-delete")
       val (first, last) = b.splitAt(c)
@@ -82,16 +82,16 @@ object BasicFilters {
     else injectNewLine(b, c, rest)
   }
 
-  def enterFilter: Filter = Filter("enterFilter") {
+  def enterFilter: Filter = Filter.partial("enterFilter") {
     case TS(13 ~: rest, b, c, _) => doEnter(b, c, rest) // Enter
     case TS(10 ~: rest, b, c, _) => doEnter(b, c, rest) // Enter
     case TS(10 ~: 13 ~: rest, b, c, _) => doEnter(b, c, rest) // Enter
     case TS(13 ~: 10 ~: rest, b, c, _) => doEnter(b, c, rest) // Enter
   }
 
-  def exitFilter: Filter = Filter("exitFilter") {
+  def exitFilter: Filter = Filter.partial("exitFilter") {
     case TS(Ctrl('c') ~: rest, b, c, _) =>
-      Result("")
+      Interrupt
     case TS(Ctrl('d') ~: rest, b, c, _) =>
       // only exit if the line is empty, otherwise, behave like
       // "delete" (i.e. delete one char to the right)
@@ -102,7 +102,7 @@ object BasicFilters {
     case TS(-1 ~: rest, b, c, _) => Exit   // java.io.Reader.read() produces -1 on EOF
   }
 
-  def clearFilter: Filter = Filter("clearFilter") {
+  def clearFilter: Filter = Filter.partial("clearFilter") {
     case TS(Ctrl('l') ~: rest, b, c, _) => ClearScreen(TS(rest, b, c))
   }
 
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/GUILikeFilters.scala b/repl/src/dotty/tools/repl/terminal/filters/GUILikeFilters.scala
similarity index 72%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/filters/GUILikeFilters.scala
rename to repl/src/dotty/tools/repl/terminal/filters/GUILikeFilters.scala
index 69a9769c6379..7a147adfef8b 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/GUILikeFilters.scala
+++ b/repl/src/dotty/tools/repl/terminal/filters/GUILikeFilters.scala
@@ -1,7 +1,5 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 package filters
 
@@ -11,6 +9,7 @@ import terminal.SpecialKeys._
 import terminal.DelegateFilter
 import terminal._
 
+import Filter._
 /**
  * Filters have hook into the various {Ctrl,Shift,Fn,Alt}x{Up,Down,Left,Right}
  * combination keys, and make them behave similarly as they would on a normal
@@ -18,8 +17,7 @@ import terminal._
  * text selection, etc.
  */
 object GUILikeFilters {
-  case class SelectionFilter(indent: Int) extends DelegateFilter {
-    def identifier = "SelectionFilter"
+  case class SelectionFilter(indent: Int) extends DelegateFilter("SelectionFilter") {
     var mark: Option[Int] = None
 
     def setMark(c: Int) = {
@@ -68,17 +66,17 @@ object GUILikeFilters {
 
     def filter = Filter.merge(
 
-      Case(ShiftUp) {(b, c, m) => setMark(c); BasicFilters.moveUp(b, c, m.width)},
-      Case(ShiftDown) {(b, c, m) => setMark(c); BasicFilters.moveDown(b, c, m.width)},
-      Case(ShiftRight) {(b, c, m) => setMark(c); (b, c + 1)},
-      Case(ShiftLeft) {(b, c, m) => setMark(c); (b, c - 1)},
-      Case(AltShiftUp) {(b, c, m) => setMark(c); BasicFilters.moveUp(b, c, m.width)},
-      Case(AltShiftDown) {(b, c, m) => setMark(c); BasicFilters.moveDown(b, c, m.width)},
-      Case(AltShiftRight) {(b, c, m) => setMark(c); wordRight(b, c)},
-      Case(AltShiftLeft) {(b, c, m) => setMark(c); wordLeft(b, c)},
-      Case(FnShiftRight) {(b, c, m) => setMark(c); BasicFilters.moveEnd(b, c, m.width)},
-      Case(FnShiftLeft) {(b, c, m) => setMark(c); BasicFilters.moveStart(b, c, m.width)},
-      Filter("fnOtherFilter") {
+      simple(ShiftUp){(b, c, m) => setMark(c); BasicFilters.moveUp(b, c, m.width)},
+      simple(ShiftDown){(b, c, m) => setMark(c); BasicFilters.moveDown(b, c, m.width)},
+      simple(ShiftRight){(b, c, m) => setMark(c); (b, c + 1)},
+      simple(ShiftLeft){(b, c, m) => setMark(c); (b, c - 1)},
+      simple(AltShiftUp){(b, c, m) => setMark(c); BasicFilters.moveUp(b, c, m.width)},
+      simple(AltShiftDown){(b, c, m) => setMark(c); BasicFilters.moveDown(b, c, m.width)},
+      simple(AltShiftRight){(b, c, m) => setMark(c); wordRight(b, c)},
+      simple(AltShiftLeft){(b, c, m) => setMark(c); wordLeft(b, c)},
+      simple(FnShiftRight){(b, c, m) => setMark(c); BasicFilters.moveEnd(b, c, m.width)},
+      simple(FnShiftLeft){(b, c, m) => setMark(c); BasicFilters.moveStart(b, c, m.width)},
+      partial(identifier) {
         case TS(27 ~: 91 ~: 90 ~: rest, b, c, _) if mark.isDefined =>
           doIndent(b, c, rest,
             slice => -math.min(slice.iterator.takeWhile(_ == ' ').size, indent)
@@ -132,27 +130,27 @@ object GUILikeFilters {
   }
 
   val fnFilter = Filter.merge(
-    Case(FnUp)((b, c, m) => (b, c - 9999)),
-    Case(FnDown)((b, c, m) => (b, c + 9999)),
-    Case(FnRight)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)),
-    Case(FnLeft)((b, c, m) => BasicFilters.moveStart(b, c, m.width))
+    simple(FnUp)((b, c, m) => (b, c - 9999)),
+    simple(FnDown)((b, c, m) => (b, c + 9999)),
+    simple(FnRight)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)),
+    simple(FnLeft)((b, c, m) => BasicFilters.moveStart(b, c, m.width))
   )
   val altFilter = Filter.merge(
-    Case(AltUp)    {(b, c, m) => BasicFilters.moveUp(b, c, m.width)},
-    Case(AltDown)  {(b, c, m) => BasicFilters.moveDown(b, c, m.width)},
-    Case(AltRight) {(b, c, m) => wordRight(b, c)},
-    Case(AltLeft)  {(b, c, m) => wordLeft(b, c)}
+    simple(AltUp){(b, c, m) => BasicFilters.moveUp(b, c, m.width)},
+    simple(AltDown){(b, c, m) => BasicFilters.moveDown(b, c, m.width)},
+    simple(AltRight){(b, c, m) => wordRight(b, c)},
+    simple(AltLeft){(b, c, m) => wordLeft(b, c)}
   )
 
   val fnAltFilter = Filter.merge(
-    Case(FnAltUp)    {(b, c, m) => (b, c)},
-    Case(FnAltDown)  {(b, c, m) => (b, c)},
-    Case(FnAltRight) {(b, c, m) => (b, c)},
-    Case(FnAltLeft)  {(b, c, m) => (b, c)}
+    simple(FnAltUp){(b, c, m) => (b, c)},
+    simple(FnAltDown){(b, c, m) => (b, c)},
+    simple(FnAltRight){(b, c, m) => (b, c)},
+    simple(FnAltLeft){(b, c, m) => (b, c)}
   )
   val fnAltShiftFilter = Filter.merge(
-    Case(FnAltShiftRight) {(b, c, m) => (b, c)},
-    Case(FnAltShiftLeft)  {(b, c, m) => (b, c)}
+    simple(FnAltShiftRight){(b, c, m) => (b, c)},
+    simple(FnAltShiftLeft){(b, c, m) => (b, c)}
   )
 
 
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/HistoryFilter.scala b/repl/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
similarity index 98%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/filters/HistoryFilter.scala
rename to repl/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
index dac1c9d2394c..992c70774926 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/HistoryFilter.scala
+++ b/repl/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
@@ -1,7 +1,5 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 package filters
 
@@ -18,10 +16,8 @@ class HistoryFilter(
   history: () => IndexedSeq[String],
   commentStartColor: String,
   commentEndColor: String
-) extends DelegateFilter {
+) extends DelegateFilter("HistoryFilter") {
 
-
-  def identifier = "HistoryFilter"
   /**
     * `-1` means we haven't started looking at history, `n >= 0` means we're
     * currently at history command `n`
@@ -165,14 +161,14 @@ class HistoryFilter(
     }
   }
 
-  def prelude: Filter = Filter("historyPrelude") {
+  def prelude: Filter = Filter.partial("historyPrelude") {
     case TS(inputs, b, c, _) if activeHistory && prevBuffer.exists(_ != b) =>
       endHistory()
       prevBuffer = None
       TS(inputs, b, c)
   }
 
-  def filter0: Filter = Filter("filter0") {
+  def filter0: Filter = Filter.partial("filter0") {
     // Ways to kick off the history/search if you're not already in it
 
     // `Ctrl-R`
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/ReadlineFilters.scala b/repl/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
similarity index 50%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/filters/ReadlineFilters.scala
rename to repl/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
index eb79f2b04c8e..c619238de2d0 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/ReadlineFilters.scala
+++ b/repl/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
@@ -1,13 +1,14 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 package filters
 
 import terminal.FilterTools._
 import terminal.SpecialKeys._
 import terminal.{DelegateFilter, Filter, Terminal}
+
+import Filter._
+
 /**
  * Filters for injection of readline-specific hotkeys, the sort that
  * are available in bash, python and most other interactive command-lines
@@ -42,23 +43,27 @@ object ReadlineFilters {
    * rather than using arrows
    */
   lazy val navFilter = Filter.merge(
-    Case(Ctrl('b'))((b, c, m) => (b, c - 1)), // <- one char
-    Case(Ctrl('f'))((b, c, m) => (b, c + 1)), // -> one char
-    Case(Alt + "b")((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
-    Case(Alt + "B")((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
-    Case(LinuxCtrlLeft)((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
-    Case(Alt + "f")((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one  word
-    Case(Alt + "F")((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one  word
-    Case(LinuxCtrlRight)((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one word
-    Case(Home)((b, c, m) => BasicFilters.moveStart(b, c, m.width)), // <- one line
-    Case(HomeScreen)((b, c, m) => BasicFilters.moveStart(b, c, m.width)), // <- one line
-    Case(Ctrl('a'))((b, c, m) => BasicFilters.moveStart(b, c, m.width)),
-    Case(End)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)), // -> one line
-    Case(EndScreen)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)), // -> one line
-    Case(Ctrl('e'))((b, c, m) => BasicFilters.moveEnd(b, c, m.width)),
-    Case(Alt + "t")((b, c, m) => transposeWord(b, c)),
-    Case(Alt + "T")((b, c, m) => transposeWord(b, c)),
-    Case(Ctrl('t'))((b, c, m) => transposeLetter(b, c))
+    simple(Ctrl('p'))((b, c, m) => BasicFilters.moveUp(b, c, m.width)),
+    simple(Ctrl('n'))((b, c, m) => BasicFilters.moveDown(b, c, m.width)),
+    simple(Ctrl('b'))((b, c, m) => (b, c - 1)), // <- one char
+    simple(Ctrl('f'))((b, c, m) => (b, c + 1)), // -> one char
+    simple(Alt + "b")((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
+    simple(Alt + "B")((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
+    simple(LinuxCtrlLeft)((b, c, m) => GUILikeFilters.wordLeft(b, c)), // <- one word
+    simple(Alt + "f")((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one  word
+    simple(Alt + "F")((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one  word
+    simple(LinuxCtrlRight)((b, c, m) => GUILikeFilters.wordRight(b, c)), // -> one word
+    simple(Home)((b, c, m) => BasicFilters.moveStart(b, c, m.width)), // <- one line
+    simple(HomeScreen)((b, c, m) => BasicFilters.moveStart(b, c, m.width)), // <- one line
+    simple(HomeLinuxXterm)((b, c, m) => BasicFilters.moveStart(b, c, m.width)), // <- one line
+    simple(Ctrl('a'))((b, c, m) => BasicFilters.moveStart(b, c, m.width)),
+    simple(End)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)), // -> one line
+    simple(EndScreen)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)), // -> one line
+    simple(EndRxvt)((b, c, m) => BasicFilters.moveEnd(b, c, m.width)), // -> one line
+    simple(Ctrl('e'))((b, c, m) => BasicFilters.moveEnd(b, c, m.width)),
+    simple(Alt + "t")((b, c, m) => transposeWord(b, c)),
+    simple(Alt + "T")((b, c, m) => transposeWord(b, c)),
+    simple(Ctrl('t'))((b, c, m) => transposeLetter(b, c))
   )
 
   def transposeLetter(b: Vector[Char], c: Int) =
@@ -83,7 +88,8 @@ object ReadlineFilters {
           val leftStart = GUILikeFilters.consumeWord(b, leftStart0 - 1, -1, 1)
           val leftEnd   = GUILikeFilters.consumeWord(b, leftStart, 1, 0)
           (leftStart, leftEnd)
-        }else (leftStart0, leftEnd0)
+        } else
+          (leftStart0, leftEnd0)
 
       val newB =
         b.slice(0, leftStart)         ++
@@ -100,8 +106,7 @@ object ReadlineFilters {
    * All the cut-pasting logic, though for many people they simply
    * use these shortcuts for deleting and don't use paste much at all.
    */
-  case class CutPasteFilter() extends DelegateFilter {
-    def identifier = "CutPasteFilter"
+  case class CutPasteFilter() extends DelegateFilter("CutPasteFilter") {
     var accumulating = false
     var currentCut = Vector.empty[Char]
     def prepend(b: Vector[Char]) = {
@@ -119,13 +124,53 @@ object ReadlineFilters {
       (b patch(from = c - 1, patch = Nil, replaced = 1), c - 1)
     }
 
-    def cutAllLeft(b: Vector[Char], c: Int) = {
-      prepend(b.take(c))
-      (b.drop(c), 0)
+    def cutLineLeft(b: Vector[Char], c: Int) = {
+      val (allBeforeCursor, allAfterCursor) = b.splitAt(c)
+      val previousNewlineIndex = allBeforeCursor.lastIndexWhere(_ == '\n')
+      if (previousNewlineIndex == -1) {
+        // beginning of input. no leading newline
+        prepend(allBeforeCursor)
+        (allAfterCursor, 0)
+      } else {
+        val (allBeforeLine, lineBeforeCursor) = allBeforeCursor.splitAt(
+          previousNewlineIndex
+        )
+        val charsBeforeCursorOnLine = lineBeforeCursor.length
+        if (charsBeforeCursorOnLine == 1) {
+          // if only a newline before cursor on line, cut it
+          prepend(lineBeforeCursor)
+          (allBeforeLine ++ allAfterCursor, c - 1)
+        } else {
+          // if there's more on the line before cursor, cut to beginning of line
+          prepend(lineBeforeCursor.tail)
+          val buffer = allBeforeLine ++ "\n" ++ allAfterCursor
+          val cursor = c - (charsBeforeCursorOnLine - 1)
+          (buffer, cursor)
+        }
+      }
     }
-    def cutAllRight(b: Vector[Char], c: Int) = {
-      append(b.drop(c))
-      (b.take(c), c)
+
+    def cutLineRight(b: Vector[Char], c: Int) = {
+      val (allBeforeCursor, allAfterCursor) = b.splitAt(c)
+      val nextNewlineIndex = allAfterCursor.indexWhere(_ == '\n')
+      if (nextNewlineIndex == -1) {
+        // end of input. no trailing newline
+        append(allAfterCursor)
+        (allBeforeCursor, c)
+      } else {
+        allAfterCursor.splitAt(
+          nextNewlineIndex
+        ) match {
+          case (Vector(), ('\n' +: allAfterNewline)) =>
+            // if there's only a newline after cursor on line, cut it
+            append(Vector('\n'))
+            (allBeforeCursor ++ allAfterNewline, c)
+          case (restOfLine, allAfterLine) =>
+            // if there's more on the line after cursor, cut to end of line
+            append(restOfLine)
+            (allBeforeCursor ++ allAfterLine, c)
+        }
+      }
     }
 
     def cutWordRight(b: Vector[Char], c: Int) = {
@@ -146,20 +191,21 @@ object ReadlineFilters {
     }
 
     def filter = Filter.merge(
-      Case(Ctrl('u'))((b, c, m) => cutAllLeft(b, c)),
-      Case(Ctrl('k'))((b, c, m) => cutAllRight(b, c)),
-      Case(Alt + "d")((b, c, m) => cutWordRight(b, c)),
-      Case(Ctrl('w'))((b, c, m) => cutWordLeft(b, c)),
-      Case(Alt + "\u007f")((b, c, m) => cutWordLeft(b, c)),
+      simple(Ctrl('u'))((b, c, m) => cutLineLeft(b, c)),
+      simple(Ctrl('k'))((b, c, m) => cutLineRight(b, c)),
+      simple(Alt + "d")((b, c, m) => cutWordRight(b, c)),
+      simple(Ctrl('w'))((b, c, m) => cutWordLeft(b, c)),
+      simple(Alt + "\u007f")((b, c, m) => cutWordLeft(b, c)),
       // weird hacks to make it run code every time without having to be the one
       // handling the input; ideally we'd change Filter to be something
       // other than a PartialFunction, but for now this will do.
 
       // If some command goes through that's not appending/prepending to the
       // kill ring, stop appending and allow the next kill to override it
-      Filter.wrap("ReadLineFilterWrap") {_ => accumulating = false; None},
-      Case(Ctrl('h'))((b, c, m) => cutCharLeft(b, c)),
-      Case(Ctrl('y'))((b, c, m) => paste(b, c))
+      Filter.wrap(identifier) { _ => accumulating = false; None },
+      simple(Ctrl('h'))((b, c, m) => cutCharLeft(b, c)),
+      simple(Ctrl('y'))((b, c, m) => paste(b, c))
     )
   }
+
 }
diff --git a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/UndoFilter.scala b/repl/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
similarity index 97%
rename from compiler/src/dotty/tools/dotc/repl/ammonite/filters/UndoFilter.scala
rename to repl/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
index c265a7a4c0e5..c0b01ea1b7f5 100644
--- a/compiler/src/dotty/tools/dotc/repl/ammonite/filters/UndoFilter.scala
+++ b/repl/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
@@ -1,7 +1,5 @@
 package dotty.tools
-package dotc
 package repl
-package ammonite
 package terminal
 package filters
 
@@ -23,8 +21,7 @@ import scala.collection.mutable
   *
   * @param maxUndo: the maximum number of undo-frames that are stored.
   */
-case class UndoFilter(maxUndo: Int = 25) extends DelegateFilter {
-  def identifier = "UndoFilter"
+case class UndoFilter(maxUndo: Int = 25) extends DelegateFilter("UndoFilter") {
   /**
     * The current stack of states that undo/redo would cycle through.
     *
@@ -132,7 +129,7 @@ case class UndoFilter(maxUndo: Int = 25) extends DelegateFilter {
         pushUndos(b, c)
         None
     },
-    Filter("undoFilter") {
+    Filter.partial("undoFilter") {
       case TS(31 ~: rest, b, c, _) => wrap(undo(b, c), rest)
       case TS(27 ~: 114 ~: rest, b, c, _) => wrap(undo(b, c), rest)
       case TS(27 ~: 45 ~: rest, b, c, _) => wrap(redo(b, c), rest)
diff --git a/tests/repl/def.check b/repl/test-resources/repl/defs
similarity index 84%
rename from tests/repl/def.check
rename to repl/test-resources/repl/defs
index 9d653835490a..6db260b48f26 100644
--- a/tests/repl/def.check
+++ b/repl/test-resources/repl/defs
@@ -7,7 +7,6 @@ def baz(): Int
 scala> def qux(): Int = 2
 def qux(): Int
 scala> def id(x: 4): 4 = x
-def id(x: 4.type): Int(4)
+def id(x: 4): 4
 scala> id(4)
 val res0: Int = 4
-scala> :quit
diff --git a/repl/test-resources/repl/errmsgs b/repl/test-resources/repl/errmsgs
new file mode 100644
index 000000000000..afc529393e4b
--- /dev/null
+++ b/repl/test-resources/repl/errmsgs
@@ -0,0 +1,66 @@
+scala> class Inv[T](x: T)
+// defined class Inv
+scala> val x: List[String] = List(1)
+1 | val x: List[String] = List(1)
+  |                            ^
+  |                            found:    Int(1)
+  |                            required: String
+  |
+scala> val y: List[List[String]] = List(List(1))
+1 | val y: List[List[String]] = List(List(1))
+  |                                       ^
+  |                                       found:    Int(1)
+  |                                       required: String
+  |
+scala> val z: (List[String], List[Int]) = (List(1), List("a"))
+1 | val z: (List[String], List[Int]) = (List(1), List("a"))
+  |                                          ^
+  |                                          found:    Int(1)
+  |                                          required: String
+  |
+1 | val z: (List[String], List[Int]) = (List(1), List("a"))
+  |                                                   ^^^
+  |                                                   found:    String("a")
+  |                                                   required: Int
+  |
+scala> val a: Inv[String] = new Inv(new Inv(1))
+1 | val a: Inv[String] = new Inv(new Inv(1))
+  |                                  ^^^^^
+  |                                  found:    Inv[Int]
+  |                                  required: String
+  |
+scala> val b: Inv[String] = new Inv(1)
+1 | val b: Inv[String] = new Inv(1)
+  |                              ^
+  |                              found:    Int(1)
+  |                              required: String
+  |
+scala> abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
+1 | abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
+  |                                                                                  ^
+  |found:    C.this.T(C.this.x)
+  |required: T'
+  |
+  |where:    T  is a type in class C
+  |          T' is a type in the initalizer of value s which is an alias of String
+1 | abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
+  |                                                                                                                                    ^
+  |found:    T(y)
+  |required: T'
+  |
+  |where:    T  is a type in the initalizer of value s which is an alias of String
+  |          T' is a type in method f which is an alias of Int
+scala> class Foo() { def bar: Int = 1 }; val foo = new Foo(); foo.barr
+1 | class Foo() { def bar: Int = 1 }; val foo = new Foo(); foo.barr
+  |                                                        ^^^^^^^^
+  |             value `barr` is not a member of Foo - did you mean `foo.bar`?
+scala> val x: List[Int] = "foo" :: List(1)
+1 | val x: List[Int] = "foo" :: List(1)
+  |                    ^^^^^
+  |                    found:    String($1$)
+  |                    required: Int
+  |
+scala> { def f: Int = g; val x: Int = 1; def g: Int = 5; }
+1 | { def f: Int = g; val x: Int = 1; def g: Int = 5; }
+  |                ^
+  |           `g` is a forward reference extending over the definition of `x`
diff --git a/repl/test-resources/repl/errorThenValid b/repl/test-resources/repl/errorThenValid
new file mode 100644
index 000000000000..660860e86468
--- /dev/null
+++ b/repl/test-resources/repl/errorThenValid
@@ -0,0 +1,6 @@
+scala> val xs = scala.collection.mutable.ListBuffer[Int]
+1 | val xs = scala.collection.mutable.ListBuffer[Int]
+  |          ^
+  |          missing parameter type for parameter elems, expected = ?
+scala> val xs = scala.collection.mutable.ListBuffer[Int]()
+val xs: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
diff --git a/tests/repl/functions.check b/repl/test-resources/repl/functions
similarity index 97%
rename from tests/repl/functions.check
rename to repl/test-resources/repl/functions
index 1e14e7019bef..8a9317deedb9 100644
--- a/tests/repl/functions.check
+++ b/repl/test-resources/repl/functions
@@ -1,5 +1,4 @@
 scala> object Test { def foo(p1: Int, p2: Int, p3: Int, p4: Int, p5: Int, p6: Int, p7: Int, p8: Int, p9: Int, p10: Int, p11: Int, p12: Int, p13: Int, p14: Int, p15: Int, p16: Int, p17: Int, p18: Int, p19: Int, p20: Int, p21: Int, p22: Int, p23: Int, p24: Int, p25: Int, p26: Int, p27: Int, p28: Int, p29: Int, p30: Int, p31: Int, p32: Int, p33: Int, p34: Int, p35: Int, p36: Int, p37: Int, p38: Int, p39: Int, p40: Int, p41: Int, p42: Int, p43: Int, p44: Int, p45: Int, p46: Int, p47: Int, p48: Int, p49: Int, p50: Int, p51: Int, p52: Int, p53: Int, p54: Int, p55: Int, p56: Int, p57: Int, p58: Int, p59: Int, p60: Int, p61: Int, p62: Int, p63: Int, p64: Int, p65: Int, p66: Int, p67: Int, p68: Int, p69: Int, p70: Int, p71: Int, p72: Int, p73: Int, p74: Int, p75: Int, p76: Int, p77: Int, p78: Int, p79: Int, p80: Int, p81: Int, p82: Int, p83: Int, p84: Int, p85: Int, p86: Int, p87: Int, p88: Int, p89: Int, p90: Int, p91: Int, p92: Int, p93: Int, p94: Int, p95: Int, p96: Int, p97: Int, p98: Int, p99: Int, p100: Int, p101: Int, p102: Int, p103: Int, p104: Int, p105: Int, p106: Int, p107: Int, p108: Int, p109: Int): Int = 42 }
-defined module Test
+// defined object Test
 scala> Test.foo(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109)
 val res0: Int = 42
-scala> :quit
diff --git a/repl/test-resources/repl/getClass b/repl/test-resources/repl/getClass
new file mode 100644
index 000000000000..27dbb0c77a37
--- /dev/null
+++ b/repl/test-resources/repl/getClass
@@ -0,0 +1,4 @@
+scala> val xs = List(1)
+val xs: List[Int] = List(1)
+scala> xs.getClass
+val res0: Class[_] = class scala.collection.immutable.$colon$colon
diff --git a/tests/repl/i1433.check b/repl/test-resources/repl/i1433
similarity index 85%
rename from tests/repl/i1433.check
rename to repl/test-resources/repl/i1433
index 728d0640f7e9..d7b100d6d124 100644
--- a/tests/repl/i1433.check
+++ b/repl/test-resources/repl/i1433
@@ -2,4 +2,3 @@ scala> val ### = 42
 val ###: Int = 42
 scala> ### + ###
 val res0: Int = 84
-scala> :quit
diff --git a/repl/test-resources/repl/i2063 b/repl/test-resources/repl/i2063
new file mode 100644
index 000000000000..3bb96fc32b23
--- /dev/null
+++ b/repl/test-resources/repl/i2063
@@ -0,0 +1,12 @@
+scala> 	class Foo extends Bar // with one tab
+1 | 	class Foo extends Bar // with one tab
+  | 	                  ^^^
+  | 	                  not found: type Bar
+scala>                                                                               class Foo extends Bar // with spaces
+1 |                                                                               class Foo extends Bar // with spaces
+  |                                                                                                 ^^^
+  |                                                       not found: type Bar
+scala>                                                                                  class Foo extends Bar // with tabs
+1 |                                                                                  class Foo extends Bar // with tabs
+  |                                                                                                    ^^^
+  |                                                       not found: type Bar
diff --git a/repl/test-resources/repl/i2213 b/repl/test-resources/repl/i2213
new file mode 100644
index 000000000000..79bdb08fef92
--- /dev/null
+++ b/repl/test-resources/repl/i2213
@@ -0,0 +1,7 @@
+scala> def x
+1 | def x
+  |      ^
+  |      missing return type
+1 | def x
+  |     ^
+  |     '=' expected, but eof found
diff --git a/repl/test-resources/repl/i2492 b/repl/test-resources/repl/i2492
new file mode 100644
index 000000000000..b459d4feef43
--- /dev/null
+++ b/repl/test-resources/repl/i2492
@@ -0,0 +1,6 @@
+scala> class Map[K, V]
+// defined class Map
+scala> val s: Map {type Map$K = String; type Map$V = Int} = null
+1 | val s: Map {type Map$K = String; type Map$V = Int} = null
+  |        ^^^
+  |        missing type parameter for Map
diff --git a/tests/repl/import.check b/repl/test-resources/repl/import
similarity index 90%
rename from tests/repl/import.check
rename to repl/test-resources/repl/import
index d53906ddce17..1bba01cb5443 100644
--- a/tests/repl/import.check
+++ b/repl/test-resources/repl/import
@@ -1,5 +1,4 @@
 scala> import collection.mutable._
-import collection.mutable._
 scala> val buf = new ListBuffer[Int]
 val buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
 scala> buf += 22
@@ -8,4 +7,3 @@ scala> buf ++= List(1, 2, 3)
 val res1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(22, 1, 2, 3)
 scala> buf.toList
 val res2: List[Int] = List(22, 1, 2, 3)
-scala> :quit
diff --git a/repl/test-resources/repl/importFromObj b/repl/test-resources/repl/importFromObj
new file mode 100644
index 000000000000..ca59758ab53d
--- /dev/null
+++ b/repl/test-resources/repl/importFromObj
@@ -0,0 +1,22 @@
+scala> import scala.collection.mutable
+scala> val buf = mutable.ListBuffer[Int]()
+val buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
+scala> object o { val xs = List(1, 2, 3) }
+// defined object o
+scala> import o._
+scala> buf += xs
+1 | buf += xs
+  |        ^^
+  |        found:    scala.collection.immutable.List[Int](o.xs)
+  |        required: Int
+  |
+scala> buf ++= xs
+val res0: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
+scala> import util.foo
+1 | import util.foo
+  |             ^^^
+  |             foo is not a member of util
+scala> import util.foo.bar
+1 | import util.foo.bar
+  |        ^^^^^^^^
+  |        value `foo` is not a member of util - did you mean `util.Left`?
diff --git a/tests/repl/innerClasses.check b/repl/test-resources/repl/innerClasses
similarity index 67%
rename from tests/repl/innerClasses.check
rename to repl/test-resources/repl/innerClasses
index 72dc6ae450d3..a67bd3be46e6 100644
--- a/tests/repl/innerClasses.check
+++ b/repl/test-resources/repl/innerClasses
@@ -1,5 +1,4 @@
 scala> class A { class Inner }
-defined class A
+// defined class A
 scala> class B extends A { class Inner2 extends super.Inner }
-defined class B
-scala> :quit
+// defined class B
diff --git a/repl/test-resources/repl/onePlusOne b/repl/test-resources/repl/onePlusOne
new file mode 100644
index 000000000000..9440caa8f877
--- /dev/null
+++ b/repl/test-resources/repl/onePlusOne
@@ -0,0 +1,2 @@
+scala> 1 + 1
+val res0: Int = 2
diff --git a/repl/test-resources/repl/overrides b/repl/test-resources/repl/overrides
new file mode 100644
index 000000000000..05ddd3229deb
--- /dev/null
+++ b/repl/test-resources/repl/overrides
@@ -0,0 +1,10 @@
+scala> class B { override def foo(i: Int): Unit = {}; }
+1 | class B { override def foo(i: Int): Unit = {}; }
+  |                        ^
+  |                        method foo overrides nothing
+scala> class A { def foo: Unit = {}; }
+// defined class A
+scala> class B extends A { override def foo(i: Int): Unit = {}; }
+1 | class B extends A { override def foo(i: Int): Unit = {}; }
+  |                                  ^
+  |      method foo has a different signature than the overridden declaration
diff --git a/tests/repl/patdef.check b/repl/test-resources/repl/patdef
similarity index 94%
rename from tests/repl/patdef.check
rename to repl/test-resources/repl/patdef
index c92b678e003c..8dd059daf184 100644
--- a/tests/repl/patdef.check
+++ b/repl/test-resources/repl/patdef
@@ -7,4 +7,3 @@ val b: Int = 2
 scala> val a@b = 0
 val a: Int @unchecked = 0
 val b: Int @unchecked = 0
-scala> :quit
diff --git a/repl/test-resources/repl/renderNull b/repl/test-resources/repl/renderNull
new file mode 100644
index 000000000000..d01a6d2a5686
--- /dev/null
+++ b/repl/test-resources/repl/renderNull
@@ -0,0 +1,2 @@
+scala> val x: String = null
+val x: String = null
diff --git a/tests/repl/toplevelTry.check b/repl/test-resources/repl/toplevelTry
similarity index 82%
rename from tests/repl/toplevelTry.check
rename to repl/test-resources/repl/toplevelTry
index 5b9be157f975..ad781d93c9a2 100644
--- a/tests/repl/toplevelTry.check
+++ b/repl/test-resources/repl/toplevelTry
@@ -1,3 +1,2 @@
 scala> try { 0 } catch { _: Throwable => 1 }
 val res0: Int = 0
-scala> :quit
diff --git a/tests/repl/vc.check b/repl/test-resources/repl/valueClassMember
similarity index 76%
rename from tests/repl/vc.check
rename to repl/test-resources/repl/valueClassMember
index e2c9b65fda1e..5462136b25a9 100644
--- a/tests/repl/vc.check
+++ b/repl/test-resources/repl/valueClassMember
@@ -1,5 +1,4 @@
 scala> class Foo(x: Int) extends AnyVal { def hi: Int = 1 }
-defined class Foo
+// defined class Foo
 scala> new Foo(1).hi
 val res0: Int = 1
-scala> :quit
diff --git a/tests/repl/vars.check b/repl/test-resources/repl/varOrder
similarity index 72%
rename from tests/repl/vars.check
rename to repl/test-resources/repl/varOrder
index 2e21e1a9fbb4..58b6453bf3ed 100644
--- a/tests/repl/vars.check
+++ b/repl/test-resources/repl/varOrder
@@ -4,5 +4,4 @@ scala> x = x + 1
 x: Int = 1
 scala> x *= 2
 scala> x
-val res2: Int = 2
-scala> :quit
+val res0: Int = 2
diff --git a/repl/test-resources/type-printer/classDefs b/repl/test-resources/type-printer/classDefs
new file mode 100644
index 000000000000..549dfa6031ad
--- /dev/null
+++ b/repl/test-resources/type-printer/classDefs
@@ -0,0 +1,4 @@
+scala> class T[A,B,C] { override def toString = getClass.getName.toString }
+// defined class T
+scala> new T[Int, String, Boolean]
+val res0: T[Int, String, Boolean] = T
diff --git a/repl/test-resources/type-printer/defs b/repl/test-resources/type-printer/defs
new file mode 100644
index 000000000000..f4f6514b1980
--- /dev/null
+++ b/repl/test-resources/type-printer/defs
@@ -0,0 +1,10 @@
+scala> def foo: Int = 5
+def foo: Int
+scala> def bar(x: Int): Int = x
+def bar(x: Int): Int
+scala> def baz[A](a: A): A = a
+def baz[A](a: A): A
+scala> def qux[A](a: A): a.type = a
+def qux[A](a: A): a.type
+scala> def singleton: 1 = 1
+def singleton: 1
diff --git a/repl/test-resources/type-printer/hkClass b/repl/test-resources/type-printer/hkClass
new file mode 100644
index 000000000000..cb1e4a0ce637
--- /dev/null
+++ b/repl/test-resources/type-printer/hkClass
@@ -0,0 +1,4 @@
+scala> case class Foo[M[_]](x: M[Int])
+// defined case class Foo
+scala> Foo(Option(1))
+val res0: Foo[Option] = Foo(Some(1))
diff --git a/tests/repl/infix-types.check b/repl/test-resources/type-printer/infix
similarity index 92%
rename from tests/repl/infix-types.check
rename to repl/test-resources/type-printer/infix
index 1f2a9275c23a..460bbd9a619d 100644
--- a/tests/repl/infix-types.check
+++ b/repl/test-resources/type-printer/infix
@@ -1,5 +1,5 @@
 scala> class &&[T,U]
-defined class &&
+// defined class &&
 scala> def foo: Int && Boolean = ???
 def foo: Int && Boolean
 scala> def foo: Int && Boolean && String = ???
@@ -7,7 +7,7 @@ def foo: Int && Boolean && String
 scala> def foo: Int && (Boolean && String) = ???
 def foo: Int && (Boolean && String)
 scala> class &:[L, R]
-defined class &:
+// defined class &:
 scala> def foo: Int &: String = ???
 def foo: Int &: String
 scala> def foo: Int &: Boolean &: String = ???
@@ -16,4 +16,3 @@ scala> def foo: (Int && String) &: Boolean = ???
 def foo: (Int && String) &: Boolean
 scala> def foo: Int && (Boolean &: String) = ???
 def foo: Int && (Boolean &: String)
-scala> :quit
diff --git a/repl/test-resources/type-printer/type-mismatch b/repl/test-resources/type-printer/type-mismatch
new file mode 100644
index 000000000000..4452d880a324
--- /dev/null
+++ b/repl/test-resources/type-printer/type-mismatch
@@ -0,0 +1,10 @@
+scala> case class Foo[A](a: A)
+// defined case class Foo
+scala> Foo(1)
+val res0: Foo[Int] = Foo(1)
+scala> val x: Foo[String] = res0
+1 | val x: Foo[String] = res0
+  |                      ^^^^
+  |                      found:    Foo[Int](res0)
+  |                      required: Foo[String]
+  |
diff --git a/repl/test-resources/type-printer/typeAliasInfix b/repl/test-resources/type-printer/typeAliasInfix
new file mode 100644
index 000000000000..9204d080fda2
--- /dev/null
+++ b/repl/test-resources/type-printer/typeAliasInfix
@@ -0,0 +1,4 @@
+scala> trait +[A, B]
+// defined trait +
+scala> type IntAndString = Int + String
+// defined alias type IntAndString = Int + String
diff --git a/repl/test-resources/type-printer/vals b/repl/test-resources/type-printer/vals
new file mode 100644
index 000000000000..cfffdf183c99
--- /dev/null
+++ b/repl/test-resources/type-printer/vals
@@ -0,0 +1,10 @@
+scala> val x = 1
+val x: Int = 1
+scala> var y = 2
+var y: Int = 2
+scala> val xs = List(1)
+val xs: List[Int] = List(1)
+scala> scala.util.Try(1)
+val res0: scala.util.Try[Int] = Success(1)
+scala> Map(1 -> "one")
+val res1: Map[Int, String] = Map(1 -> "one")
diff --git a/repl/test/dotty/tools/repl/CompilerTests.scala b/repl/test/dotty/tools/repl/CompilerTests.scala
new file mode 100644
index 000000000000..20f29e45829f
--- /dev/null
+++ b/repl/test/dotty/tools/repl/CompilerTests.scala
@@ -0,0 +1,95 @@
+package dotty.tools
+package repl
+
+import org.junit.Assert._
+import org.junit.Test
+
+import dotc.core.Contexts.Context
+import dotc.ast.Trees._
+import dotc.ast.untpd
+
+import results._
+import ReplTest._
+
+class ReplCompilerTests extends ReplTest {
+
+  @Test def compileSingle: Unit = fromInitialState { implicit state =>
+    compiler.compile("def foo: 1 = 1").stateOrFail
+  }
+
+
+  @Test def compileTwo =
+    fromInitialState { implicit state =>
+      compiler.compile("def foo: 1 = 1").stateOrFail
+    }
+    .andThen { implicit state =>
+      val s2 = compiler.compile("def foo(i: Int): i.type = i").stateOrFail
+      assert(s2.objectIndex == 2,
+             s"Wrong object offset: expected 2 got ${s2.objectIndex}")
+    }
+
+  @Test def inspectSingle =
+    fromInitialState { implicit state =>
+      val untpdTree = compiler.compile("def foo: 1 = 1").map(_._1.untpdTree)
+
+      untpdTree.fold(
+        onErrors,
+        _ match {
+          case PackageDef(_, List(mod: untpd.ModuleDef)) =>
+            implicit val ctx = state.run.runContext
+            assert(mod.name.show == "rs$line$1", mod.name.show)
+          case tree => fail(s"Unexpected structure: $tree")
+        }
+      )
+    }
+
+  @Test def testVar = fromInitialState { implicit state =>
+    compile("var x = 5")
+    assertEquals("var x: Int = 5\n", storedOutput())
+  }
+
+  @Test def testRes = fromInitialState { implicit state =>
+    compile {
+      """|def foo = 1 + 1
+         |val x = 5 + 5
+         |1 + 1
+         |var y = 5
+         |10 + 10""".stripMargin
+    }
+
+    val expected = Set("def foo: Int",
+                       "val x: Int = 10",
+                       "val res1: Int = 20",
+                       "val res0: Int = 2",
+                       "var y: Int = 5")
+
+    expected === storedOutput().split("\n")
+  }
+
+  @Test def testImportMutable =
+    fromInitialState { implicit state =>
+      compile("import scala.collection.mutable")
+    }
+    .andThen { implicit state =>
+      assert(state.imports.nonEmpty, "Didn't add import to `State` after compilation")
+
+      compile("""mutable.Map("one" -> 1)""")
+
+      assertEquals(
+        "val res0: scala.collection.mutable.Map[String, Int] = Map(one -> 1)\n",
+        storedOutput()
+      )
+    }
+
+  @Test def rebindVariable =
+    fromInitialState { implicit s => compile("var x = 5") }
+    .andThen { implicit s =>
+      compile("x = 10")
+      assertEquals(
+        """|var x: Int = 5
+           |x: Int = 10
+           |""".stripMargin,
+        storedOutput()
+      )
+    }
+}
diff --git a/repl/test/dotty/tools/repl/ReplTest.scala b/repl/test/dotty/tools/repl/ReplTest.scala
new file mode 100644
index 000000000000..82d1baac52a2
--- /dev/null
+++ b/repl/test/dotty/tools/repl/ReplTest.scala
@@ -0,0 +1,105 @@
+package dotty.tools
+package repl
+
+import dotty.Jars
+import java.io.{ OutputStream, PrintStream, ByteArrayOutputStream }
+import org.junit.{ Before, After }
+import dotc.core.Contexts.Context
+import dotc.reporting.MessageRendering
+import org.junit.Assert.fail
+
+import dotc.reporting.diagnostic.MessageContainer
+import results.Result
+
+sealed class NullPrintStream extends ByteArrayOutputStream {
+  override def write(b: Int) = ()
+  override def write(b: Array[Byte], off: Int, len: Int) = ()
+  override def writeTo(out: OutputStream) = ()
+}
+
+sealed class StoringPrintStream extends PrintStream(new NullPrintStream) {
+  private[this] var sb = new StringBuilder
+
+  override def println(obj: Object) =
+    println(obj.toString)
+
+  override def println(str: String) = {
+    sb.append(str)
+    sb += '\n'
+  }
+
+  def flushStored(): String = {
+    val str = sb.toString
+    sb = new StringBuilder
+    str
+  }
+}
+
+class ReplTest extends ReplDriver(
+  Array("-classpath", List(Jars.dottyLib, Jars.dottyInterfaces).mkString(":")),
+  new StoringPrintStream
+) with MessageRendering {
+
+  /** Get the stored output from `out`, resetting the `StoringPrintStream` */
+  def storedOutput(): String =
+    stripColor(out.asInstanceOf[StoringPrintStream].flushStored())
+
+  protected implicit def toParsed(expr: String)(implicit state: State): Parsed = {
+    implicit val ctx = state.run.runContext
+    ParseResult(expr) match {
+      case pr: Parsed => pr
+      case pr =>
+        throw new java.lang.AssertionError(s"Expected parsed, got: $pr")
+    }
+  }
+
+  /** Make sure the context is new before each test */
+  @Before def init(): Unit =
+    resetToInitial()
+
+  /** Reset the stored output */
+  @After def cleanup: Unit =
+    storedOutput()
+
+  def fromInitialState[A](op: State => A): A =
+    op(initState)
+
+  implicit class TestingState(state: State) {
+    def andThen[A](op: State => A): A =
+      op(state.newRun(compiler, rootCtx))
+  }
+}
+
+
+object ReplTest {
+
+  /** Fail if there are errors */
+  def onErrors(xs: Seq[MessageContainer]): Nothing = throw new AssertionError(
+    s"Expected no errors, got: \n${ xs.map(_.message).mkString("\n") }"
+  )
+
+  implicit class TestingStateResult(val res: Result[State]) extends AnyVal {
+    def stateOrFail: State = res.fold(onErrors, x => x)
+  }
+
+  implicit class TestingStateResultTuple[A](val res: Result[(A, State)]) extends AnyVal {
+    def stateOrFail: State = res.fold(onErrors, x => x._2)
+  }
+
+  implicit class SetEquals(val xs: Iterable[String]) extends AnyVal {
+    def ===(other: Iterable[String]): Unit = {
+      val sortedXs = xs.toVector.sorted
+      val sortedOther = other.toVector.sorted
+
+      val nonMatching = sortedXs
+        .zip(sortedOther)
+        .filterNot{ case (a, b) => a == b }
+        .map { case (a, b) =>
+          s"""expected element: "$a" got "$b""""
+        }
+
+      if (nonMatching.nonEmpty)
+        fail(s"\nNot all elements matched:\n${ nonMatching.mkString("\n") }")
+    }
+  }
+}
diff --git a/repl/test/dotty/tools/repl/ScriptedTests.scala b/repl/test/dotty/tools/repl/ScriptedTests.scala
new file mode 100644
index 000000000000..7807c5c1dbdd
--- /dev/null
+++ b/repl/test/dotty/tools/repl/ScriptedTests.scala
@@ -0,0 +1,90 @@
+package dotty.tools
+package repl
+
+import java.io.{ File => JFile }
+
+import org.junit.Assert._
+import org.junit.Test
+
+import scala.collection.mutable.ArrayBuffer
+import scala.io.Source
+
+import dotc.reporting.MessageRendering
+
+/** Runs all tests contained in `/repl/test-resources/scripts` */
+class ScriptedTests extends ReplTest with MessageRendering {
+
+  private def scripts(path: String): Array[JFile] = {
+    val dir = new JFile(getClass.getResource(path).getPath)
+    assert(dir.exists && dir.isDirectory, "Couldn't load scripts dir")
+    dir.listFiles
+  }
+
+  private def testFile(f: JFile): Unit = {
+    val prompt = "scala>"
+    val lines = Source.fromFile(f).getLines.buffered
+
+    def extractInputs(prompt: String): List[String] = {
+      val input = lines.next()
+
+      assert(input.startsWith(prompt),
+        s"""Each file has to start with the prompt: "$prompt"""")
+
+      if (!input.startsWith(prompt)) extractInputs(prompt)
+      else if (lines.hasNext) {
+        // read lines and strip trailing whitespace:
+        while (lines.hasNext && !lines.head.startsWith(prompt))
+          lines.next()
+
+        input :: { if (lines.hasNext) extractInputs(prompt) else Nil }
+      }
+      else Nil
+    }
+
+    def evaluate(state: State, input: String, prompt: String) =
+      try {
+        val nstate = run(input.drop(prompt.length))(state)
+        val out = input + "\n" + stripColor(storedOutput())
+        (out, nstate)
+      }
+      catch {
+        case ex: Throwable =>
+          System.err.println(s"failed while running script: $f, on:\n$input")
+          throw ex
+      }
+
+    def filterEmpties(line: String): List[String] =
+      line.replaceAll("""(?m)\s+$""", "") match {
+        case "" => Nil
+        case nonEmptyLine => nonEmptyLine :: Nil
+      }
+
+    val expectedOutput =
+      Source.fromFile(f).getLines.flatMap(filterEmpties).mkString("\n")
+    val actualOutput = {
+      resetToInitial()
+      init()
+      val inputRes = extractInputs(prompt)
+      val buf = new ArrayBuffer[String]
+      inputRes.foldLeft(initState) { (state, input) =>
+        val (out, nstate) = evaluate(state, input, prompt)
+        buf.append(out)
+        nstate
+      }
+      buf.flatMap(filterEmpties).mkString("\n")
+    }
+
+    if (expectedOutput != actualOutput) {
+      println("expected =========>")
+      println(expectedOutput)
+      println("actual ===========>")
+      println(actualOutput)
+
+      fail(s"Error in file $f, expected output did not match actual")
+    }
+  }
+
+  @Test def replTests = scripts("/repl").foreach(testFile)
+
+  @Test def typePrinterTests = scripts("/type-printer").foreach(testFile)
+}
diff --git a/repl/test/dotty/tools/repl/TabcompleteTests.scala b/repl/test/dotty/tools/repl/TabcompleteTests.scala
new file mode 100644
index 000000000000..84ef6cc130ca
--- /dev/null
+++ b/repl/test/dotty/tools/repl/TabcompleteTests.scala
@@ -0,0 +1,55 @@
+package dotty.tools
+package repl
+
+import org.junit.Assert._
+import org.junit.Test
+
+import dotc.reporting.MessageRendering
+import dotc.ast.untpd
+
+import results._
+import ReplTest._
+
+/** These tests test input that has proved problematic */
+class TabcompleteTests extends ReplTest {
+
+  /** Returns the `(<instance completions>, <companion completions>)`*/
+  private[this] def tabComplete(src: String)(implicit state: State): Completions =
+    completions(src.length, src, state)
+
+  @Test def tabCompleteList: Unit = fromInitialState { implicit s =>
+    val comp = tabComplete("List.r")
+    assertTrue(s"""Expected single element "range" got: ${comp.suggestions}""",
+      comp.suggestions.head == "range")
+  }
+
+  @Test def tabCompleteListInstance: Unit = fromInitialState { implicit s =>
+    val comp = tabComplete("(null: List[Int]).sli")
+    assertTrue(s"""Expected completions "slice" and "sliding": ${comp.suggestions}""",
+      comp.suggestions.sorted == List("slice", "sliding"))
+  }
+
+  @Test def autoCompleteValAssign: Unit =
+    fromInitialState { implicit s => tabComplete("val x = 5") }
+
+  @Test def tabCompleteNumberDot: Unit =
+    fromInitialState { implicit s => tabComplete("val x = 5 + 5.") }
+
+  @Test def tabCompleteInClass: Unit =
+    fromInitialState { implicit s =>
+      tabComplete("class Foo { def bar: List[Int] = List.a")
+    }
+
+  @Test def tabCompleteTwiceIn: Unit = {
+    val src1 = "class Foo { def bar: List[Int] = List.a"
+    val src2 = "class Foo { def bar: List[Int] = List.app"
+
+    fromInitialState { implicit state =>
+      assert(tabComplete(src1).suggestions.nonEmpty)
+      state
+    }
+    .andThen { implicit state =>
+      assert(tabComplete(src2).suggestions.nonEmpty)
+    }
+  }
+}
diff --git a/repl/test/dotty/tools/repl/TypeTests.scala b/repl/test/dotty/tools/repl/TypeTests.scala
new file mode 100644
index 000000000000..e751eb362afa
--- /dev/null
+++ b/repl/test/dotty/tools/repl/TypeTests.scala
@@ -0,0 +1,26 @@
+package dotty.tools
+package repl
+
+import org.junit.Test
+import org.junit.Assert._
+
+import ReplTest._
+
+class TypeTests extends ReplTest {
+  @Test def typeOf1 = fromInitialState { implicit s =>
+    compiler.typeOf("1")
+            .fold(onErrors, assertEquals("Int", _))
+  }
+
+  @Test def typeOfBlock = fromInitialState { implicit s =>
+    compiler.typeOf("{ /** omg omg omg */ 1 + 5; 1 }")
+            .fold(onErrors,  assertEquals("Int", _))
+  }
+
+  @Test def typeOfX =
+    fromInitialState { implicit s => compile("val x = 5") }
+    .andThen { implicit s =>
+      compiler.typeOf("x")
+              .fold(onErrors, assertEquals("Int", _))
+    }
+}
diff --git a/sbt-bridge/src/xsbt/ConsoleInterface.scala b/sbt-bridge/src/xsbt/ConsoleInterface.scala
index b34eb8a4d663..a98de74ff76a 100644
--- a/sbt-bridge/src/xsbt/ConsoleInterface.scala
+++ b/sbt-bridge/src/xsbt/ConsoleInterface.scala
@@ -6,8 +6,7 @@ package xsbt
 import xsbti.Logger
 
 import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.repl.REPL
-import dotty.tools.dotc.repl.REPL.Config
+import dotty.tools.repl.ReplDriver
 
 class ConsoleInterface {
   def commandArguments(
@@ -20,6 +19,24 @@ class ConsoleInterface {
   def run(args: Array[String],
           bootClasspathString: String,
           classpathString: String,
+          // TODO: initial commands needs to be run under some form of special
+          // "silent" mode in the REPL. I.e. the effects should be had without
+          // any visual output.
+          //
+          // To do this we can use the `run` interface to the `ReplDriver` and
+          // pass it a special instance of `ParseResult` like `Silently(res: ParseResult)`
+          // and then observe the effects without printing to `ReplDriver#out`
+          //
+          // This way, the REPL can offer feedback on invalid commands but
+          // still function without stringly logic.
+          //
+          // This same principle can be applied to `cleanupCommands` and
+          // `bindValues`
+          //
+          // Steps:
+          //
+          // 1. Introduce `case class Silent(res: ParseResult) extends ParseResult`
+          // 2. Perform all steps in `interpret` as usual without printing to `out`
           initialCommands: String,
           cleanupCommands: String,
           loader: ClassLoader,
@@ -28,42 +45,12 @@ class ConsoleInterface {
           log: Logger
   ): Unit = {
     val completeArgs =
-      args                                    :+
-      "-bootclasspath" :+ bootClasspathString :+
-      "-classpath"     :+ classpathString
+      args ++ {
+        if (bootClasspathString.isEmpty) Array.empty[String]
+        else Array("-bootclasspath", bootClasspathString)
+      } ++
+      Array("-classpath", classpathString)
 
-    println("Starting dotty interpreter...")
-    val repl = ConsoleInterface.customRepl(
-      initialCommands :: Nil,
-      cleanupCommands :: Nil,
-      bindNames zip bindValues,
-      loader
-    )
-    repl.process(completeArgs)
+    new ReplDriver(completeArgs, classLoader = Some(loader)).runUntilQuit()
   }
 }
-
-object ConsoleInterface {
-  def customConfig(
-    initCmds: List[String],
-    cleanupCmds: List[String],
-    boundVals: Array[(String, Any)],
-    loader: ClassLoader
-  ) = new Config {
-    override val initialCommands: List[String] = initCmds
-    override val cleanupCommands: List[String] = cleanupCmds
-    override val boundValues: Array[(String, Any)] = boundVals
-    override val classLoader: Option[ClassLoader] = Option(loader)
-  }
-
-  def customRepl(cfg: Config): REPL = new REPL {
-    override lazy val config = cfg
-  }
-
-  def customRepl(
-    initCmds: List[String],
-    cleanupCmds: List[String],
-    boundVals: Array[(String, Any)],
-    loader: ClassLoader
-  ): REPL = customRepl(customConfig(initCmds, cleanupCmds, boundVals, loader))
-}
diff --git a/sbt-bridge/test/xsbt/TestDriver.scala b/sbt-bridge/test/xsbt/TestDriver.scala
index ba3f20efa7f0..790c14f4b912 100644
--- a/sbt-bridge/test/xsbt/TestDriver.scala
+++ b/sbt-bridge/test/xsbt/TestDriver.scala
@@ -4,8 +4,6 @@ import dotty.tools.dotc._
 import core.Contexts._
 
 class TestDriver extends Driver {
-  protected def newCompiler(implicit ctx: Context): Compiler = new Compiler
-
   override protected def sourcesRequired = false
 
   def getCompiler(args: Array[String], rootCtx: Context) = {
diff --git a/tests/repl/errmsgs.check b/tests/repl/errmsgs.check
deleted file mode 100644
index 23068cb481e2..000000000000
--- a/tests/repl/errmsgs.check
+++ /dev/null
@@ -1,94 +0,0 @@
-scala> class Inv[T](x: T)
-defined class Inv
-scala> val x: List[String] = List(1)
--- [E007] Type Mismatch Error: <console>:4:27 ----------------------------------
-4 |val x: List[String] = List(1)
-  |                           ^
-  |                           found:    Int(1)
-  |                           required: String
-  |                           
-scala> val y: List[List[String]] = List(List(1))
--- [E007] Type Mismatch Error: <console>:4:38 ----------------------------------
-4 |val y: List[List[String]] = List(List(1))
-  |                                      ^
-  |                                      found:    Int(1)
-  |                                      required: String
-  |                                      
-scala> val z: (List[String], List[Int]) = (List(1), List("a"))
--- [E007] Type Mismatch Error: <console>:4:41 ----------------------------------
-4 |val z: (List[String], List[Int]) = (List(1), List("a"))
-  |                                         ^
-  |                                         found:    Int(1)
-  |                                         required: String
-  |                                         
--- [E007] Type Mismatch Error: <console>:4:50 ----------------------------------
-4 |val z: (List[String], List[Int]) = (List(1), List("a"))
-  |                                                  ^^^
-  |                                                  found:    String("a")
-  |                                                  required: Int
-  |                                                  
-scala> val a: Inv[String] = new Inv(new Inv(1))
--- [E007] Type Mismatch Error: <console>:5:33 ----------------------------------
-5 |val a: Inv[String] = new Inv(new Inv(1))
-  |                                 ^^^^^
-  |                                 found:    Inv[Int]
-  |                                 required: String
-  |                                 
-scala> val b: Inv[String] = new Inv(1)
--- [E007] Type Mismatch Error: <console>:5:29 ----------------------------------
-5 |val b: Inv[String] = new Inv(1)
-  |                             ^
-  |                             found:    Int(1)
-  |                             required: String
-  |                             
-scala> abstract class C {
-           type T
-           val x: T
-           val s: Unit = {
-             type T = String
-             var y: T = x
-             locally {
-               def f() = {
-                 type T = Int
-                 val z: T = y
-               }
-               f()
-             }
-           }
-         }
--- [E007] Type Mismatch Error: <console>:9:17 ----------------------------------
-9 |      var y: T = x
-  |                 ^
-  |found:    C.this.T(C.this.x)
-  |required: T'
-  |
-  |where:    T  is a type in class C
-  |          T' is a type in the initalizer of value s which is an alias of String
--- [E007] Type Mismatch Error: <console>:13:21 ---------------------------------
-13 |          val z: T = y
-   |                     ^
-   |found:    T(y)
-   |required: T'
-   |
-   |where:    T  is a type in the initalizer of value s which is an alias of String
-   |          T' is a type in method f which is an alias of Int
-scala> class Foo() { def bar: Int = 1 }; val foo = new Foo(); foo.barr
--- [E008] Member Not Found Error: <console>:4:59 -------------------------------
-4 |class Foo() { def bar: Int = 1 }; val foo = new Foo(); foo.barr
-  |                                                       ^^^^^^^^
-  |             value `barr` is not a member of Foo - did you mean `foo.bar`?
-scala> val x: List[Int] = "foo" :: List(1)
--- [E007] Type Mismatch Error: <console>:4:19 ----------------------------------
-4 |val x: List[Int] = "foo" :: List(1)
-  |                   ^^^^^
-  |                   found:    String($1$)
-  |                   required: Int
-  |                   
-scala> { def f: Int = g; val x: Int = 1; def g: Int = 5; }
--- [E038] Reference Error: <console>:5:15 --------------------------------------
-5 |{ def f: Int = g; val x: Int = 1; def g: Int = 5; }
-  |               ^
-  |           `g` is a forward reference extending over the definition of `x`
-
-longer explanation available when compiling with `-explain`
-scala> :quit
diff --git a/tests/repl/i2063.check b/tests/repl/i2063.check
deleted file mode 100644
index 4cfee5d03b20..000000000000
--- a/tests/repl/i2063.check
+++ /dev/null
@@ -1,22 +0,0 @@
-scala> 	class Foo extends Bar // with one tab
--- [E006] Unbound Identifier Error: <console>:4:18 -----------------------------
-4 |	class Foo extends Bar // with one tab
-  |	                  ^^^
-  |	                  not found: type Bar
-
-longer explanation available when compiling with `-explain`
-scala>                                                                               class Foo extends Bar // with spaces
--- [E006] Unbound Identifier Error: <console>:4:96 -----------------------------
-4 |                                                                              class Foo extends Bar // with spaces
-  |                                                                                                ^^^
-  |                                                       not found: type Bar
-
-longer explanation available when compiling with `-explain`
-scala>                                                                                  class Foo extends Bar // with tabs
--- [E006] Unbound Identifier Error: <console>:4:99 -----------------------------
-4 |                                                                                 class Foo extends Bar // with tabs
-  |                                                                                                   ^^^
-  |                                                       not found: type Bar
-
-longer explanation available when compiling with `-explain`
-scala> :quit
diff --git a/tests/repl/i2213.check b/tests/repl/i2213.check
deleted file mode 100644
index 40e9395143e8..000000000000
--- a/tests/repl/i2213.check
+++ /dev/null
@@ -1,8 +0,0 @@
-scala> def x
--- [E018] Syntax Error: <console>:1:5 ------------------------------------------
-1 |def x
-  |     ^
-  |     missing return type
-
-longer explanation available when compiling with `-explain`
-scala> :quit
diff --git a/tests/repl/i2492.check b/tests/repl/i2492.check
deleted file mode 100644
index 31e4f836db7b..000000000000
--- a/tests/repl/i2492.check
+++ /dev/null
@@ -1,8 +0,0 @@
-scala> class Map[K, V]
-defined class Map
-scala> val s: Map {type Map$K =String;type Map$V = Int} = null
--- [E055] Syntax Error: <console>:5:7 ------------------------------------------
-5 |val s: Map {type Map$K =String;type Map$V = Int} = null
-  |       ^^^
-  |       missing type parameter for Map
-scala> :quit
diff --git a/tests/repl/imports.check b/tests/repl/imports.check
deleted file mode 100644
index 45407099799f..000000000000
--- a/tests/repl/imports.check
+++ /dev/null
@@ -1,28 +0,0 @@
-scala> import scala.collection.mutable
-import scala.collection.mutable
-scala> val buf = mutable.ListBuffer[Int]()
-val buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
-scala> object o { val xs = List(1, 2, 3) }
-defined module o
-scala> import o._
-import o._
-scala> buf += xs
--- [E007] Type Mismatch Error: <console>:11:7 ----------------------------------
-11 |buf += xs
-   |       ^^
-   |       found:    scala.collection.immutable.List[Int](o.xs)
-   |       required: Int
-   |       
-scala> buf ++= xs
-val res1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
-scala> import util.foo
--- Error: <console>:8:12 -------------------------------------------------------
-8 |import util.foo
-  |            ^^^
-  |            foo is not a member of util
-scala> import util.foo.bar
--- [E008] Member Not Found Error: <console>:8:12 -------------------------------
-8 |import util.foo.bar
-  |       ^^^^^^^^
-  |       value `foo` is not a member of util - did you mean `util.Left`?
-scala> :quit
diff --git a/tests/repl/infixTypeOp.check b/tests/repl/infixTypeOp.check
deleted file mode 100644
index fe8e453fb262..000000000000
--- a/tests/repl/infixTypeOp.check
+++ /dev/null
@@ -1,5 +0,0 @@
-scala> trait +[A, B]
-defined trait +
-scala> type IntAndString = Int + String
-defined type alias IntAndString
-scala> :quit
diff --git a/tests/repl/names.check b/tests/repl/names.check
deleted file mode 100644
index 55279b533ac7..000000000000
--- a/tests/repl/names.check
+++ /dev/null
@@ -1,5 +0,0 @@
-scala> case class Foo[M[_]](x: M[Int]) 
-defined class Foo
-scala> Foo(Option(1))
-val res0: Foo[Option] = Foo(Some(1))
-scala> :quit
diff --git a/tests/repl/onePlusOne.check b/tests/repl/onePlusOne.check
deleted file mode 100644
index 1e906069354b..000000000000
--- a/tests/repl/onePlusOne.check
+++ /dev/null
@@ -1,3 +0,0 @@
-scala> 1+1
-val res0: Int = 2
-scala> :quit
diff --git a/tests/repl/overrides.check b/tests/repl/overrides.check
deleted file mode 100644
index 75970d0a104a..000000000000
--- a/tests/repl/overrides.check
+++ /dev/null
@@ -1,17 +0,0 @@
-scala> class B { override def foo(i: Int): Unit = {}; }
--- [E036] Reference Error: <console>:4:23 --------------------------------------
-4 |class B { override def foo(i: Int): Unit = {}; }
-  |                       ^
-  |                       method foo overrides nothing
-
-longer explanation available when compiling with `-explain`
-scala> class A { def foo: Unit = {}; }
-defined class A
-scala> class B extends A { override def foo(i: Int): Unit = {}; }
--- [E037] Reference Error: <console>:5:33 --------------------------------------
-5 |class B extends A { override def foo(i: Int): Unit = {}; }
-  |                                 ^
-  |      method foo has a different signature than the overridden declaration
-
-longer explanation available when compiling with `-explain`
-scala> :quit
diff --git a/tests/repl/showMethod.check b/tests/repl/showMethod.check
deleted file mode 100644
index 428e3a2f6ed1..000000000000
--- a/tests/repl/showMethod.check
+++ /dev/null
@@ -1,9 +0,0 @@
-scala> class A { def show = "hello"; override def toString = "A" }
-defined class A
-scala> new A
-val res0: A = A
-scala> class B { def show() = "hello"; override def toString = "B" }
-defined class B
-scala> new B
-val res1: B = B
-scala> :quit