Add worksheet/exec and worksheet/publishOutput

Duhemm · Duhemm · commit de5c28e313ba · 2018-10-09T10:38:05.000+02:00
Instead of relying on `textDocument/didSave` and `window/logMessage`
like we did in the past.
diff --git a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala
@@ -29,7 +29,7 @@ import Interactive.Include
 import config.Printers.interactiv
 
 import languageserver.config.ProjectConfig
-import languageserver.worksheet.Worksheet
+import languageserver.worksheet.{Worksheet, WorksheetClient, WorksheetService}
 
 import lsp4j.services._
 
@@ -42,7 +42,8 @@ import lsp4j.services._
  *  - This implementation is based on the LSP4J library: https://github.com/eclipse/lsp4j
  */
 class DottyLanguageServer extends LanguageServer
-    with LanguageClientAware with TextDocumentService with WorkspaceService { thisServer =>
+    with LanguageClientAware with TextDocumentService with WorkspaceService
+    with WorksheetService { thisServer =>
   import ast.tpd._
 
   import DottyLanguageServer._
@@ -54,7 +55,10 @@ class DottyLanguageServer extends LanguageServer
 
 
   private[this] var rootUri: String = _
-  private[this] var client: LanguageClient = _
+
+  private[this] var myClient: WorksheetClient = _
+  def client: WorksheetClient = myClient
+
   private[this] val worksheets: ConcurrentHashMap[URI, CompletableFuture[_]] = new ConcurrentHashMap()
 
   private[this] var myDrivers: mutable.Map[ProjectConfig, InteractiveDriver] = _
@@ -121,7 +125,7 @@ class DottyLanguageServer extends LanguageServer
   }
 
   override def connect(client: LanguageClient): Unit = {
-    this.client = client
+    myClient = client.asInstanceOf[WorksheetClient]
   }
 
   override def exit(): Unit = {
@@ -132,7 +136,7 @@ class DottyLanguageServer extends LanguageServer
     CompletableFuture.completedFuture(new Object)
   }
 
-  private[this] def computeAsync[R](fun: CancelChecker => R): CompletableFuture[R] =
+  def computeAsync[R](fun: CancelChecker => R): CompletableFuture[R] =
     CompletableFutures.computeAsync { cancelToken =>
       // We do not support any concurrent use of the compiler currently.
       thisServer.synchronized {
@@ -229,27 +233,7 @@ class DottyLanguageServer extends LanguageServer
     /*thisServer.synchronized*/ {}
 
   override def didSave(params: DidSaveTextDocumentParams): Unit = {
-    val uri = new URI(params.getTextDocument.getUri)
-    if (isWorksheet(uri)) {
-      if (uri.getScheme == "cancel") {
-        val fileURI = new URI("file", uri.getUserInfo, uri.getHost, uri.getPort, uri.getPath, uri.getQuery, uri.getFragment)
-        Option(worksheets.get(fileURI)).foreach(_.cancel(true))
-      } else thisServer.synchronized {
-        val sendMessage = (msg: String) => client.logMessage(new MessageParams(MessageType.Info, uri + msg))
-        worksheets.put(
-          uri,
-          computeAsync { cancelChecker =>
-            try {
-              val driver = driverFor(uri)
-              evaluateWorksheet(driver, uri, sendMessage, cancelChecker)(driver.currentCtx)
-            } finally {
-              worksheets.remove(uri)
-              sendMessage("FINISHED")
-            }
-          }
-        )
-      }
-    }
+    /*thisServer.synchronized*/ {}
   }
 
   // FIXME: share code with messages.NotAMember
@@ -447,25 +431,6 @@ class DottyLanguageServer extends LanguageServer
   override def resolveCodeLens(params: CodeLens) = null
   override def resolveCompletionItem(params: CompletionItem) = null
   override def signatureHelp(params: TextDocumentPositionParams) = null
-
-  /**
-   * Evaluate the worksheet at `uri`.
-   *
-   * @param driver        The driver for the project that contains the worksheet.
-   * @param uri           The URI of the worksheet.
-   * @param sendMessage   A mean of communicating the results of evaluation back.
-   * @param cancelChecker Token to check whether evaluation was cancelled
-   */
-  private def evaluateWorksheet(driver: InteractiveDriver,
-                                uri: URI,
-                                sendMessage: String => Unit,
-                                cancelChecker: CancelChecker)(
-      implicit ctx: Context): Unit = {
-    val trees = driver.openedTrees(uri)
-    trees.headOption.foreach { tree =>
-      Worksheet.evaluate(tree, sendMessage, cancelChecker)
-    }
-  }
 }
 
 object DottyLanguageServer {
diff --git a/language-server/src/dotty/tools/languageserver/Main.scala b/language-server/src/dotty/tools/languageserver/Main.scala
@@ -10,6 +10,7 @@ import java.nio.channels._
 import org.eclipse.lsp4j._
 import org.eclipse.lsp4j.services._
 import org.eclipse.lsp4j.launch._
+import org.eclipse.lsp4j.jsonrpc.Launcher
 
 /** Run the Dotty Language Server.
  *
@@ -65,9 +66,16 @@ object Main {
     val server = new DottyLanguageServer
 
     println("Starting server")
-    // For debugging JSON messages:
-    // val launcher = LSPLauncher.createServerLauncher(server, in, out, false, new java.io.PrintWriter(System.err, true))
-    val launcher = LSPLauncher.createServerLauncher(server, in, out)
+    val launcher =
+      new Launcher.Builder[worksheet.WorksheetClient]()
+        .setLocalService(server)
+        .setRemoteInterface(classOf[worksheet.WorksheetClient])
+        .setInput(in)
+        .setOutput(out)
+        // For debugging JSON messages:
+        // .traceMessages(new java.io.PrintWriter(System.err, true))
+        .create();
+
     val client = launcher.getRemoteProxy()
     server.connect(client)
     launcher.startListening()
diff --git a/language-server/src/dotty/tools/languageserver/worksheet/Worksheet.scala b/language-server/src/dotty/tools/languageserver/worksheet/Worksheet.scala
@@ -22,13 +22,13 @@ object Worksheet {
    * @param cancelChecker A token to check whether execution should be cancelled.
    */
   def evaluate(tree: SourceTree,
-               sendMessage: String => Unit,
+               sendMessage: (Int, String) => Unit,
                cancelChecker: CancelChecker)(
       implicit ctx: Context): Unit = synchronized {
 
     Evaluator.get(cancelChecker) match {
       case None =>
-        sendMessage(encode("Couldn't start JVM.", 1))
+        sendMessage(1, "Couldn't start JVM.")
       case Some(evaluator) =>
         tree.tree match {
           case td @ TypeDef(_, template: Template) =>
@@ -42,7 +42,7 @@ object Worksheet {
                 try {
                   cancelChecker.checkCanceled()
                   val (line, result) = execute(evaluator, statement, tree.source)
-                  if (result.nonEmpty) sendMessage(encode(result, line))
+                  if (result.nonEmpty) sendMessage(line, result)
                 } catch { case _: CancellationException => () }
 
               case _ =>
@@ -66,9 +66,6 @@ object Worksheet {
     (line, evaluator.eval(source).getOrElse(""))
   }
 
-  private def encode(message: String, line: Int): String =
-    line + ":" + message
-
   private def bounds(pos: Position): (Int, Int) = (pos.start, pos.end)
 
 }
diff --git a/language-server/src/dotty/tools/languageserver/worksheet/WorksheetClient.scala b/language-server/src/dotty/tools/languageserver/worksheet/WorksheetClient.scala
@@ -0,0 +1,15 @@
+package dotty.tools.languageserver.worksheet
+
+import org.eclipse.lsp4j.services.LanguageClient
+import org.eclipse.lsp4j.jsonrpc.services.JsonNotification
+
+/**
+ * A `LanguageClient` that supports the `worksheet/publishOutput` notification.
+ *
+ * @see dotty.tools.languageserver.worksheet.WorksheetExecOutput
+ */
+trait WorksheetClient extends LanguageClient {
+  @JsonNotification("worksheet/publishOutput")
+  def publishOutput(output: WorksheetExecOutput): Unit
+}
+
diff --git a/language-server/src/dotty/tools/languageserver/worksheet/WorksheetMessages.scala b/language-server/src/dotty/tools/languageserver/worksheet/WorksheetMessages.scala
@@ -0,0 +1,15 @@
+package dotty.tools.languageserver.worksheet
+
+import java.net.URI
+
+/** The parameter for the `worksheet/exec` request. */
+case class WorksheetExecParams(uri: URI)
+
+/** The response to a `worksheet/exec` request. */
+case class WorksheetExecResponse(success: Boolean)
+
+/**
+ * A notification that tells the client that a line of a worksheet
+ * produced the specified output.
+ */
+case class WorksheetExecOutput(uri: URI, line: Int, content: String)
diff --git a/language-server/src/dotty/tools/languageserver/worksheet/WorksheetService.scala b/language-server/src/dotty/tools/languageserver/worksheet/WorksheetService.scala
@@ -0,0 +1,57 @@
+package dotty.tools.languageserver.worksheet
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.interactive.InteractiveDriver
+import dotty.tools.languageserver.DottyLanguageServer
+
+import org.eclipse.lsp4j.jsonrpc._//{CancelChecker, CompletableFutures}
+import org.eclipse.lsp4j.jsonrpc.services._//{JsonSegment, JsonRequest}
+
+import java.net.URI
+import java.util.concurrent.{CompletableFuture, ConcurrentHashMap}
+
+@JsonSegment("worksheet")
+trait WorksheetService { thisServer: DottyLanguageServer =>
+
+  val worksheets: ConcurrentHashMap[URI, CompletableFuture[_]] = new ConcurrentHashMap()
+
+  @JsonRequest
+  def exec(params: WorksheetExecParams): CompletableFuture[WorksheetExecResponse] = thisServer.synchronized {
+    val uri = params.uri
+    val future =
+      computeAsync { cancelChecker =>
+        try {
+          val driver = driverFor(uri)
+          val sendMessage = (line: Int, msg: String) => client.publishOutput(WorksheetExecOutput(uri, line, msg))
+          evaluateWorksheet(driver, uri, sendMessage, cancelChecker)(driver.currentCtx)
+          WorksheetExecResponse(success = true)
+        } catch {
+          case _: Throwable =>
+            WorksheetExecResponse(success = false)
+        } finally {
+          worksheets.remove(uri)
+        }
+      }
+    worksheets.put(uri, future)
+    future
+  }
+
+  /**
+   * Evaluate the worksheet at `uri`.
+   *
+   * @param driver        The driver for the project that contains the worksheet.
+   * @param uri           The URI of the worksheet.
+   * @param sendMessage   A mean of communicating the results of evaluation back.
+   * @param cancelChecker Token to check whether evaluation was cancelled
+   */
+  private def evaluateWorksheet(driver: InteractiveDriver,
+                                uri: URI,
+                                sendMessage: (Int, String) => Unit,
+                                cancelChecker: CancelChecker)(
+      implicit ctx: Context): Unit = {
+    val trees = driver.openedTrees(uri)
+    trees.headOption.foreach { tree =>
+      Worksheet.evaluate(tree, sendMessage, cancelChecker)
+    }
+  }
+}
diff --git a/language-server/test/dotty/tools/languageserver/util/actions/WorksheetAction.scala b/language-server/test/dotty/tools/languageserver/util/actions/WorksheetAction.scala
@@ -1,31 +1,26 @@
 package dotty.tools.languageserver.util.actions
 
+import dotty.tools.languageserver.worksheet.{WorksheetExecOutput, WorksheetExecParams, WorksheetExecResponse}
 import dotty.tools.languageserver.util.embedded.CodeMarker
 
-import org.eclipse.lsp4j.{DidSaveTextDocumentParams, MessageParams, MessageType}
+import java.net.URI
+import java.util.concurrent.CompletableFuture
 
 abstract class WorksheetAction extends Action {
 
-  def triggerEvaluation(marker: CodeMarker): Exec[Unit] = {
-    val file = marker.toTextDocumentIdentifier
-    server.didSave(new DidSaveTextDocumentParams(file))
-  }
+  /** Get the URI of the worksheet that contains `marker`. */
+  def getUri(marker: CodeMarker): Exec[URI] = new URI(marker.toTextDocumentIdentifier.getUri)
 
-  def triggerCancellation(marker: CodeMarker): Exec[Unit] = {
-    val file = {
-      val file = marker.toTextDocumentIdentifier
-      file.setUri(file.getUri.replaceFirst("file:", "cancel:"))
-      file
-    }
-    server.didSave(new DidSaveTextDocumentParams(file))
+  /** Triggers the evaluation of the worksheet. */
+  def triggerEvaluation(marker: CodeMarker): Exec[CompletableFuture[WorksheetExecResponse]] = {
+    val uri = getUri(marker)
+    server.exec(WorksheetExecParams(uri))
   }
 
-  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
-    }
+  /** The output of the worksheet that contains `marker`. */
+  def worksheetOutput(marker: CodeMarker): Exec[List[WorksheetExecOutput]] = {
+    val uri = getUri(marker)
+    client.worksheetOutput.get.filter(_.uri == uri)
   }
+
 }
diff --git a/language-server/test/dotty/tools/languageserver/util/actions/WorksheetCancel.scala b/language-server/test/dotty/tools/languageserver/util/actions/WorksheetCancel.scala
@@ -3,26 +3,20 @@ package dotty.tools.languageserver.util.actions
 import dotty.tools.languageserver.util.PositionContext
 import dotty.tools.languageserver.util.embedded.CodeMarker
 
-import org.junit.Assert.{assertEquals, fail}
+import org.junit.Assert.assertTrue
 
-class WorksheetCancel(marker: CodeMarker, afterMs: Long) extends WorksheetAction {
+import java.util.concurrent.TimeUnit
 
-  private final val cancellationTimeoutMs = 10 * 1000
+class WorksheetCancel(marker: CodeMarker, afterMs: Long) extends WorksheetAction {
 
   override def execute(): Exec[Unit] = {
-    triggerEvaluation(marker)
+    val futureResult = triggerEvaluation(marker)
     Thread.sleep(afterMs)
-    triggerCancellation(marker)
+    val cancelled = futureResult.cancel(true)
 
-    val timeAtCancellation = System.currentTimeMillis()
-    while (!getLogs(marker).contains("FINISHED")) {
-      if (System.currentTimeMillis() - timeAtCancellation > cancellationTimeoutMs) {
-        fail(s"Couldn't cancel worksheet evaluation after ${cancellationTimeoutMs} ms.")
-      }
-      Thread.sleep(100)
-    }
+    assertTrue(cancelled)
 
-    client.log.clear()
+    client.worksheetOutput.clear()
   }
 
   override def show: PositionContext.PosCtx[String] =
diff --git a/language-server/test/dotty/tools/languageserver/util/actions/WorksheetEvaluate.scala b/language-server/test/dotty/tools/languageserver/util/actions/WorksheetEvaluate.scala
@@ -3,31 +3,26 @@ package dotty.tools.languageserver.util.actions
 import dotty.tools.languageserver.util.PositionContext
 import dotty.tools.languageserver.util.embedded.CodeMarker
 
+import java.util.concurrent.TimeUnit
+
 import org.junit.Assert.{assertEquals, assertTrue, fail}
 
 class WorksheetEvaluate(marker: CodeMarker, expected: Seq[String], strict: Boolean) extends WorksheetAction {
 
-  private final val evaluationTimeoutMs = 30 * 1000
-
   override def execute(): Exec[Unit] = {
-    triggerEvaluation(marker)
+    val result = triggerEvaluation(marker).get(30, TimeUnit.SECONDS)
+    assertTrue(result.success)
 
-    val timeAtEvaluation = System.currentTimeMillis()
-    while (!getLogs(marker).contains("FINISHED")) {
-      if (System.currentTimeMillis() - timeAtEvaluation > evaluationTimeoutMs) {
-        fail(s"Evaluation didn't finish after ${evaluationTimeoutMs} ms.")
-      }
-      Thread.sleep(100)
-    }
+    val logs = worksheetOutput(marker).map(out => s"${out.line}:${out.content}")
 
     if (strict) {
-      assertEquals(expected, getLogs(marker).init)
+      assertEquals(expected, logs)
     } else {
-      expected.zip(getLogs(marker).init).foreach {
+      expected.zip(logs).foreach {
         case (expected, message) => assertTrue(s"'$message' didn't start with '$expected'", message.startsWith(expected))
       }
     }
-    client.log.clear()
+    client.worksheetOutput.clear()
   }
 
   override def show: PositionContext.PosCtx[String] =
diff --git a/language-server/test/dotty/tools/languageserver/util/server/TestClient.scala b/language-server/test/dotty/tools/languageserver/util/server/TestClient.scala
diff --git a/vscode-dotty/src/extension.ts b/vscode-dotty/src/extension.ts
diff --git a/vscode-dotty/src/worksheet.ts b/vscode-dotty/src/worksheet.ts
