Use single compiler instance instead of split pipeline

Author: felixmulder

repl/src/dotty/tools/repl/InjectableTree.scala

@@ -13,13 +13,18 @@ import dotc.{ Compiler, Driver }
 import AmmoniteReader._
 import results._
 
+case class State(objects: Int, freeValues: Int, history: History, ictx: Context)
+object State {
+  def initial(ctx: Context): State = new State(0, 0, Nil, ctx)
+}
+
 class Repl(settings: Array[String]) extends Driver {
 
   // FIXME: Change the Driver API to not require implementing this method
   override protected def newCompiler(implicit ctx: Context): Compiler =
     ???
 
-  private[this] def initializeCtx = {
+  protected[this] def initializeCtx = {
     val rootCtx = initCtx.fresh
     val summary = CompilerCommand.distill(settings)(rootCtx)
     val ictx = rootCtx.setSettings(summary.sstate)
@@ -28,75 +33,69 @@ class Repl(settings: Array[String]) extends Driver {
   }
 
   protected[this] var myCtx    = initializeCtx: Context
-  protected[this] var typer    = new ReplTyper(myCtx)
   protected[this] var compiler = new ReplCompiler(myCtx)
 
   private def readLine(history: History) =
     AmmoniteReader(history)(myCtx).prompt()
 
   @tailrec
-  final def run(history: History = Nil,
-                tree: InjectableTree = InjectableTree()(myCtx)): Unit =
-    readLine(history) match {
+  final def run(state: State = State.initial(myCtx)): Unit =
+    readLine(state.history) match {
       case (parsed: Parsed, history) =>
-        val newTree = compile(parsed, tree)(myCtx)
-        run(history, newTree)
+        val newState = compile(parsed, state)
+        run(newState.copy(history = history))
 
       case (SyntaxErrors(errs, ctx), history) =>
         displayErrors(errs)(ctx)
-        run(history)
+        run(state)
 
       case (Newline, history) =>
-        run(history)
+        run(state)
 
       case (cmd: Command, history) =>
-        interpretCommand(cmd, history)
+        interpretCommand(cmd, state)
     }
 
-  def compile(parsed: Parsed, tree: InjectableTree)(implicit ctx: Context): InjectableTree = {
-    val res = for {
-      typed    <- typer.typeCheck(parsed, tree.nextId)
-      injected <- InjectableTree.patch(tree, typed)(typed.newCtx)
-      _        <- compiler.compile(injected.obj)(typed.newCtx)
-    } yield (injected, typed.newCtx)
-
-    // Fold over result, on failure - report errors and return old `tree`:
-    res.fold(
-      errors => {
-        displayErrors(errors.msgs)
-        tree
-      },
-      (injected, newCtx) => {
-        myCtx = newCtx
-        injected
-      }
-    )
+  def compile(parsed: Parsed, state: State): State = {
+    implicit val ctx = state.ictx
+    compiler
+      .compile(parsed, state)
+      .fold(
+        errors => {
+          displayErrors(errors.msgs)
+          state
+        },
+        state => {
+          myCtx = state.ictx
+          state
+        }
+      )
   }
 
-  def interpretCommand(cmd: Command, history: History): Unit = cmd match {
+  def interpretCommand(cmd: Command, state: State): Unit = cmd match {
     case UnknownCommand(cmd) => {
       println(s"""Unknown command: "$cmd", run ":help" for a list of commands""")
-      run(history)
+      run(state)
     }
 
     case Help => {
       println(Help.text)
-      run(history)
+      run(state)
     }
 
     case Reset => {
       myCtx = initCtx.fresh
-      run(Nil)
+      run()
     }
 
     case Load(path) =>
       if ((new java.io.File(path)).exists) {
         val contents = scala.io.Source.fromFile(path).mkString
-        run(contents :: history)
+        run(state.copy(history = contents :: state.history))
       }
       else {
         println(s"""Couldn't find file "$path"""")
-        run(history)
+        run(state)
       }
 
     case Quit =>

repl/src/dotty/tools/repl/Repl.scala

@@ -1,15 +1,44 @@
 package dotty.tools
 package repl
 
+import java.io.{ File => JFile }
+
+import dotc.ast.untpd
 import dotc.ast.tpd
-import dotc.core.{ Phases, Decorators, Flags }
-import dotc.core.Contexts.Context
 import dotc.{ CompilationUnit, Compiler }
+import dotc.core.{ Phases, Decorators, Flags }
+import Decorators._, Flags._
+import dotc.util.SourceFile
+import dotc.typer.FrontEnd
 import backend.jvm.GenBCode
+import dotc.core.Contexts.Context
+import dotc.util.Positions._
+import dotc.reporting.diagnostic.MessageContainer
+import dotc.reporting._
 import io._
+
 import results._
 
 class ReplCompiler(ictx: Context) extends Compiler {
+
+  type NextRes = Int
+
+  private class REPLFrontEnd extends FrontEnd {
+    override def phaseName = "replFrontEnd"
+
+    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)
+    }
+  }
+
   /** A GenBCode phase that outputs to a virtual directory */
   private class REPLGenBCode extends GenBCode {
     override def phaseName = "replGenBCode"
@@ -24,12 +53,68 @@ class ReplCompiler(ictx: Context) extends Compiler {
     override def outputDir(implicit ctx: Context) = virtualDirectory
   }
 
-  /** Phases without `FrontEnd`, and a modified `GenBCode` */
-  override def phases = Phases.replace(
-    classOf[GenBCode],
-    _ => new REPLGenBCode :: Nil,
-    super.phases.tail
-  )
+  override def phases = {
+    val replacedFrontend = Phases.replace(
+      classOf[FrontEnd],
+      _ => new REPLFrontEnd :: Nil,
+      super.phases
+    )
+
+    Phases.replace(
+      classOf[GenBCode],
+      _ => new REPLGenBCode :: Nil,
+      replacedFrontend
+    )
+  }
+
+  def freeToAssigned(trees: Seq[untpd.Tree], state: State)
+                    (implicit ctx: Context): (State, Seq[untpd.Tree]) = {
+    import untpd._
+
+    def freeExpression(t: Tree) =
+      t.isTerm && !t.isInstanceOf[Assign]
+
+    val (exps, other) = trees.partition(freeExpression)
+    val resX = exps.zipWithIndex.map { (exp, i) =>
+      ValDef(s"res${i + state.freeValues}".toTermName, TypeTree(), exp)
+        .withPos(exp.pos)
+    }
+
+    (state.copy(freeValues = state.freeValues + resX.length), resX ++ other)
+  }
+
+  def wrapped(trees: Seq[untpd.Tree], nextId: Int)(implicit ctx: Context): untpd.PackageDef = {
+    import untpd._
+    import dotc.core.StdNames._
+
+    val imports = List.range(0, nextId).map{ i =>
+      Import(Ident(("ReplSession$" + i).toTermName), Ident(nme.WILDCARD) :: Nil)
+    }
 
-  def compile(tree: tpd.Tree)(implicit ctx: Context): Result[Unit] = ()
+    val tmpl = Template(emptyConstructor, Nil, EmptyValDef, imports ++ trees)
+    PackageDef(Ident(nme.NO_NAME),
+      ModuleDef(("ReplSession$" + nextId).toTermName, tmpl)
+        .withMods(new Modifiers(Module | Final))
+        .withPos(Position(trees.head.pos.start, trees.last.pos.end)) :: Nil
+    )
+  }
+
+  def compile(parsed: Parsed, state: State)(implicit ctx: Context): Result[State] = {
+    val reporter = new StoreReporter(null) with UniqueMessagePositions with HideNonSensicalMessages
+
+    val unit = new CompilationUnit(new SourceFile("ReplSession$" + (state.objects + 1), parsed.sourceCode))
+    val (stateAfterAssign, trees) = freeToAssigned(parsed.trees, state)
+    unit.untpdTree = wrapped(trees, 0)
+
+    val run = newRun(ctx.fresh.setReporter(reporter))
+    run.compileUnits(unit :: Nil)
+
+    val errs = reporter.removeBufferedMessages
+    if (errs.isEmpty) state.copy(
+      freeValues = stateAfterAssign.freeValues,
+      objects = state.objects + 1,
+      ictx = run.runContext
+    )
+    else Errors(errs)
+  }
 }