Move SyntaxHighlight to scala.quoted

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala

@@ -4,6 +4,8 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.util.{SourcePosition, Spans}
 
+import scala.quoted.show.SyntaxHighlight
+
 object ReflectionImpl {
 
   def apply(rootContext: Contexts.Context): scala.tasty.Reflection =
@@ -16,7 +18,10 @@ object ReflectionImpl {
     val refl = new scala.tasty.Reflection(new KernelImpl(ctx, tree.sourcePos))
     val reflCtx = ctx.asInstanceOf[refl.Context]
     val reflTree = tree.asInstanceOf[refl.Tree]
-    new refl.SourceCodePrinter(ctx.settings.color.value == "always").showTree(reflTree)(reflCtx)
+    val syntaxHighlight =
+      if (ctx.settings.color.value == "always") SyntaxHighlight.ANSI
+      else SyntaxHighlight.plain
+    new refl.SourceCodePrinter(syntaxHighlight).showTree(reflTree)(reflCtx)
   }
 
 }

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

@@ -4,7 +4,7 @@ package util
 
 import core.Names._
 import collection.mutable
-import scala.tasty.util.Chars
+import scala.internal.Chars
 
 import scala.annotation.internal.sharable
 

library/src-3.x/scala/quoted/Expr.scala

@@ -2,6 +2,8 @@ package scala
 
 package quoted {
 
+  import scala.quoted.show.SyntaxHighlight
+
   sealed abstract class Expr[+T] {
 
     /** Evaluate the contents of this expression and return the result.
@@ -18,9 +20,13 @@ package quoted {
     import scala.internal.quoted._
 
     implicit class ExprOps[T](expr: Expr[T]) {
+
       /** Show a source code like representation of this expression */
-      def show(implicit qctx: QuoteContext): String = qctx.show(expr, false)
-      def showFormatted(implicit qctx: QuoteContext): String = qctx.show(expr, true)
+      def show(implicit qctx: QuoteContext): String = qctx.show(expr, SyntaxHighlight.plain)
+
+      /** Show a source code like representation of this expression */
+      def show(syntaxHighlight: SyntaxHighlight)(implicit qctx: QuoteContext): String = qctx.show(expr, syntaxHighlight)
+
     }
 
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */

library/src-3.x/scala/quoted/Type.scala

@@ -2,6 +2,7 @@ package scala
 
 package quoted {
   import scala.internal.quoted.TaggedType
+  import scala.quoted.show.SyntaxHighlight
 
   sealed abstract class Type[T <: AnyKind] {
     type `$splice` = T
@@ -11,9 +12,13 @@ package quoted {
   object Type {
 
     implicit class TypeOps[T](tpe: Type[T]) {
-      /** Show a source code like representation of this expression */
-      def show(implicit qctx: QuoteContext): String = qctx.show(tpe, false)
-      def showFormatted(implicit qctx: QuoteContext): String = qctx.show(tpe, true)
+
+      /** Show a source code like representation of this type */
+      def show(implicit qctx: QuoteContext): String = qctx.show(tpe, SyntaxHighlight.plain)
+
+      /** Show a source code like representation of this type */
+      def show(syntaxHighlight: SyntaxHighlight)(implicit qctx: QuoteContext): String = qctx.show(tpe, syntaxHighlight)
+
     }
 
     implicit val UnitTag: Type[Unit] = new TaggedType[Unit]

library/src-3.x/scala/quoted/package.scala

@@ -16,8 +16,6 @@ package object quoted {
    */
   def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr given _)
 
-  def show[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): String = run(expr.show.toExpr)
-
   object autolift {
     implicit def autoToExpr[T: Liftable](x: T): Expr[T] = x.toExpr
   }

library/src/scala/internal/Chars.scala

@@ -0,0 +1,96 @@
+package scala.internal
+
+import scala.annotation.switch
+import java.lang.{Character => JCharacter}
+import java.lang.Character.LETTER_NUMBER
+import java.lang.Character.LOWERCASE_LETTER
+import java.lang.Character.OTHER_LETTER
+import java.lang.Character.TITLECASE_LETTER
+import java.lang.Character.UPPERCASE_LETTER
+
+/** Contains constants and classifier methods for characters */
+object Chars {
+
+  final val LF = '\u000A'
+  final val FF = '\u000C'
+  final val CR = '\u000D'
+  final val SU = '\u001A'
+
+  /** Convert a character digit to an Int according to given base,
+    *  -1 if no success
+    */
+  def digit2int(ch: Char, base: Int): Int = {
+    val num = (
+      if (ch <= '9') ch - '0'
+      else if ('a' <= ch && ch <= 'z') ch - 'a' + 10
+      else if ('A' <= ch && ch <= 'Z') ch - 'A' + 10
+      else -1
+      )
+    if (0 <= num && num < base) num else -1
+  }
+  /** Buffer for creating '\ u XXXX' strings. */
+  private[this] val char2uescapeArray = Array[Char]('\\', 'u', 0, 0, 0, 0)
+
+  /** Convert a character to a backslash-u escape */
+  def char2uescape(c: Char): String = {
+    @forceInline def hexChar(ch: Int): Char =
+      (( if (ch < 10) '0' else 'A' - 10 ) + ch).toChar
+
+    char2uescapeArray(2) = hexChar((c >> 12)     )
+    char2uescapeArray(3) = hexChar((c >>  8) % 16)
+    char2uescapeArray(4) = hexChar((c >>  4) % 16)
+    char2uescapeArray(5) = hexChar((c      ) % 16)
+
+    new String(char2uescapeArray)
+  }
+
+  /** Is character a line break? */
+  def isLineBreakChar(c: Char): Boolean = (c: @switch) match {
+    case LF|FF|CR|SU  => true
+    case _            => false
+  }
+
+  /** Is character a whitespace character (but not a new line)? */
+  def isWhitespace(c: Char): Boolean =
+    c == ' ' || c == '\t' || c == CR
+
+  /** Can character form part of a doc comment variable $xxx? */
+  def isVarPart(c: Char): Boolean =
+    '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
+
+  /** Can character start an alphanumeric Scala identifier? */
+  def isIdentifierStart(c: Char): Boolean =
+    (c == '_') || (c == '$') || JCharacter.isUnicodeIdentifierStart(c)
+
+  /** Can character form part of an alphanumeric Scala identifier? */
+  def isIdentifierPart(c: Char): Boolean =
+    (c == '$') || JCharacter.isUnicodeIdentifierPart(c)
+
+  /** Is character a math or other symbol in Unicode?  */
+  def isSpecial(c: Char): Boolean = {
+    val chtp = JCharacter.getType(c)
+    chtp == JCharacter.MATH_SYMBOL.toInt || chtp == JCharacter.OTHER_SYMBOL.toInt
+  }
+
+  def isValidJVMChar(c: Char): Boolean =
+    !(c == '.' || c == ';' || c =='[' || c == '/')
+
+  def isValidJVMMethodChar(c: Char): Boolean =
+    !(c == '.' || c == ';' || c =='[' || c == '/' || c == '<' || c == '>')
+
+  private final val otherLetters = Set[Char]('\u0024', '\u005F')  // '$' and '_'
+  private final val letterGroups = {
+    import JCharacter._
+    Set[Byte](LOWERCASE_LETTER, UPPERCASE_LETTER, OTHER_LETTER, TITLECASE_LETTER, LETTER_NUMBER)
+  }
+  def isScalaLetter(ch: Char): Boolean = letterGroups(JCharacter.getType(ch).toByte) || otherLetters(ch)
+
+  /** Can character form part of a Scala operator name? */
+  def isOperatorPart(c : Char) : Boolean = (c: @switch) match {
+    case '~' | '!' | '@' | '#' | '%' |
+         '^' | '*' | '+' | '-' | '<' |
+         '>' | '?' | ':' | '=' | '&' |
+         '|' | '/' | '\\' => true
+    case c => isSpecial(c)
+  }
+}

library/src/scala/quoted/QuoteContext.scala

@@ -1,17 +1,17 @@
 package scala.quoted
 
+import scala.quoted.show.SyntaxHighlight
+
 class QuoteContext(reflection: tasty.Reflection) {
 
-  def show[T](expr: Expr[T], formatted: Boolean): String = {
+  def show[T](expr: Expr[T], syntaxHighlight: SyntaxHighlight): String = {
     import reflection._
-    if (formatted) expr.unseal.showFormatted
-    else expr.unseal.show
+    expr.unseal.show(syntaxHighlight)
   }
 
-  def show[T](tpe: Type[T], formatted: Boolean): String = {
+  def show[T](tpe: Type[T], syntaxHighlight: SyntaxHighlight): String = {
     import reflection._
-    if (formatted) tpe.unseal.showFormatted
-    else tpe.unseal.show
+    tpe.unseal.show(syntaxHighlight)
   }
 
 }

library/src/scala/quoted/show/SyntaxHighlight.scala

@@ -0,0 +1,47 @@
+package scala.quoted.show
+
+trait SyntaxHighlight {
+  def highlightKeyword(str: String): String
+  def highlightTypeDef(str: String): String
+  def highlightLiteral(str: String): String
+  def highlightValDef(str: String): String
+  def highlightOperator(str: String): String
+  def highlightAnnotation(str: String): String
+  def highlightString(str: String): String
+  def highlightTripleQs: String
+}
+
+object SyntaxHighlight {
+
+  def ANSI: SyntaxHighlight = new SyntaxHighlight {
+    // Keep in sync with SyntaxHighlighting
+    private val NoColor         = Console.RESET
+    private val CommentColor    = Console.BLUE
+    private val KeywordColor    = Console.YELLOW
+    private val ValDefColor     = Console.CYAN
+    private val LiteralColor    = Console.RED
+    private val StringColor     = Console.GREEN
+    private val TypeColor       = Console.MAGENTA
+    private val AnnotationColor = Console.MAGENTA
+
+    def highlightKeyword(str: String): String = KeywordColor + str + NoColor
+    def highlightTypeDef(str: String): String = TypeColor + str + NoColor
+    def highlightLiteral(str: String): String = LiteralColor + str + NoColor
+    def highlightValDef(str: String): String = ValDefColor + str + NoColor
+    def highlightOperator(str: String): String = TypeColor + str + NoColor
+    def highlightAnnotation(str: String): String = AnnotationColor + str + NoColor
+    def highlightString(str: String): String = StringColor + str + NoColor
+    def highlightTripleQs: String = Console.RED_B + "???" + NoColor
+  }
+
+  def plain: SyntaxHighlight = new SyntaxHighlight {
+    def highlightKeyword(str: String): String = str
+    def highlightTypeDef(str: String): String = str
+    def highlightLiteral(str: String): String = str
+    def highlightValDef(str: String): String = str
+    def highlightOperator(str: String): String = str
+    def highlightAnnotation(str: String): String = str
+    def highlightString(str: String): String = str
+    def highlightTripleQs: String = "???"
+  }
+}

library/src/scala/quoted/show/package.scala

@@ -0,0 +1,7 @@
+package scala.quoted
+
+package object show {
+
+  def apply[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): String = run(expr.show.toExpr)
+
+}