REPL state now store a Context instead of a Run

Author: allanrenucci

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -72,7 +72,7 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
   private def definitions(trees: List[untpd.Tree], state: State): Definitions = {
     import untpd._
 
-    implicit val ctx: Context = state.run.runContext
+    implicit val ctx: Context = state.context
 
     var valIdx = state.valIndex
 
@@ -120,7 +120,7 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
 
     assert(defs.stats.nonEmpty)
 
-    implicit val ctx: Context = defs.state.run.runContext
+    implicit val ctx: Context = defs.state.context
 
     val tmpl = Template(emptyConstructor, Nil, EmptyValDef, defs.stats)
     val module = ModuleDef(objectName(defs.state), tmpl)
@@ -137,12 +137,11 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
   }
 
   private def runCompilationUnit(unit: CompilationUnit, state: State): Result[(CompilationUnit, State)] = {
-    val run = state.run
-    val reporter = state.run.runContext.reporter
-    run.compileUnits(unit :: Nil)
+    val ctx = state.context
+    ctx.run.compileUnits(unit :: Nil)
 
-    if (!reporter.hasErrors) (unit, state).result
-    else run.runContext.flushBufferedMessages().errors
+    if (!ctx.reporter.hasErrors) (unit, state).result
+    else ctx.reporter.removeBufferedMessages(ctx).errors
   }
 
   final def compile(parsed: Parsed)(implicit state: State): Result[(CompilationUnit, State)] = {
@@ -154,7 +153,7 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
   final def typeOf(expr: String)(implicit state: State): Result[String] =
     typeCheck(expr).map { tree =>
       import dotc.ast.Trees._
-      implicit val ctx = state.run.runContext
+      implicit val ctx = state.context
       tree.rhs match {
         case Block(xs, _) => xs.last.tpe.widen.show
         case _ =>
@@ -218,23 +217,20 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
     }
 
 
-    val run = state.run
-    val reporter = newStoreReporter
-    val src = new SourceFile(s"EvaluateExpr", expr)
-    val runCtx =
-      run.runContext.fresh
-         .setReporter(reporter)
-         .setSetting(run.runContext.settings.YstopAfter, List("frontend"))
+    val src = new SourceFile("<typecheck>", expr)
+    implicit val ctx = state.context.fresh
+      .setReporter(newStoreReporter)
+      .setSetting(state.context.settings.YstopAfter, List("frontend"))
 
-    wrapped(expr, src, state)(runCtx).flatMap { pkg =>
+    wrapped(expr, src, state).flatMap { pkg =>
       val unit = new CompilationUnit(src)
       unit.untpdTree = pkg
-      run.compileUnits(unit :: Nil, runCtx)
+      ctx.run.compileUnits(unit :: Nil, ctx)
 
-      if (errorsAllowed || !reporter.hasErrors)
-        unwrapped(unit.tpdTree, src)(runCtx)
+      if (errorsAllowed || !ctx.reporter.hasErrors)
+        unwrapped(unit.tpdTree, src)
       else {
-        reporter.removeBufferedMessages(runCtx).errors
+        ctx.reporter.removeBufferedMessages.errors
       }
     }
   }

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -51,7 +51,7 @@ import scala.collection.JavaConverters._
 case class State(objectIndex: Int,
                  valIndex: Int,
                  imports: List[untpd.Import],
-                 run: Run)
+                 context: Context)
 
 /** Main REPL instance, orchestrating input, compilation and presentation */
 class ReplDriver(settings: Array[String],
@@ -72,7 +72,7 @@ class ReplDriver(settings: Array[String],
   }
 
   /** the initial, empty state of the REPL session */
-  protected[this] def initState = State(0, 0, Nil, compiler.newRun(rootCtx, 0))
+  protected[this] def initState = State(0, 0, Nil, rootCtx)
 
   /** Reset state of repl to the initial state
    *
@@ -118,7 +118,7 @@ class ReplDriver(settings: Array[String],
         val comps = completions(line.cursor, line.line, state)
         candidates.addAll(comps.asJava)
       }
-      implicit val ctx = state.run.runContext
+      implicit val ctx = state.context
       try {
         val line = terminal.readLine(completer)
         ParseResult(line)
@@ -140,16 +140,16 @@ class ReplDriver(settings: Array[String],
   }
 
   final def run(input: String)(implicit state: State): State = withRedirectedOutput {
-    val parsed = ParseResult(input)(state.run.runContext)
+    val parsed = ParseResult(input)(state.context)
     interpret(parsed)
   }
 
   private def withRedirectedOutput(op: => State): State =
     Console.withOut(out) { Console.withErr(out) { op } }
 
   private def newRun(state: State) = {
-    val newRun = compiler.newRun(rootCtx.fresh.setReporter(newStoreReporter), state.objectIndex)
-    state.copy(run = newRun)
+    val run = compiler.newRun(rootCtx.fresh.setReporter(newStoreReporter), state.objectIndex)
+    state.copy(context = run.runContext)
   }
 
   /** Extract possible completions at the index of `cursor` in `expr` */
@@ -173,7 +173,7 @@ class ReplDriver(settings: Array[String],
         val file = new SourceFile("<completions>", expr)
         val unit = new CompilationUnit(file)
         unit.tpdTree = tree
-        implicit val ctx = state.run.runContext.fresh.setCompilationUnit(unit)
+        implicit val ctx = state.context.fresh.setCompilationUnit(unit)
         val srcPos = SourcePosition(file, Position(cursor))
         val (_, completions) = Interactive.completions(srcPos)
         completions.map(makeCandidate)
@@ -224,16 +224,16 @@ class ReplDriver(settings: Array[String],
             val newImports = newState.imports ++ extractImports(parsed.trees)
             val newStateWithImports = newState.copy(imports = newImports)
 
-            // display warnings
-            displayErrors(newState.run.runContext.flushBufferedMessages())(newState)
+            val warnings = newState.context.reporter.removeBufferedMessages(newState.context)
+            displayErrors(warnings)(newState) // display warnings
             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
+    implicit val ctx = state.context
 
     def resAndUnit(denot: Denotation) = {
       import scala.util.{Success, Try}
@@ -319,7 +319,7 @@ class ReplDriver(settings: Array[String],
       initState
 
     case Imports =>
-      state.imports.foreach(i => out.println(SyntaxHighlighting(i.show(state.run.runContext))))
+      state.imports.foreach(i => out.println(SyntaxHighlighting(i.show(state.context))))
       state
 
     case Load(path) =>
@@ -356,7 +356,7 @@ class ReplDriver(settings: Array[String],
 
   /** Output errors to `out` */
   private def displayErrors(errs: Seq[MessageContainer])(implicit state: State): State = {
-    errs.map(renderMessage(_)(state.run.runContext)).foreach(out.println)
+    errs.map(renderMessage(_)(state.context)).foreach(out.println)
     state
   }
 }

compiler/src/dotty/tools/repl/package.scala

@@ -19,12 +19,4 @@ package object repl {
       text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.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
-      }
-  }
 }