Add tests for worksheets

Author: Duhemm

language-server/src/dotty/tools/languageserver/Worksheet.scala

@@ -1,10 +1,13 @@
 package dotty.tools.languageserver
 
-import dotty.tools.dotc.ast.tpd.{Template, Tree, TypeDef}
+import dotty.tools.dotc.ast.tpd.{DefTree, Template, Tree, TypeDef}
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.interactive.SourceTree
+import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.util.SourceFile
 
+import dotty.tools.dotc.core.Flags.Synthetic
+
 import dotty.tools.repl.{ReplDriver, State}
 
 import java.io.{ByteArrayOutputStream, PrintStream}
@@ -22,14 +25,21 @@ object Worksheet {
       case td @ TypeDef(_, template: Template) =>
         val replOut = new ByteArrayOutputStream
         val repl = new ReplDriver(replOptions, out = new PrintStream(replOut))
+        val executed = collection.mutable.Set.empty[(Int, Int)]
 
         template.body.foldLeft(repl.initialState) {
-          case (state, statement) =>
+          case (state, statement: DefTree) if statement.symbol.is(Synthetic) =>
+            state
+
+          case (state, statement) if executed.add(bounds(statement.pos)) =>
             val (line, newState) = execute(repl, state, statement, tree.source)
             val result = new String(replOut.toByteArray())
-            sendMessage(encode(result, line))
+            if (result.trim.nonEmpty) sendMessage(encode(result, line))
             replOut.reset()
             newState
+
+          case (state, statement) =>
+            state
         }
     }
   }
@@ -54,4 +64,6 @@ object Worksheet {
 
   private def encode(message: String, line: Int): String =
     line + ":" + message
+
+  private def bounds(pos: Position): (Int, Int) = (pos.start, pos.end)
 }

language-server/test/dotty/tools/languageserver/WorksheetTest.scala

@@ -0,0 +1,85 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class WorksheetTest {
+
+  @Test def evaluateExpression: Unit = {
+    ws"${m1}2 + 2".withSource
+      .evaluate(m1, "1:val res0: Int = 4")
+  }
+
+  @Test def evaluateSimpleVal: Unit = {
+    ws"${m1}val foo = 123".withSource
+      .evaluate(m1, "1:val foo: Int = 123")
+  }
+
+  @Test def usePreviousDefinition: Unit = {
+    ws"""${m1}val foo = 123
+         val bar = foo + 1""".withSource
+      .evaluate(m1, "1:val foo: Int = 123",
+                    "2:val bar: Int = 124")
+  }
+
+  @Test def defineObject: Unit = {
+    ws"""${m1}def foo(x: Int) = x + 1
+         foo(1)""".withSource
+      .evaluate(m1, "1:def foo(x: Int): Int",
+                    "2:val res0: Int = 2")
+  }
+
+  @Test def defineCaseClass: Unit = {
+    ws"""${m1} case class Foo(x: Int)
+         Foo(1)""".withSource
+      .evaluate(m1, "1:// defined case class Foo",
+                    "2:val res0: Foo = Foo(1)")
+  }
+
+  @Test def defineClass: Unit = {
+    ws"""${m1}class Foo(x: Int) {
+           override def toString: String = "Foo"
+         }
+         new Foo(1)""".withSource
+      .evaluate(m1, "3:// defined class Foo",
+                    "4:val res0: Foo = Foo")
+  }
+
+  @Test def defineAnonymousClass0: Unit = {
+    ws"""${m1}new {
+          override def toString: String = "Foo"
+         }""".withSource
+      .evaluate(m1, "3:val res0: Object = Foo")
+  }
+
+  @Test def defineAnonymousClass1: Unit = {
+    ws"""${m1}class Foo
+         trait Bar
+         new Foo with Bar {
+           override def toString: String = "Foo"
+         }""".withSource
+      .evaluate(m1, "1:// defined class Foo",
+                    "2:// defined trait Bar",
+                    "5:val res0: Foo & Bar = Foo")
+  }
+
+  @Test def produceMultilineOutput: Unit = {
+    ws"""${m1}1 to 3 foreach println""".withSource
+      .evaluate(m1, "1:1\n2\n3")
+  }
+
+  @Test def patternMatching0: Unit = {
+    ws"""${m1}1 + 2 match {
+          case x if x % 2 == 0 => "even"
+          case _ => "odd"
+        }""".withSource
+      .evaluate(m1, "4:val res0: String = odd")
+  }
+
+  @Test def patternMatching1: Unit = {
+    ws"""${m1}val (foo, bar) = (1, 2)""".withSource
+      .evaluate(m1, "1:val foo: Int = 1\nval bar: Int = 2")
+  }
+
+}

language-server/test/dotty/tools/languageserver/util/Code.scala

@@ -35,7 +35,22 @@ object Code {
      * and `m3` and `m4` enclose the identifier `Hello`. These positions can then be used to ask to
      * perform actions such as finding all references, etc.
      */
-    def code(args: Embedded*): SourceWithPositions = {
+    def code(args: Embedded*): ScalaSourceWithPositions = {
+      val (text, positions) = textAndPositions(args: _*)
+      ScalaSourceWithPositions(text, positions)
+    }
+
+    /**
+     * An interpolator similar to `code`, but used for defining a worksheet.
+     *
+     * @see code
+     */
+    def ws(args: Embedded*): WorksheetWithPositions = {
+      val (text, positions) = textAndPositions(args: _*)
+      WorksheetWithPositions(text, positions)
+    }
+
+    private def textAndPositions(args: Embedded*): (String, List[(CodeMarker, Int, Int)]) = {
       val pi = sc.parts.iterator
       val ai = args.iterator
 
@@ -70,22 +85,40 @@ object Code {
       if (pi.hasNext)
         stringBuilder.append(pi.next())
 
-      SourceWithPositions(stringBuilder.result(), positions.result())
+      (stringBuilder.result(), positions.result())
     }
   }
 
   /** A new `CodeTester` working with `sources` in the workspace. */
   def withSources(sources: SourceWithPositions*): CodeTester = new CodeTester(sources.toList, Nil)
 
+  sealed trait SourceWithPositions {
+
+     /** The code contained within the virtual source file. */
+    def text: String
+
+    /** The positions of the markers that have been set. */
+    def positions: List[(CodeMarker, Int, Int)]
+
+    /** A new `CodeTester` with only this source in the workspace. */
+    def withSource: CodeTester = new CodeTester(this :: Nil, Nil)
+
+  }
+
   /**
-   * A virtual source file where several markers have been set.
+   * A virtual Scala source file where several markers have been set.
    *
    * @param text      The code contained within the virtual source file.
    * @param positions The positions of the markers that have been set.
    */
-  case class SourceWithPositions(text: String, positions: List[(CodeMarker, Int, Int)]) {
-    /** A new `CodeTester` with only this source in the workspace. */
-    def withSource: CodeTester = new CodeTester(this :: Nil, Nil)
-  }
+  case class ScalaSourceWithPositions(text: String, positions: List[(CodeMarker, Int, Int)]) extends SourceWithPositions
+
+  /**
+   * A virtual worksheet where several markers have been set.
+   *
+   * @param text      The code contained within the virtual source file.
+   * @param positions The positions of the markers that have been set.
+   */
+  case class WorksheetWithPositions(text: String, positions: List[(CodeMarker, Int, Int)]) extends SourceWithPositions
 
 }

language-server/test/dotty/tools/languageserver/util/CodeTester.scala

@@ -1,6 +1,6 @@
 package dotty.tools.languageserver.util
 
-import dotty.tools.languageserver.util.Code.SourceWithPositions
+import dotty.tools.languageserver.util.Code._
 import dotty.tools.languageserver.util.actions._
 import dotty.tools.languageserver.util.embedded.CodeMarker
 import dotty.tools.languageserver.util.server.{TestFile, TestServer}
@@ -16,8 +16,9 @@ class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
 
   private val testServer = new TestServer(TestFile.testDir)
 
-  private val files = sources.zipWithIndex.map { case (code, i) =>
-    testServer.openCode(code.text, s"Source$i.scala")
+  private val files = sources.zipWithIndex.map {
+    case (ScalaSourceWithPositions(text, _), i) => testServer.openCode(text, s"Source$i.scala")
+    case (WorksheetWithPositions(text, _), i) => testServer.openCode(text, s"Worksheet$i.sc")
   }
   private val positions: PositionContext = getPositions(files)
 
@@ -116,9 +117,12 @@ class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
   def symbol(query: String, symbols: SymInfo*): this.type =
     doAction(new CodeSymbol(query, symbols))
 
+  def evaluate(marker: CodeMarker, expected: String*): this.type =
+    doAction(new WorksheetEvaluate(marker, expected))
+
   private def doAction(action: Action): this.type = {
     try {
-      action.execute()(testServer, positions)
+      action.execute()(testServer, testServer.client, positions)
     } catch {
       case ex: AssertionError =>
         val sourcesStr = sources.zip(files).map{ case (source, file) => "// " + file.file + "\n" + source.text}.mkString("\n")

language-server/test/dotty/tools/languageserver/util/actions/Action.scala

@@ -2,7 +2,7 @@ package dotty.tools.languageserver.util.actions
 
 import dotty.tools.languageserver.DottyLanguageServer
 import dotty.tools.languageserver.util.PositionContext
-import dotty.tools.languageserver.util.server.TestServer
+import dotty.tools.languageserver.util.server.{TestClient, TestServer}
 
 import PositionContext._
 
@@ -11,7 +11,7 @@ import PositionContext._
  * definition, etc.)
  */
 trait Action {
-  type Exec[T] = implicit (TestServer, PositionContext) => T
+  type Exec[T] = implicit (TestServer, TestClient, PositionContext) => T
 
   /** Execute the action. */
   def execute(): Exec[Unit]
@@ -22,4 +22,7 @@ trait Action {
   /** The server that this action targets. */
   def server: Exec[DottyLanguageServer] = implicitly[TestServer].server
 
+  /** The client that executes this action. */
+  def client: Exec[TestClient] = implicitly[TestClient]
+
 }

language-server/test/dotty/tools/languageserver/util/actions/WorksheetEvaluate.scala

@@ -0,0 +1,32 @@
+package dotty.tools.languageserver.util.actions
+
+import dotty.tools.languageserver.util.{PositionContext}
+import dotty.tools.languageserver.util.embedded.CodeMarker
+
+import org.eclipse.lsp4j.{DidSaveTextDocumentParams, MessageParams, MessageType}
+
+import org.junit.Assert.assertEquals
+
+class WorksheetEvaluate(marker: CodeMarker, expected: Seq[String]) extends Action {
+  override def execute(): Exec[Unit] = {
+    val file = marker.toTextDocumentIdentifier
+    server.didSave(new DidSaveTextDocumentParams(file))
+
+    while (!getLogs(marker).contains("FINISHED")) Thread.sleep(100)
+
+    assertEquals(expected, getLogs(marker).init)
+    client.log.clear()
+  }
+
+  override def show: PositionContext.PosCtx[String] =
+    s"WorksheetEvaluate(${marker.file}, ${expected})"
+
+  private def getLogs(marker: CodeMarker): Exec[List[String]] = {
+    def matches(params: MessageParams): Boolean =
+      params.getType == MessageType.Info && params.getMessage.startsWith(marker.file.uri)
+    client.log.get.collect {
+      case params: MessageParams if matches(params) =>
+        params.getMessage.substring(marker.file.uri.length).trim
+    }
+  }
+}

language-server/test/dotty/tools/languageserver/util/server/TestClient.scala

@@ -5,31 +5,42 @@ import java.util.concurrent.CompletableFuture
 import org.eclipse.lsp4j._
 import org.eclipse.lsp4j.services._
 
+import scala.collection.mutable.Buffer
+
 class TestClient extends LanguageClient {
 
-  private val log = new StringBuilder
+  class Log[T] {
+    private[this] val log = Buffer.empty[T]
+
+    def +=(elem: T): this.type = { log += elem; this }
+    def get: List[T] = log.toList
+    def clear(): Unit = log.clear()
+  }
+
+  val log = new Log[MessageParams]
+  val diagnostics = new Log[PublishDiagnosticsParams]
+  val telemetry = new Log[Any]
 
-  def getLog: String = log.result()
 
   override def logMessage(message: MessageParams) = {
-    log.append(message.toString)
+    log += message
   }
 
   override def showMessage(messageParams: MessageParams) = {
-    log.append(messageParams.toString)
+    log += messageParams
   }
 
   override def telemetryEvent(obj: scala.Any) = {
-    log.append(obj.toString)
+    telemetry += obj
   }
 
   override def showMessageRequest(requestParams: ShowMessageRequestParams) = {
-    log.append(requestParams.toString)
+    log += requestParams
     new CompletableFuture[MessageActionItem]
   }
 
-  override def publishDiagnostics(diagnostics: PublishDiagnosticsParams) = {
-    log.append(diagnostics.toString)
+  override def publishDiagnostics(diagnosticsParams: PublishDiagnosticsParams) = {
+    diagnostics += diagnosticsParams
   }
 
 }

language-server/test/dotty/tools/languageserver/util/server/TestServer.scala

@@ -11,6 +11,8 @@ import org.eclipse.lsp4j.{ DidOpenTextDocumentParams, InitializeParams, Initiali
 class TestServer(testFolder: Path) {
 
   val server = new DottyLanguageServer
+  var client: TestClient = _
+
   init()
 
   private[this] def init(): InitializeResult = {
@@ -36,7 +38,7 @@ class TestServer(testFolder: Path) {
       close()
     }
 
-    val client = new TestClient
+    client = new TestClient
     server.connect(client)
 
     val initParams = new InitializeParams()