Flatten top level block in REPL

This makes multi-line editing more convenient

Author: allanrenucci

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

@@ -75,26 +75,36 @@ class ReplCompiler extends Compiler {
 
     implicit val ctx: Context = state.context
 
+    // If trees is of the form `{ def1; def2; def3 }` then `List(def1, def2, def3)`
+    val flattened = trees match {
+      case List(Block(stats, expr)) =>
+        if (expr eq EmptyTree) stats // happens when expr is not an expression
+        else stats :+ expr
+      case _ =>
+        trees
+    }
+
     var valIdx = state.valIndex
+    val defs = new mutable.ListBuffer[Tree]
 
-    val defs = trees.flatMap {
+    flattened.foreach {
       case expr @ Assign(id: Ident, _) =>
         // special case simple reassignment (e.g. x = 3)
         // in order to print the new value in the REPL
         val assignName = (id.name ++ str.REPL_ASSIGN_SUFFIX).toTermName
         val assign = ValDef(assignName, TypeTree(), id).withPos(expr.pos)
-        List(expr, assign)
+        defs += expr += assign
       case expr if expr.isTerm =>
         val resName = (str.REPL_RES_PREFIX + valIdx).toTermName
         valIdx += 1
         val vd = ValDef(resName, TypeTree(), expr).withPos(expr.pos)
-        vd :: Nil
+        defs += vd
       case other =>
-        other :: Nil
+        defs += other
     }
 
     Definitions(
-      defs,
+      defs.toList,
       state.copy(
         objectIndex = state.objectIndex + (if (defs.isEmpty) 0 else 1),
         valIndex = valIdx

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -7,6 +7,8 @@ import org.junit.{Ignore, Test}
 
 class ReplCompilerTests extends ReplTest {
 
+  private def lines() = storedOutput().split(EOL).toList
+
   @Test def compileSingle = fromInitialState { implicit state =>
     run("def foo: 1 = 1")
     assertEquals("def foo: Int(1)", storedOutput().trim)
@@ -53,7 +55,7 @@ class ReplCompilerTests extends ReplTest {
       "val res1: Int = 20"
     )
 
-    assertEquals(expected, storedOutput().split(EOL).toList)
+    assertEquals(expected, lines())
   }
 
   @Test def testImportMutable =
@@ -124,6 +126,32 @@ class ReplCompilerTests extends ReplTest {
     )
 
     run(source)
-    assertEquals(expected, storedOutput().split(EOL).toList)
+    assertEquals(expected, lines())
   }
+
+  @Test def topLevelBlock =
+    fromInitialState { implicit state =>
+      val source =
+        """{
+          |  def foo = 1
+          |  case class A(x: Int)
+          |  foo
+          |  def bar = 2
+          |}""".stripMargin
+
+      val expected = List(
+        "// defined case class A",
+        "def foo: Int",
+        "def bar: Int",
+        "val res0: Int = 1"
+      )
+
+      val ns = run(source)
+      assertEquals(expected, lines())
+      ns
+    }
+    .andThen { implicit state =>
+      run("val a = A(foo + bar)")
+      assertEquals("val a: A = A(3)", storedOutput().trim)
+    }
 }