Relocate to Chars and share

Author: som-snytt

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -11,14 +11,12 @@ import ast.Trees.*
 import typer.Implicits.*
 import typer.ImportInfo
 import Variances.varianceSign
-import util.SourcePosition
+import util.{Chars, SourcePosition}
 import scala.util.control.NonFatal
 import scala.annotation.switch
 import config.{Config, Feature}
 import cc.{CapturingType, EventuallyCapturingType, CaptureSet, isBoxed}
 
-import java.lang.StringBuilder
-
 class PlainPrinter(_ctx: Context) extends Printer {
 
   /** The context of all public methods in Printer and subclasses.
@@ -581,18 +579,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(denot: Denotation): Text = toText(denot.symbol) ~ "/D"
 
-  private def escapedChar(ch: Char): String =
-    if requiresFormat(ch) then
-      val b = StringBuilder().append('\'')
-      escapedChar(b, ch)
-      b.append('\'').toString
-    else
-      "'" + ch + "'"
-
   def toText(const: Constant): Text = const.tag match {
-    case StringTag => stringText(escapedString(const.value.toString, quoted = true))
+    case StringTag => stringText(Chars.escapedString(const.value.toString, quoted = true))
     case ClazzTag => "classOf[" ~ toText(const.typeValue) ~ "]"
-    case CharTag => literalText(escapedChar(const.charValue))
+    case CharTag => literalText(Chars.escapedChar(const.charValue))
     case LongTag => literalText(const.longValue.toString + "L")
     case DoubleTag => literalText(const.doubleValue.toString + "d")
     case FloatTag => literalText(const.floatValue.toString + "f")
@@ -610,57 +600,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     ~ (if param.isTypeParam then "" else ": ")
     ~ toText(param.paramInfo)
 
-  protected final def escapedString(str: String): String = escapedString(str, quoted = false)
-
-  private def requiresFormat(c: Char): Boolean = (c: @switch) match
-    case '\b' | '\t' | '\n' | '\f' | '\r' | '"' | '\'' | '\\' => true
-    case c => c.isControl
-
-  private def escapedString(text: String, quoted: Boolean): String =
-    def mustBuild: Boolean =
-      var i = 0
-      while i < text.length do
-        if requiresFormat(text.charAt(i)) then return true
-        i += 1
-      false
-    if mustBuild then
-      val b = StringBuilder(text.length + 16)
-      if quoted then
-        b.append('"')
-      var i = 0
-      while i < text.length do
-        escapedChar(b, text.charAt(i))
-        i += 1
-      if quoted then
-        b.append('"')
-      b.toString
-    else if quoted then "\"" + text + "\""
-    else text
-
-  private def escapedChar(b: StringBuilder, c: Char): Unit =
-    def quadNibble(b: StringBuilder, x: Int, i: Int): Unit =
-      if i < 4 then
-        quadNibble(b, x >> 4, i + 1)
-        val n = x & 0xF
-        val c = if (n < 10) '0' + n else 'a' + (n - 10)
-        b.append(c.toChar)
-    val replace = (c: @switch) match
-      case '\b' => "\\b"
-      case '\t' => "\\t"
-      case '\n' => "\\n"
-      case '\f' => "\\f"
-      case '\r' => "\\r"
-      case '"'  => "\\\""
-      case '\'' => "\\\'"
-      case '\\' => "\\\\"
-      case c =>
-        if c.isControl then
-          b.append("\\u")
-          quadNibble(b, c.toInt, 0)
-        else
-          b.append(c)
-        return
-    b.append(replace)
+  protected final def escapedString(str: String): String = Chars.escapedString(str, quoted = false)
 
   def dclsText(syms: List[Symbol], sep: String): Text = Text(syms map dclText, sep)
 

compiler/src/dotty/tools/dotc/util/Chars.scala

@@ -3,7 +3,8 @@ package dotty.tools.dotc.util
 import scala.annotation.switch
 import Character.{LETTER_NUMBER, LOWERCASE_LETTER, OTHER_LETTER, TITLECASE_LETTER, UPPERCASE_LETTER}
 import Character.{MATH_SYMBOL, OTHER_SYMBOL}
-import Character.{isJavaIdentifierPart, isUnicodeIdentifierStart, isUnicodeIdentifierPart}
+import Character.{isISOControl as isControl, isJavaIdentifierPart, isUnicodeIdentifierStart, isUnicodeIdentifierPart}
+import java.lang.StringBuilder
 
 /** Contains constants and classifier methods for characters */
 object Chars:
@@ -110,3 +111,59 @@ object Chars:
 
   /** Would the character be encoded by `NameTransformer.encode`? */
   def willBeEncoded(c: Char): Boolean = !isJavaIdentifierPart(c)
+
+  private inline def requiresFormat(c: Char): Boolean = (c: @switch) match
+    case '\b' | '\t' | '\n' | '\f' | '\r' | '"' | '\'' | '\\' => true
+    case c => isControl(c)
+
+  def escapedString(text: String, quoted: Boolean): String =
+    inline def doBuild: String =
+      val b = StringBuilder(text.length + 16)
+      if quoted then
+        b.append('"')
+      var i = 0
+      while i < text.length do
+        escapedChar(b, text.charAt(i))
+        i += 1
+      if quoted then
+        b.append('"')
+      b.toString
+    var i = 0
+    while i < text.length do
+      if requiresFormat(text.charAt(i)) then return doBuild
+      i += 1
+    if quoted then "\"" + text + "\""
+    else text
+
+  def escapedChar(ch: Char): String =
+    if requiresFormat(ch) then
+      val b = StringBuilder().append('\'')
+      escapedChar(b, ch)
+      b.append('\'').toString
+    else
+      "'" + ch + "'"
+
+  private def escapedChar(b: StringBuilder, c: Char): Unit =
+    inline def quadNibble(x: Int, i: Int): Unit =
+      if i < 4 then
+        quadNibble(x >> 4, i + 1)
+        val n = x & 0xF
+        val c = if (n < 10) '0' + n else 'a' + (n - 10)
+        b.append(c.toChar)
+    val replace = (c: @switch) match
+      case '\b' => "\\b"
+      case '\t' => "\\t"
+      case '\n' => "\\n"
+      case '\f' => "\\f"
+      case '\r' => "\\r"
+      case '"'  => "\\\""
+      case '\'' => "\\\'"
+      case '\\' => "\\\\"
+      case c =>
+        if isControl(c) then
+          b.append("\\u")
+          quadNibble(c.toInt, 0)
+        else
+          b.append(c)
+        return
+    b.append(replace)

compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

@@ -962,9 +962,6 @@ object SourceCode {
 
     }
 
-    inline private val qc  = "\'"
-    inline private val qSc = "\""
-
     def printConstant(const: Constant): this.type = const match {
       case UnitConstant() => this += highlightLiteral("()")
       case NullConstant() => this += highlightLiteral("null")
@@ -975,8 +972,8 @@ object SourceCode {
       case LongConstant(v) => this += highlightLiteral(v.toString + "L")
       case FloatConstant(v) => this += highlightLiteral(v.toString + "f")
       case DoubleConstant(v) => this += highlightLiteral(v.toString)
-      case CharConstant(v) => this += highlightString(escapedChar(v))
-      case StringConstant(v) => this += highlightString(escapedString(v))
+      case CharConstant(v) => this += highlightString(Chars.escapedChar(v))
+      case StringConstant(v) => this += highlightString(Chars.escapedString(v, quoted = true))
       case ClassOfConstant(v) =>
         this += "classOf"
         inSquare(printType(v))
@@ -1449,62 +1446,6 @@ object SourceCode {
     private def +=(x: Char): this.type = { sb.append(x); this }
     private def +=(x: String): this.type = { sb.append(x); this }
 
-    private def escapedChar(ch: Char): String =
-      if requiresFormat(ch) then
-        val b = StringBuilder().append(qc)
-        escapedChar(b.nn, ch)
-        b.nn.append(qc).toString
-      else
-        qc + ch + qc
-
-    private def escapedChar(b: StringBuilder, c: Char): Unit =
-      def quadNibble(b: StringBuilder, x: Int, i: Int): Unit =
-        if i < 4 then
-          quadNibble(b, x >> 4, i + 1)
-          val n = x & 0xF
-          val c = if (n < 10) '0' + n else 'a' + (n - 10)
-          b.append(c.toChar)
-      val replace = (c: @switch) match
-        case '\b' => "\\b"
-        case '\t' => "\\t"
-        case '\n' => "\\n"
-        case '\f' => "\\f"
-        case '\r' => "\\r"
-        case '"'  => "\\\""
-        case '\'' => "\\\'"
-        case '\\' => "\\\\"
-        case c =>
-          if c.isControl then
-            b.append("\\u")
-            quadNibble(b, c.toInt, 0)
-          else
-            b.append(c)
-          return
-      b.append(replace)
-
-    private def requiresFormat(c: Char): Boolean = (c: @switch) match
-      case '\b' | '\t' | '\n' | '\f' | '\r' | '"' | '\'' | '\\' => true
-      case c => c.isControl
-
-    private def escapedString(text: String): String =
-      def mustBuild: Boolean =
-        var i = 0
-        while i < text.length do
-          if requiresFormat(text.charAt(i)) then return true
-          i += 1
-        false
-      if mustBuild then
-        val b = StringBuilder(text.length + 16)
-        b.append(qSc)
-        var i = 0
-        while i < text.length do
-          escapedChar(b, text.charAt(i))
-          i += 1
-        b.append(qSc)
-        b.toString
-      else
-        qSc + text + qSc
-
     private val names = collection.mutable.Map.empty[Symbol, String]
     private val namesIndex = collection.mutable.Map.empty[String, Int]