Centralize dependencies on jline

Code that depends on jline is now in package `scala.tools.nsc.interpreter.jline`.

To make this possible, remove the `entries` functionality from `History`,
and add the `historicize` method. Also provide an overload for `asStrings`.

Clean up a little along the way in `JLineHistory.scala` and `JLineReader.scala`.

Next step: fall back to an embedded jline when the expected jline jar
is not on the classpath.

The gist of the refactor: https://gist.github.com/adriaanm/02e110d4da0a585480c1

Author: adriaanm

src/repl/scala/tools/nsc/interpreter/Delimited.scala

@@ -503,10 +503,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
       val errless = intp compileSources new BatchSourceFile("<pastie>", s"object pastel {\n$code\n}")
       if (errless) echo("The compiler reports no errors.")
     }
-    def historicize(text: String) = history match {
-      case jlh: JLineHistory => text.lines foreach jlh.add ; jlh.moveToEnd() ; true
-      case _ => false
-    }
+
     def edit(text: String): Result = editor match {
       case Some(ed) =>
         val tmp = File.makeTemp()
@@ -522,7 +519,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
                   val res = intp interpret edited
                   if (res == IR.Incomplete) diagnose(edited)
                   else {
-                    historicize(edited)
+                    history.historicize(edited)
                     Result(lineToRecord = Some(edited), keepRunning = true)
                   }
                 case None => echo("Can't read edited text. Did you delete it?")
@@ -533,7 +530,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
           tmp.delete()
         }
       case None =>
-        if (historicize(text)) echo("Placing text in recent history.")
+        if (history.historicize(text)) echo("Placing text in recent history.")
         else echo(f"No EDITOR defined and you can't change history, echoing your text:%n$text")
     }
 
@@ -565,10 +562,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
         }
       import scala.collection.JavaConverters._
       val index = (start - 1) max 0
-      val text = history match {
-        case jlh: JLineHistory => jlh.entries(index).asScala.take(len) map (_.value) mkString "\n"
-        case _ => history.asStrings.slice(index, index + len) mkString "\n"
-      }
+      val text = history.asStrings(index, index + len) mkString "\n"
       edit(text)
     } catch {
       case _: NumberFormatException => echo(s"Bad range '$what'")
@@ -866,16 +860,18 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
    *  with SimpleReader.
    */
   def chooseReader(settings: Settings): InteractiveReader = {
-    if (settings.Xnojline || Properties.isEmacsShell)
-      SimpleReader()
-    else try new JLineReader(
-      if (settings.noCompletion) NoCompletion
-      else new JLineCompletion(intp)
-    )
-    catch {
-      case ex @ (_: Exception | _: NoClassDefFoundError) =>
-        echo(f"Failed to created JLineReader: ${ex}%nFalling back to SimpleReader.")
-        SimpleReader()
+    def mkJLineReader(completer: () => Completion): InteractiveReader =
+      try new jline.JLineReader(completer)
+      catch {
+        case ex@(_: Exception | _: NoClassDefFoundError) =>
+          Console.println(f"Failed to created JLineReader: ${ex}%nFalling back to SimpleReader.")
+          SimpleReader()
+      }
+
+    if (settings.Xnojline || Properties.isEmacsShell) SimpleReader()
+    else {
+      if (settings.noCompletion) mkJLineReader(() => NoCompletion)
+      else mkJLineReader(() => new JLineCompletion(intp))
     }
   }
 
@@ -896,10 +892,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
       asyncMessage(power.banner)
     }
     // SI-7418 Now, and only now, can we enable TAB completion.
-    in match {
-      case x: JLineReader => x.consoleReader.postInit
-      case _              =>
-    }
+    in.postInit()
   }
 
   // start an interpreter with the given settings

src/repl/scala/tools/nsc/interpreter/ILoop.scala

@@ -13,6 +13,8 @@ import Properties.isMac
 
 /** Reads lines from an input stream */
 trait InteractiveReader {
+  def postInit(): Unit = {}
+
   val interactive: Boolean
 
   def reset(): Unit

src/repl/scala/tools/nsc/interpreter/InteractiveReader.scala

@@ -12,6 +12,7 @@ import scala.reflect.internal.util.StringOps.longestCommonPrefix
 
 // REPL completor - queries supplied interpreter for valid
 // completions based on current contents of buffer.
+// TODO: change class name to reflect it's not specific to jline (nor does it depend on it)
 class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput {
   val global: intp.global.type = intp.global
   import global._

src/repl/scala/tools/nsc/interpreter/JLineCompletion.scala

@@ -8,6 +8,25 @@ package interpreter
 
 import util.returning
 
+trait Delimited {
+  self: Parsed =>
+
+  def delimited: Char => Boolean
+  def escapeChars: List[Char] = List('\\')
+
+  /** Break String into args based on delimiting function.
+   */
+  protected def toArgs(s: String): List[String] =
+    if (s == "") Nil
+    else (s indexWhere isDelimiterChar) match {
+      case -1   => List(s)
+      case idx  => (s take idx) :: toArgs(s drop (idx + 1))
+    }
+
+  def isDelimiterChar(ch: Char) = delimited(ch)
+  def isEscapeChar(ch: Char): Boolean = escapeChars contains ch
+}
+
 /** One instance of a command buffer.
  */
 class Parsed private (

src/repl/scala/tools/nsc/interpreter/JLineReader.scala

@@ -3,60 +3,7 @@
  * @author Paul Phillips
  */
 
-package scala.tools.nsc
-package interpreter
-
-import jline.console.{ ConsoleReader, CursorBuffer }
-
-trait ConsoleReaderHelper { _: ConsoleReader with Tabulator =>
-  def isAcross: Boolean
-
-  def terminal    = getTerminal()
-  def width       = terminal.getWidth()
-  def height      = terminal.getHeight()
-
-  def readOneKey(prompt: String): Int
-  def eraseLine(): Unit
-
-  val marginSize = 3
-
-  private def morePrompt = "--More--"
-  private def emulateMore(): Int = {
-    val key = readOneKey(morePrompt)
-    try key match {
-      case '\r' | '\n'  => 1
-      case 'q'          => -1
-      case _            => height - 1
-    }
-    finally {
-      eraseLine()
-      // TODO: still not quite managing to erase --More-- and get
-      // back to a scala prompt without another keypress.
-      if (key == 'q') {
-        putString(getPrompt())
-        redrawLine()
-        flush()
-      }
-    }
-  }
-
-  override def printColumns(items: JCollection[_ <: CharSequence]): Unit =
-    printColumns_(items: List[String])
-
-  private def printColumns_(items: List[String]): Unit = if (items exists (_ != "")) {
-    val grouped = tabulate(items)
-    var linesLeft  = if (isPaginationEnabled()) height - 1 else Int.MaxValue
-    grouped foreach { xs =>
-      println(xs.mkString)
-      linesLeft -= 1
-      if (linesLeft <= 0) {
-        linesLeft = emulateMore()
-        if (linesLeft < 0)
-          return
-      }
-    }
-  }
-}
+package scala.tools.nsc.interpreter
 
 trait Tabulator {
   def isAcross: Boolean
@@ -72,7 +19,7 @@ trait Tabulator {
   )
   protected def columnize(ss: Seq[String]): Seq[Seq[String]] = ss map (s => Seq(s))
   protected def printMultiLineColumns(items: Seq[String]): Seq[Seq[String]] = {
-    import SimpleMath._
+    import scala.tools.nsc.interpreter.SimpleMath._
     val longest     = (items map (_.length)).max
     val columnWidth = longest + marginSize
     val maxcols = (
@@ -101,7 +48,7 @@ trait Tabulator {
 /** Adjust the column width and number of columns to minimize the row count. */
 trait VariColumnTabulator extends Tabulator {
   override protected def printMultiLineColumns(items: Seq[String]): Seq[Seq[String]] = {
-    import SimpleMath._
+    import scala.tools.nsc.interpreter.SimpleMath._
     val longest  = (items map (_.length)).max
     val shortest = (items map (_.length)).min
     val fattest  = longest + marginSize