Clean up compilation logic, make union decorator work

Author: felixmulder

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

@@ -0,0 +1,19 @@
+package dotty.tools
+package repl
+
+import dotc.core.Contexts.Context
+import dotc.ast.tpd._
+
+import results._
+
+case class InjectableTree(obj: TypeDef, nextId: Int)
+
+object InjectableTree {
+  def apply()(implicit ctx: Context) = new InjectableTree({
+    ???
+  }, 0)
+
+  def patch(tree: InjectableTree, res: TypedTrees)
+           (implicit ctx: Context): Result[InjectableTree] =
+    ???
+}

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

@@ -11,6 +11,7 @@ import dotc.config.CompilerCommand
 import dotc.{ Compiler, Driver }
 
 import AmmoniteReader._
+import results._
 
 class Repl(settings: Array[String]) extends Driver {
 
@@ -26,21 +27,23 @@ class Repl(settings: Array[String]) extends Driver {
     ictx
   }
 
-  private[this] var myCtx = initializeCtx
-  private[this] var typer = new ReplTyper(myCtx)
+  private[this] var myCtx    = initializeCtx
+  private[this] var typer    = new ReplTyper(myCtx)
+  private[this] var compiler = new ReplCompiler(myCtx)
 
   private def readLine(history: History) =
     AmmoniteReader(history)(myCtx).prompt()
 
   @tailrec
-  final def run(history: History = Nil): Unit =
+  final def run(history: History = Nil,
+                tree: InjectableTree = InjectableTree()(myCtx)): Unit =
     readLine(history) match {
       case (parsed: Parsed, history) =>
-        compile(parsed, history.length)
-        run(history)
+        val newTree = compile(parsed, tree)(myCtx)
+        run(history, newTree)
 
       case (SyntaxErrors(errs, ctx), history) =>
-        displaySyntaxErrors(errs)(ctx)
+        displayErrors(errs)(ctx)
         run(history)
 
       case (Newline, history) =>
@@ -50,8 +53,22 @@ class Repl(settings: Array[String]) extends Driver {
         interpretCommand(cmd, history)
     }
 
-  def compile(parsed: Parsed, line: Int): Unit =
-    typer.typeCheck(parsed, line)(myCtx)
+  def compile(parsed: Parsed, tree: InjectableTree)(implicit ctx: Context): InjectableTree = {
+    val res = for {
+      typed    <- typer.typeCheck(parsed, tree.nextId)
+      injected <- InjectableTree.patch(tree, typed)
+      _        <- compiler.compile(injected.obj)
+    } yield injected
+
+    // Fold over result, on failure - report errors and return old `tree`:
+    res.fold(
+      errors => {
+        displayErrors(errors.msgs)
+        tree
+      },
+      id
+    )
+  }
 
   def interpretCommand(cmd: Command, history: History): Unit = cmd match {
     case UnknownCommand(cmd) => {
@@ -87,6 +104,6 @@ class Repl(settings: Array[String]) extends Driver {
   private def renderMessage(cont: MessageContainer): Context => String =
     messageRenderer.messageAndPos(cont.contained(), cont.pos, messageRenderer.diagnosticLevel(cont))
 
-  def displaySyntaxErrors(errs: Seq[MessageContainer])(implicit ctx: Context): Unit =
+  def displayErrors(errs: Seq[MessageContainer])(implicit ctx: Context): Unit =
     errs.map(renderMessage(_)(ctx)).foreach(println)
 }

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

@@ -0,0 +1,35 @@
+package dotty.tools
+package repl
+
+import dotc.ast.tpd
+import dotc.core.{ Phases, Decorators, Flags }
+import dotc.core.Contexts.Context
+import dotc.{ CompilationUnit, Compiler }
+import backend.jvm.GenBCode
+import io._
+import results._
+
+class ReplCompiler(ictx: Context) extends Compiler {
+  /** A GenBCode phase that outputs to a virtual directory */
+  private class REPLGenBCode extends GenBCode {
+    override def phaseName = "replGenBCode"
+
+    /** Directory to save class files to */
+    private val virtualDirectory =
+      if (ictx.settings.d.isDefault(ictx))
+        new VirtualDirectory("(memory)", None)
+      else
+        new PlainDirectory(new Directory(new JFile(ictx.settings.d.value(ictx))))
+
+    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
+  )
+
+  def compile(tree: tpd.Tree)(implicit ctx: Context): Result[Unit] = ()
+}

repl/src/dotty/tools/repl/ReplTyper.scala

@@ -10,13 +10,16 @@ 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._
+
+case class TypedTrees(nextId: Int, trees: Seq[tpd.Tree])
+
 class ReplTyper(ictx: Context) extends Compiler {
 
   type NextRes = Int
@@ -70,11 +73,7 @@ class ReplTyper(ictx: Context) extends Compiler {
       case _ => Nil
     }
 
-  sealed trait Result
-  case class TypedTrees(trees: Seq[tpd.Tree]) extends Result
-  case class TypeErrors(msgs: Seq[MessageContainer]) extends Result
-
-  def typeCheck(parsed: Parsed, currentRes: Int)(implicit ctx: Context): (NextRes, Result) = {
+  def typeCheck(parsed: Parsed, currentRes: Int)(implicit ctx: Context): Result[TypedTrees] = {
     val reporter = new StoreReporter(null) with UniqueMessagePositions with HideNonSensicalMessages
 
     val unit = new CompilationUnit(new SourceFile(s"repl-run-$currentRes", parsed.sourceCode))
@@ -85,10 +84,7 @@ class ReplTyper(ictx: Context) extends Compiler {
     run.compileUnits(unit :: Nil)
 
     val errs = reporter.removeBufferedMessages
-    val res =
-      if (errs.isEmpty) TypedTrees(extractStats(unit.tpdTree))
-      else TypeErrors(errs)
-
-    (newRes, res)
+    if (errs.isEmpty) TypedTrees(newRes, extractStats(unit.tpdTree))
+    else Errors(errs)
   }
 }

repl/src/dotty/tools/repl/results.scala

@@ -0,0 +1,26 @@
+package dotty.tools
+package repl
+
+import dotc.reporting.diagnostic.MessageContainer
+
+object results {
+  type Result[A] = Errors | A
+
+  case class Errors(msgs: Seq[MessageContainer])
+
+  implicit class RichResult[A](val res: Result[A]) /*extends AnyVal */{
+    def map[B](f: A => B): Result[B] = res match {
+      case errs: Errors => errs
+      case a: A => f(a)
+    }
+
+    def flatMap[B](f: A => Result[B]): Result[B] = map(f)
+
+    def fold[B](left: Errors => B, right: A => B): B = res match {
+      case errors: Errors => left(errors)
+      case a: A => right(a)
+    }
+  }
+
+  def id[A](a: A): a.type = a
+}