Turn dotty-repl project into a Scala 2 project

Author: felixmulder

project/Build.scala

@@ -360,11 +360,10 @@ object Build {
 
   lazy val `dotty-repl` = project.in(file("repl")).
     dependsOn(
-      `dotty-language-server`,
-      `dotty-compiler-bootstrapped`,
-      `dotty-compiler-bootstrapped` % "test->test"
+      `dotty-compiler`,
+      `dotty-compiler` % "test->test"
     ).
-    settings(commonBootstrappedSettings).
+    settings(commonNonBootstrappedSettings).
     settings(
       // set system in/out for repl
       connectInput in run := true,

repl/src/dotty/tools/repl/ParseResult.scala

@@ -54,8 +54,8 @@ object Load {
  * String
  * ```
  */
-case class Type(expr: String) extends Command
-object Type {
+case class TypeOf(expr: String) extends Command
+object TypeOf {
   val command = ":type"
 }
 
@@ -106,7 +106,7 @@ object ParseResult {
         case Reset.command => Reset
         case Imports.command => Imports
         case Load.command => Load(arg)
-        case Type.command => Type(arg)
+        case TypeOf.command => TypeOf(arg)
         case _ => UnknownCommand(cmd)
       }
       case _ => {

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

@@ -3,6 +3,7 @@ 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
@@ -71,7 +72,7 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
     }
 
     val (exps, other) = trees.partition(_.isTerm)
-    val resX = exps.zipWithIndex.flatMap { (exp, i) =>
+    val resX = exps.zipWithIndex.flatMap { case (exp, i) =>
       val resName = (str.REPL_RES_PREFIX + (i + state.valIndex)).toTermName
       val show = createShow(resName, exp.pos)
 
@@ -107,7 +108,7 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
           ).apply(Nil, pat).reverse
         }
 
-        t :: variables.map(createShow)
+        t :: variables.map { case (name, pos) => createShow(name, pos) }
       }
       case t => List(t)
     }

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

@@ -11,7 +11,7 @@ import dotc.ast.untpd
 import dotc.ast.tpd
 import dotc.interactive.{ SourceTree, Interactive }
 import dotc.core.Contexts.Context
-import dotc.Run
+import dotc.{ CompilationUnit, Run }
 import dotc.core.Mode
 import dotc.core.Flags._
 import dotc.core.Types._
@@ -197,21 +197,25 @@ class ReplDriver(settings: Array[String], protected val out: PrintStream = Syste
 
   /** Compile `parsed` trees and evolve `state` in accordance */
   protected[this] final def compile(parsed: Parsed)(implicit state: State): State = {
+    import dotc.ast.Trees._
+    import dotc.ast.untpd._
     def extractNewestWrapper(tree: untpd.Tree): Name = tree match {
-      case untpd.PackageDef(_, (obj: untpd.ModuleDef) :: Nil) => obj.name.moduleClassName
+      case PackageDef(_, (obj: ModuleDef) :: Nil) => obj.name.moduleClassName
       case _ => nme.NO_NAME
     }
 
     compiler
       .compile(parsed)
       .fold(
         displayErrors,
-        (unit, newState) => {
-          val newestWrapper = extractNewestWrapper(unit.untpdTree)
-          val newImports = newState.imports ++ extractImports(parsed.trees)(newState.run.runContext)
-          val newStateWithImports = newState.copy(imports = newImports)
+        {
+          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)
+            displayDefinitions(unit.tpdTree, newestWrapper)(newStateWithImports)
+          }
         }
       )
   }
@@ -329,12 +333,12 @@ class ReplDriver(settings: Array[String], protected val out: PrintStream = Syste
         state.withHistory(loadCmd)
       }
 
-    case Type(expr) => {
+    case TypeOf(expr) => {
       compiler.typeOf(expr).fold(
         displayErrors,
         res => out.println(SyntaxHighlighting(res))
       )
-      state.withHistory(s"${Type.command} $expr")
+      state.withHistory(s"${TypeOf.command} $expr")
     }
 
     case Quit =>
@@ -360,7 +364,7 @@ class ReplDriver(settings: Array[String], protected val out: PrintStream = Syste
 
   /** Render messages using the `MessageRendering` trait */
   private def renderMessage(cont: MessageContainer): Context => String =
-    messageRenderer.messageAndPos(cont.contained(), cont.pos, messageRenderer.diagnosticLevel(cont))
+    messageRenderer.messageAndPos(cont.contained(), cont.pos, messageRenderer.diagnosticLevel(cont))(_)
 
   /** Output errors to `out` */
   private def displayErrors(errs: Seq[MessageContainer])(implicit state: State): State = {

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

@@ -17,7 +17,7 @@ package object repl {
     new StoreReporter(null)
     with UniqueMessagePositions with HideNonSensicalMessages
 
-  private[repl] implicit class ListOps[A](xs: List[A]) extends AnyVal {
+  private[repl] implicit class ListOps[A](val xs: List[A]) extends AnyVal {
     def intersperse(a: A): List[A] = {
       def recur(xs: List[A]): List[A] = xs match {
         case x :: Nil => List(x)
@@ -27,19 +27,15 @@ package object repl {
     }
   }
 
-  private[repl] implicit class ShowUser(ds: Denotation | Symbol) extends AnyVal {
+  private[repl] implicit class ShowUser(val s: Symbol) extends AnyVal {
     def showUser(implicit ctx: Context): String = {
       val printer = new UserFacingPrinter(ctx)
-      val text = ds match {
-        case d: Denotation => printer.dclText(d.symbol)
-        case s: Symbol => printer.dclText(s)
-      }
-
+      val text = printer.dclText(s)
       text.mkString(ctx.settings.pageWidth.value)
     }
   }
 
-  private[repl] implicit class StoreReporterContext(ctx: Context) extends AnyVal {
+  private[repl] implicit class StoreReporterContext(val ctx: Context) extends AnyVal {
     def flushBufferedMessages(): List[MessageContainer] =
       ctx.reporter match {
         case rep: StoreReporter => rep.removeBufferedMessages(ctx)

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

@@ -7,27 +7,38 @@ import dotc.reporting.diagnostic.MessageContainer
  *  in the REPL
  */
 object results {
-  type Errors = List[MessageContainer]
-  private case class ErrorContainer(messages: Errors)
 
-  /** A result of a computation is either a list of errors or the result `A` */
-  class Result[+A] private[results] (result: ErrorContainer | A) { self =>
+  /** Type alias for `List[MessageContainer]` */
+  private type Errors = List[MessageContainer]
+  /** Private ADT instead of using union type, we're not dotty yet... */
+  private sealed trait Disjunction[+A]
+  /** Successful version of `Disjunction[A]` */
+  private case class Success[A](a: A) extends Disjunction[A]
+  /** Erroneous version of `Disjunction[A]` */
+  private case class ErrorContainer(messages: Errors) extends Disjunction[Nothing]
+
+  /** A result of a computation is either a list of errors or the result `A`
+   *
+   *  @note should be replaced by the right-biased `Either` from 2.12.x, TODO
+   */
+  class Result[+A] private[results] (result: Disjunction[A]) { self =>
+
     def flatMap[B](f: A => Result[B]): Result[B] =
       result match {
         case ec: ErrorContainer => new Result(ec)
-        case a: A @unchecked => f(a)
+        case Success(a) => f(a)
       }
 
     def map[B](f: A => B): Result[B] =
       result match {
         case ec: ErrorContainer => new Result(ec)
-        case a: A @unchecked => new Result(f(a))
+        case Success(a) => new Result(Success(f(a)))
       }
 
     def fold[B](onErrors: Errors => B, onResult: A => B): B =
       result match {
         case ErrorContainer(errs) => onErrors(errs)
-        case a: A @unchecked => onResult(a)
+        case Success(a) => onResult(a)
       }
 
     def recoverWith[B >: A](pf: PartialFunction[Errors, Result[B]]): Result[B] =
@@ -51,7 +62,7 @@ object results {
   }
 
   implicit class ResultConversionA[A](val a: A) extends AnyVal {
-    def result: Result[A] = new Result(a)
+    def result: Result[A] = new Result(Success(a))
   }
 
   implicit class ResultConversionErr(val xs: Errors) extends AnyVal {

repl/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala

@@ -161,7 +161,7 @@ object ReadlineFilters {
         allAfterCursor.splitAt(
           nextNewlineIndex
         ) match {
-          case (Vector(), Vector('\n', allAfterNewline: _*)) =>
+          case (Vector(), Vector('\n', allAfterNewline@ _*)) =>
             // if there's only a newline after cursor on line, cut it
             append(Vector('\n'))
             (allBeforeCursor ++ allAfterNewline, c)

repl/test/dotty/tools/repl/CompilerTests.scala

@@ -5,52 +5,50 @@ import org.junit.Assert._
 import org.junit.Test
 
 import dotc.core.Contexts.Context
-import dotc.reporting.MessageRendering
+import dotc.ast.Trees._
 import dotc.ast.untpd
 
 import results._
 import ReplTest._
 
-class ReplCompilerTests extends ReplTest with MessageRendering {
+class ReplCompilerTests extends ReplTest {
 
-  @Test def compileSingle = withState {
-    compiler.compile("def foo: 1 = 1").fold(onErrors, _ => ())
+  @Test def compileSingle: Unit = fromInitialState { implicit state =>
+    compiler.compile("def foo: 1 = 1").stateOrFail
   }
 
-  @Test def compileTwo = withState {
-    val secondState =
-      for {
-        (_, s1) <- compiler.compile("def foo: 1 = 1")
-        (_, s2) <- fromState(s1) {
-          compiler.compile("def foo(i: Int): i.type = i")
-        }
-      } yield s2
 
-    secondState.fold(onErrors, { state =>
-      assert(state.objectIndex == 2,
-             s"Wrong object offset: expected 2 got ${state.objectIndex}")
-    })
-  }
+  @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 = withState {
-    val untpdTree = compiler.compile("def foo: 1 = 1").map((u,_) => u.untpdTree)
-
-    untpdTree.fold(
-      onErrors,
-      _ match {
-        case untpd.PackageDef(_, List(mod: untpd.ModuleDef)) =>
-          assert(mod.name.show == "rs$line$1", mod.name.show)
-        case tree => fail(s"Unexpected structure: $tree")
-      }
-    )
-  }
+  @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 = withState {
+  @Test def testVar = fromInitialState { implicit state =>
     compile("var x = 5")
-    assertEquals("var x: Int = 5\n", stripColor(storedOutput()))
+    assertEquals("var x: Int = 5\n", storedOutput())
   }
 
-  @Test def testRes = withState {
+  @Test def testRes = fromInitialState { implicit state =>
     compile {
       """|def foo = 1 + 1
          |val x = 5 + 5
@@ -65,32 +63,33 @@ class ReplCompilerTests extends ReplTest with MessageRendering {
                        "val res0: Int = 2",
                        "var y: Int = 5")
 
-    val actual = storedOutput()
-    expected === stripColor(actual).split("\n")
+    expected === storedOutput().split("\n")
   }
 
-  @Test def testImportMutable = withState {
-    fromState(compile("import scala.collection.mutable")) {
-      assert(implicitly[State].imports.nonEmpty, "Didn't add import to `State` after compilation")
+  @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",
-        stripColor(storedOutput())
+        storedOutput()
       )
     }
-  }
 
-  @Test def rebindVariable = withState {
-    fromState(compile("var x = 5")) {
+  @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,
-        stripColor(storedOutput())
+        storedOutput()
       )
     }
-  }
 }