Add annotations highlight

- Highlight is based on MemberDef with annotations present
- move scanner highlighter before parser so that annotation @inline
wholdn't be highlighted as keyword
- annotations are highlighted when full member definition is available

Author: slothspot

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

@@ -370,17 +370,12 @@ object SyntaxHighlighting {
     override def doReport(m: MessageContainer)(implicit ctx: Context): Unit = ()
   }
 
-  private val ignoredKwds = Set(nme.ARROWkw, nme.EQ, nme.EQL, nme.COLONkw)
-
   def highlight(in: String)(ctx0: Context): String = {
     import dotty.tools.dotc.ast.untpd._
 
     implicit val ctx: Context = ctx0.fresh.setReporter(new NoReporter)
 
     val source = new SourceFile("<highlighting>", in.toCharArray)
-    val parser = new Parser(source)
-    val trees = parser.blockStatSeq()
-
     val colorAt = Array.fill(in.length)(NoColor)
 
     def highlightRange(from: Int, to: Int, color: String) = {
@@ -395,18 +390,39 @@ object SyntaxHighlighting {
     def highlightPosition(pos: Position, color: String) =
       if (pos.exists) highlightRange(pos.start, pos.end, color)
 
+    val scanner = new Scanner(source)
+
+    while (scanner.token != EOF) {
+      val isKwd = alphaKeywords.contains(scanner.token)
+      val offsetStart = scanner.offset
+
+      if (scanner.token == IDENTIFIER && scanner.name == nme.???) {
+        highlightRange(scanner.offset, scanner.offset + scanner.name.length, Console.RED_B)
+      }
+      scanner.nextToken()
+
+      if (isKwd) {
+        val offsetEnd = scanner.lastOffset
+        highlightPosition(Position(offsetStart, offsetEnd), KeywordColor)
+      }
+    }
+
     val treeHighlighter = new UntypedTreeTraverser {
       def traverse(tree: Tree)(implicit ctx: Context): Unit = {
         tree match {
-          case id: Ident if id.isType =>
+          case id : Ident if id.isType =>
             highlightPosition(id.pos, TypeColor)
           case tpe : TypeDef =>
+            for (annotation <- tpe.rawMods.annotations)
+              highlightPosition(annotation.pos, AnnotationColor)
             highlightPosition(tpe.namePos, TypeColor)
           case _ : TypTree =>
             highlightPosition(tree.pos, TypeColor)
           case mod: ModuleDef =>
             highlightPosition(mod.namePos, TypeColor)
           case v : ValOrDefDef =>
+            for (annotation <- v.rawMods.annotations)
+              highlightPosition(annotation.pos, AnnotationColor)
             highlightPosition(v.namePos, ValDefColor)
             highlightPosition(v.tpt.pos, TypeColor)
           case _ : Literal =>
@@ -417,26 +433,12 @@ object SyntaxHighlighting {
       }
     }
 
+    val parser = new Parser(source)
+    val trees = parser.blockStatSeq()
+
     for (tree <- trees)
       treeHighlighter.traverse(tree)
 
-    val scanner = new Scanner(source)
-
-    while (scanner.token != EOF) {
-      val isKwd = isKeyword(scanner.token) && !ignoredKwds.contains(scanner.name)
-      val offsetStart = scanner.offset
-
-      if (scanner.token == IDENTIFIER && scanner.name == nme.???) {
-        highlightRange(scanner.offset, scanner.offset + scanner.name.length, Console.RED_B)
-      }
-      scanner.nextToken()
-
-      if (isKwd) {
-        val offsetEnd = scanner.lastOffset
-        highlightPosition(Position(offsetStart, offsetEnd), KeywordColor)
-      }
-    }
-
     val sb = new mutable.StringBuilder()
 
     for (idx <- colorAt.indices) {

compiler/test/dotty/tools/dotc/printing/SyntaxHighlightingTests.scala

@@ -50,11 +50,33 @@ class SyntaxHighlightingTests extends DottyTest {
   def strings = {
     // For some reason we currently use literal color for string
     test("\"Hello\"", "<L|\"Hello\">")
+    test("s\"Hello\"", "s<L|\"Hello\">")
+//    test("s\"Hello $name\"", "s<L|\"Hello <V|$name<L|\">")
+    test("raw\"Hello\"", "raw<L|\"Hello\">")
+    test("s\"\"\"Hello\"\"\"", "s<L|\"\"\"Hello\"\"\">")
   }
 
   @Test
   def annotations = {
-    test("@tailrec", "<T|@tailrec>")
+    val source =
+      """
+        |@deprecated
+        |class Foo {
+        |  @inline val bar = 42
+        |}
+      """.stripMargin
+
+    val expected =
+      """
+        |<T|@deprecated>
+        |<K|class> <T|Foo> {
+        |  <T|@inline> <K|val> <V|bar> = <L|42>
+        |}
+      """.stripMargin
+
+    test(source, expected)
+
+    test("@deprecated class Foo", "<T|@deprecated> <K|class> <T|Foo>")
   }
 
   @Test