Merge pull request #5320 from dotty-staging/worksheet

Remove Worksheet dependency on JLine

Author: Duhemm

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

@@ -13,13 +13,13 @@ import org.jline.reader.impl.history.DefaultHistory
 import org.jline.terminal.TerminalBuilder
 import org.jline.utils.AttributedString
 
-final class JLineTerminal(needsTerminal: Boolean) extends java.io.Closeable {
+final class JLineTerminal extends java.io.Closeable {
   // import java.util.logging.{Logger, Level}
   // Logger.getLogger("org.jline").setLevel(Level.FINEST)
 
   private val terminal =
     TerminalBuilder.builder()
-    .dumb(!needsTerminal) // fail early if we need a terminal and can't create one
+    .dumb(false) // fail early if not able to create a terminal
     .build()
   private val history = new DefaultHistory
 

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

@@ -3,10 +3,5 @@ package dotty.tools.repl
 /** Main entry point to the REPL */
 object Main {
   def main(args: Array[String]): Unit =
-    new ReplDriver(args).runUntilQuit(needsTerminal = true)
-}
-
-object WorksheetMain {
-  def main(args: Array[String]): Unit =
-    new ReplDriver(args).runUntilQuit(needsTerminal = false)
+    new ReplDriver(args).runUntilQuit()
 }

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

@@ -101,8 +101,8 @@ class ReplDriver(settings: Array[String],
    *  observable outside of the CLI, for this reason, most helper methods are
    *  `protected final` to facilitate testing.
    */
-  final def runUntilQuit(needsTerminal: Boolean, initialState: State = initialState): State = {
-    val terminal = new JLineTerminal(needsTerminal)
+  final def runUntilQuit(initialState: State = initialState): State = {
+    val terminal = new JLineTerminal
 
     /** Blockingly read a line, getting back a parse result */
     def readLine(state: State): ParseResult = {

language-server/src/dotty/tools/languageserver/worksheet/CancellationThread.scala

@@ -2,7 +2,10 @@ package dotty.tools.languageserver.worksheet
 
 import dotty.tools.dotc.core.Contexts.Context
 
-import java.io.{File, PrintStream}
+import java.io.{File, PrintStream, IOException}
+import java.lang.ProcessBuilder.Redirect
+import java.util.concurrent.CancellationException
+import java.util.{Timer, TimerTask}
 
 import org.eclipse.lsp4j.jsonrpc.CancelChecker
 
@@ -31,7 +34,7 @@ private object Evaluator {
   def get(cancelChecker: CancelChecker)(implicit ctx: Context): Option[Evaluator] = synchronized {
     val classpath = ctx.settings.classpath.value
     previousEvaluator match {
-      case Some(cp, evaluator) if evaluator.isAlive() && cp == classpath =>
+      case Some(cp, evaluator) if evaluator.isAlive && cp == classpath =>
         evaluator.reset(cancelChecker)
         Some(evaluator)
       case _ =>
@@ -52,12 +55,12 @@ private object Evaluator {
  */
 private class Evaluator private (javaExec: String,
                                  userClasspath: String,
-                                 cancelChecker: CancelChecker) {
+                                 private var cancelChecker: CancelChecker) {
   private val process =
     new ProcessBuilder(
       javaExec,
       "-classpath", scala.util.Properties.javaClassPath,
-      dotty.tools.repl.WorksheetMain.getClass.getName.stripSuffix("$"),
+      ReplProcess.getClass.getName.stripSuffix("$"),
       "-classpath", userClasspath,
       "-color:never")
        .redirectErrorStream(true)
@@ -67,46 +70,54 @@ private class Evaluator private (javaExec: String,
   private val processInput = new PrintStream(process.getOutputStream())
 
   // Messages coming out of the REPL
-  private val processOutput = new ReplReader(process.getInputStream())
-  processOutput.start()
-
-  // The thread that monitors cancellation
-  private val cancellationThread = new CancellationThread(cancelChecker, this)
-  cancellationThread.start()
+  private val processOutput = new InputStreamConsumer(process.getInputStream())
+
+  // A timer that monitors cancellation
+  private val cancellationTimer = new Timer()
+  locally {
+    val task = new TimerTask {
+      def run(): Unit =
+        if (!isAlive)
+          cancellationTimer.cancel()
+        else
+          try cancelChecker.checkCanceled()
+          catch { case _: CancellationException => exit() }
+    }
+    val checkCancelledDelayMs = 50L
+    cancellationTimer.schedule(task, checkCancelledDelayMs, checkCancelledDelayMs)
+  }
 
-  // Wait for the REPL to be ready
-  processOutput.next()
 
   /** Is the process that runs the REPL still alive? */
-  def isAlive(): Boolean = process.isAlive()
+  def isAlive: Boolean = process.isAlive
 
   /**
    * Submit `command` to the REPL, wait for the result.
    *
    * @param command The command to evaluate.
    * @return The result from the REPL.
    */
-  def eval(command: String): Option[String] = {
-    processInput.println(command)
+  def eval(command: String): String = {
+    processInput.print(command)
+    processInput.print(InputStreamConsumer.delimiter)
     processInput.flush()
-    processOutput.next().map(_.trim)
+
+    try processOutput.next().trim
+    catch { case _: IOException => "" }
   }
 
   /**
    * Reset the REPL to its initial state, update the cancel checker.
    */
   def reset(cancelChecker: CancelChecker): Unit = {
-    cancellationThread.setCancelChecker(cancelChecker)
+    this.cancelChecker = cancelChecker
     eval(":reset")
   }
 
   /** Terminate this JVM. */
   def exit(): Unit = {
-    processOutput.interrupt()
     process.destroyForcibly()
     Evaluator.previousEvaluator = None
-    cancellationThread.interrupt()
+    cancellationTimer.cancel()
   }
-
 }
-

language-server/src/dotty/tools/languageserver/worksheet/Evaluator.scala

@@ -0,0 +1,25 @@
+package dotty.tools.languageserver.worksheet
+
+import java.io.{InputStream, IOException}
+import java.util.Scanner
+
+class InputStreamConsumer(in: InputStream) {
+  private[this] val scanner =
+    new Scanner(in).useDelimiter(InputStreamConsumer.delimiter)
+
+  /** Finds and returns the next complete token from this input stream.
+   *
+   *  A complete token is preceded and followed by input that matches the delimiter pattern.
+   *  This method may block while waiting for input
+   */
+  def next(): String =
+    try scanner.next()
+    catch {
+      case _: NoSuchElementException =>
+        throw new IOException("InputStream closed")
+    }
+}
+
+object InputStreamConsumer {
+  def delimiter = "\uE000" // withing private use area
+}

language-server/src/dotty/tools/languageserver/worksheet/InputStreamConsumer.scala

@@ -0,0 +1,17 @@
+package dotty.tools.languageserver.worksheet
+
+import dotty.tools.repl.ReplDriver
+
+object ReplProcess {
+  def main(args: Array[String]): Unit = {
+    val driver = new ReplDriver(args)
+    val in = new InputStreamConsumer(System.in)
+    var state = driver.initialState
+
+    while (true) {
+      val code = in.next() // blocking
+      state = driver.run(code)(state)
+      print(InputStreamConsumer.delimiter) // needed to mark the end of REPL output
+    }
+  }
+}

language-server/src/dotty/tools/languageserver/worksheet/ReplProcess.scala

@@ -49,7 +49,7 @@ object Worksheet {
           }
           queries.foreach { (line, code) =>
             cancelChecker.checkCanceled()
-            val res = evaluator.eval(code).getOrElse("")
+            val res = evaluator.eval(code)
             cancelChecker.checkCanceled()
             if (res.nonEmpty)
               sendMessage(line, res)

language-server/src/dotty/tools/languageserver/worksheet/ReplReader.scala

@@ -41,7 +41,7 @@ class ConsoleInterface {
 
     val s1 = driver.run(initialCommands)(s0)
     // TODO handle failure during initialisation
-    val s2 = driver.runUntilQuit(needsTerminal = true, s1)
+    val s2 = driver.runUntilQuit(s1)
     driver.run(cleanupCommands)(s2)
   }
 }