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-resources/repl/errmsgs

@@ -53,10 +53,6 @@ scala> val x: List[Int] = "foo" :: List(1)
   |                    ^^^^^
   |                    Found:    String("foo")
   |                    Required: Int
-scala> { def f: Int = g; val x: Int = 1; def g: Int = 5; }
-1 | { def f: Int = g; val x: Int = 1; def g: Int = 5; }
-  |                ^
-  |               g is a forward reference extending over the definition of x
 scala> while (((  foo ))) {}
 1 | while (((  foo ))) {}
   |            ^^^

compiler/test-resources/repl/top-level-block

@@ -0,0 +1,22 @@
+scala> { case class A(); def foo = 1; 2 }
+// defined case class A
+def foo: Int
+val res0: Int = 2
+
+scala> foo
+val res1: Int = 1
+
+scala> A()
+val res2: A = A()
+
+scala> { def f: Int = g; def g: Int = 5 }
+def g: Int
+def f: Int
+
+scala> f + g
+val res3: Int = 10
+
+scala> { val x = 3; 4; val y = 5 }
+val x: Int = 3
+val res4: Int = 4
+val y: Int = 5

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,6 @@ class ReplCompilerTests extends ReplTest {
     )
 
     run(source)
-    assertEquals(expected, storedOutput().split(EOL).toList)
+    assertEquals(expected, lines())
   }
 }