Upgrade syntax of CommandLineParser and test

Author: som-snytt

compiler/src/dotty/tools/dotc/config/CommandLineParser.scala

@@ -1,101 +1,96 @@
-package dotty.tools.dotc
-package config
+package dotty.tools.dotc.config
 
 import scala.annotation.tailrec
+import scala.collection.mutable.ArrayBuffer
+import java.lang.Character.isWhitespace
 
 /** A simple enough command line parser.
  */
-object CommandLineParser {
-  private final val DQ = '"'
-  private final val SQ = '\''
+object CommandLineParser:
+  inline private val DQ  = '"'
+  inline private val SQ  = '\''
+  inline private val EOF = -1
 
   /** Split the line into tokens separated by whitespace or quotes.
    *
-   *  @return either an error message or reverse list of tokens
+   *  Invoke `errorFn` with message on bad quote.
    */
-  private def tokens(in: String) = {
-    import Character.isWhitespace
-    import java.lang.{StringBuilder => Builder}
-    import collection.mutable.ArrayBuffer
+  def tokenize(line: String, errorFn: String => Unit): List[String] =
 
     var accum: List[String] = Nil
-    var pos = 0
+
+    var pos   = 0
     var start = 0
-    val qpos = new ArrayBuffer[Int](16)    // positions of paired quotes
+    val qpos  = new ArrayBuffer[Int](16)    // positions of paired quotes
 
-    def cur: Int  = if (done) -1 else in.charAt(pos)
-    def bump() = pos += 1
-    def done   = pos >= in.length
+    inline def cur    = if done then EOF else line.charAt(pos): Int
+    inline def bump() = pos += 1
+    inline def done   = pos >= line.length
 
-    def skipToQuote(q: Int) = {
+    def skipToQuote(q: Int): Boolean =
       var escaped = false
-      def terminal = in.charAt(pos) match {
+      def terminal = cur match
         case _ if escaped => escaped = false ; false
         case '\\'         => escaped = true ; false
-        case `q`          => true
+        case `q` | EOF    => true
         case _            => false
-      }
-      while (!done && !terminal) pos += 1
+      while !terminal do bump()
       !done
-    }
-    @tailrec
-    def skipToDelim(): Boolean =
-      cur match {
-        case q @ (DQ | SQ)        => { qpos += pos; bump(); skipToQuote(q) } && { qpos += pos; bump(); skipToDelim() }
+
+    @tailrec def skipToDelim(): Boolean =
+      inline def quote() = { qpos += pos ; bump() }
+      cur match
+        case q @ (DQ | SQ)        => { quote() ; skipToQuote(q) } && { quote() ; skipToDelim() }
         case -1                   => true
         case c if isWhitespace(c) => true
         case _                    => bump(); skipToDelim()
-      }
-    def skipWhitespace() = while (isWhitespace(cur)) pos += 1
-    def copyText() = {
-      val buf = new Builder
+
+    def copyText(): String =
+      val buf = new java.lang.StringBuilder
       var p = start
       var i = 0
-      while (p < pos) {
-        if (i >= qpos.size) {
-          buf.append(in, p, pos)
+      while p < pos do
+        if i >= qpos.size then
+          buf.append(line, p, pos)
           p = pos
-        } else if (p == qpos(i)) {
-          buf.append(in, qpos(i)+1, qpos(i+1))
+        else if p == qpos(i) then
+          buf.append(line, qpos(i)+1, qpos(i+1))
           p = qpos(i+1)+1
           i += 2
-        } else {
-          buf.append(in, p, qpos(i))
+        else
+          buf.append(line, p, qpos(i))
           p = qpos(i)
-        }
-      }
       buf.toString
-    }
-    def text() = {
+
+    def text(): String =
       val res =
-        if (qpos.isEmpty) in.substring(start, pos)
-        else if (qpos(0) == start && qpos(1) == pos) in.substring(start+1, pos-1)
+        if qpos.isEmpty then line.substring(start, pos)
+        else if qpos(0) == start && qpos(1) == pos then line.substring(start+1, pos-1)
         else copyText()
       qpos.clear()
       res
-    }
-    def badquote = Left("Unmatched quote")
 
-    @tailrec def loop(): Either[String, List[String]] = {
+    inline def badquote() = errorFn(s"Unmatched quote [${qpos.last}](${line.charAt(qpos.last)})")
+
+    inline def skipWhitespace() = while isWhitespace(cur) do pos += 1
+
+    @tailrec def loop(): List[String] =
       skipWhitespace()
       start = pos
-      if (done) Right(accum)
-      else if (!skipToDelim()) badquote
-      else {
+      if done then
+        accum.reverse
+      else if !skipToDelim() then
+        badquote()
+        Nil
+      else
         accum = text() :: accum
         loop()
-      }
-    }
-    loop()
-  }
+    end loop
 
-  class ParseException(msg: String) extends RuntimeException(msg)
+    loop()
 
-  def tokenize(line: String, errorFn: String => Unit): List[String] =
-    tokens(line) match {
-      case Right(args) => args.reverse
-      case Left(msg)   => errorFn(msg) ; Nil
-    }
+  end tokenize
 
   def tokenize(line: String): List[String] = tokenize(line, x => throw new ParseException(x))
-}
+
+  class ParseException(msg: String) extends RuntimeException(msg)

compiler/test/dotty/tools/dotc/config/CommandLineParserTest.scala

@@ -9,10 +9,11 @@ class CommandLineParserTest:
 
   private def check(tokens: String*)(input: String): Unit = assertEquals(tokens, tokenize(input))
 
-  private def checkFails(input: String): Unit =
-    var failed = false
-    val res = tokenize(input, _ => failed = true)
-    assertTrue(s"Expected bad tokenization for [$input] but result was [$res]", failed)
+  private def checkFails(input: String, output: String): Unit =
+    var txt: String = null
+    val res = tokenize(input, msg => txt = msg)
+    assertTrue(s"Expected bad tokenization for [$input] but result was [$res]", txt ne null)
+    assertEquals(output, txt)
 
   @Test def parserTokenizes() =
     check()("")
@@ -39,5 +40,5 @@ class CommandLineParserTest:
     check("x'y'z")("""x"'y'"z""")
     check("abcxyz")(""""abc"xyz""")
     // missing quotes
-    checkFails(""""x""")         // was assertEquals(List("\"x"), tokenize(""""x"""))
-    checkFails("""x'""")
+    checkFails(""""x""", "Unmatched quote [0](\")")  // was assertEquals(List("\"x"), tokenize(""""x"""))
+    checkFails("""x'""", "Unmatched quote [1](')")