Remove Worksheet dependency on JLine

The worksheet used to spawn a REPL with JLine just to be able to read
from an InputStream.

This is alternative solution that simply uses java.util.Scanner to read
from an InputStream. For that, we need to agree on a delimiter. We
choose a character within the private user area to not conflict with
the output produced by the REPL.

Author: allanrenucci

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/Evaluator.scala

@@ -2,7 +2,8 @@ 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 org.eclipse.lsp4j.jsonrpc.CancelChecker
 
@@ -57,7 +58,7 @@ private class Evaluator private (javaExec: String,
     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,15 +68,12 @@ 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()
+  private val processOutput = new InputStreamConsumer(process.getInputStream())
 
   // The thread that monitors cancellation
   private val cancellationThread = new CancellationThread(cancelChecker, this)
   cancellationThread.start()
 
-  // Wait for the REPL to be ready
-  processOutput.next()
 
   /** Is the process that runs the REPL still alive? */
   def isAlive(): Boolean = process.isAlive()
@@ -86,10 +84,13 @@ private class Evaluator private (javaExec: String,
    * @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 => "" }
   }
 
   /**
@@ -102,7 +103,6 @@ private class Evaluator private (javaExec: String,
 
   /** Terminate this JVM. */
   def exit(): Unit = {
-    processOutput.interrupt()
     process.destroyForcibly()
     Evaluator.previousEvaluator = None
     cancellationThread.interrupt()

language-server/src/dotty/tools/languageserver/worksheet/InputStreamConsumer.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/ReplProcess.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/ReplReader.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/Worksheet.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)
   }
 }