Skip to content

Commit ffdc530

Browse files
allanrenucciallanrenucci
committed
Polishing
Fix #4500
1 parent 8dc30f4 commit ffdc530

File tree

5 files changed

+108
-136
lines changed

5 files changed

+108
-136
lines changed

‎compiler/src/dotty/tools/dotc/printing/Formatting.scala

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -83,8 +83,8 @@ object Formatting {
8383
hl.show
8484
case hb: HighlightBuffer =>
8585
hb.toString
86-
case str: String if ctx.settings.color.value != "never" =>
87-
SyntaxHighlighting.highlight(str)(ctx)
86+
case str: String =>
87+
SyntaxHighlighting.highlight(str)
8888
case _ => super.showArg(arg)
8989
}
9090
}

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

Lines changed: 79 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
1-
package dotty.tools
2-
package dotc
3-
package printing
1+
package dotty.tools.dotc.printing
42

3+
import dotty.tools.dotc.ast.untpd
54
import dotty.tools.dotc.core.Contexts.Context
65
import dotty.tools.dotc.core.StdNames._
76
import dotty.tools.dotc.parsing.Parsers.Parser
@@ -10,14 +9,16 @@ import dotty.tools.dotc.parsing.Tokens._
109
import dotty.tools.dotc.reporting.Reporter
1110
import dotty.tools.dotc.reporting.diagnostic.MessageContainer
1211
import dotty.tools.dotc.util.Positions.Position
12+
import dotty.tools.dotc.util.SourceFile
1313

14-
import util.SourceFile
15-
16-
import scala.collection.mutable
14+
import java.util.Arrays
1715

1816
/** This object provides functions for syntax highlighting in the REPL */
1917
object SyntaxHighlighting {
2018

19+
/** if true, log erroneous positions being highlighted */
20+
private final val debug = false
21+
2122
// Keep in sync with SyntaxHighlightingTests
2223
val NoColor = Console.RESET
2324
val CommentColor = Console.BLUE
@@ -32,88 +33,89 @@ object SyntaxHighlighting {
3233
override def doReport(m: MessageContainer)(implicit ctx: Context): Unit = ()
3334
}
3435

35-
def highlight(in: String)(ctx0: Context): String = {
36-
import dotty.tools.dotc.ast.untpd._
37-
38-
implicit val ctx: Context = ctx0.fresh.setReporter(new NoReporter)
39-
40-
val source = new SourceFile("<highlighting>", in.toCharArray)
41-
val colorAt = Array.fill(in.length)(NoColor)
42-
43-
def highlightRange(from: Int, to: Int, color: String) = {
44-
try {
45-
for (i <- from until to)
46-
colorAt(i) = color
47-
} catch {
48-
case _: IndexOutOfBoundsException =>
49-
println("Encountered tree with invalid position, please open an issue with the code snippet that caused the error")
36+
def highlight(in: String)(implicit ctx: Context): String = {
37+
def freshCtx = ctx.fresh.setReporter(new NoReporter)
38+
if (in.isEmpty || ctx.settings.color.value == "never") in
39+
else {
40+
implicit val ctx = freshCtx
41+
val source = new SourceFile("<highlighting>", in.toCharArray)
42+
val colorAt = Array.fill(in.length)(NoColor)
43+
44+
def highlightRange(from: Int, to: Int, color: String) =
45+
Arrays.fill(colorAt.asInstanceOf[Array[AnyRef]], from, to, color)
46+
47+
def highlightPosition(pos: Position, color: String) = if (pos.exists) {
48+
if (pos.start < 0 || pos.end > in.length) {
49+
if (debug)
50+
println(s"Trying to highlight erroneous position $pos. Input size: ${in.length}")
51+
}
52+
else
53+
highlightRange(pos.start, pos.end, color)
5054
}
51-
}
52-
def highlightPosition(pos: Position, color: String) =
53-
if (pos.exists) highlightRange(pos.start, pos.end, color)
54-
55-
val scanner = new Scanner(source)
5655

57-
while (scanner.token != EOF) {
58-
val isKwd = alphaKeywords.contains(scanner.token)
59-
val offsetStart = scanner.offset
60-
61-
if (scanner.token == IDENTIFIER && scanner.name == nme.???) {
62-
highlightRange(scanner.offset, scanner.offset + scanner.name.length, Console.RED_B)
56+
val scanner = new Scanner(source)
57+
while (scanner.token != EOF) {
58+
val start = scanner.offset
59+
val token = scanner.token
60+
val name = scanner.name
61+
scanner.nextToken()
62+
val end = scanner.lastOffset
63+
64+
if (alphaKeywords.contains(token))
65+
highlightRange(start, end, KeywordColor)
66+
else if (token == IDENTIFIER && name == nme.???)
67+
highlightRange(start, end, Console.RED_B)
6368
}
64-
scanner.nextToken()
6569

66-
if (isKwd) {
67-
val offsetEnd = scanner.lastOffset
68-
highlightPosition(Position(offsetStart, offsetEnd), KeywordColor)
69-
}
70-
}
70+
val treeHighlighter = new untpd.UntypedTreeTraverser {
71+
import untpd._
7172

72-
val treeHighlighter = new UntypedTreeTraverser {
73-
def traverse(tree: Tree)(implicit ctx: Context): Unit = {
74-
tree match {
75-
case id : Ident if id.isType =>
76-
highlightPosition(id.pos, TypeColor)
77-
case tpe : TypeDef =>
78-
for (annotation <- tpe.rawMods.annotations)
79-
highlightPosition(annotation.pos, AnnotationColor)
80-
highlightPosition(tpe.namePos, TypeColor)
81-
case _ : TypTree =>
82-
highlightPosition(tree.pos, TypeColor)
83-
case mod: ModuleDef =>
84-
highlightPosition(mod.namePos, TypeColor)
85-
case v : ValOrDefDef =>
86-
for (annotation <- v.rawMods.annotations)
87-
highlightPosition(annotation.pos, AnnotationColor)
88-
highlightPosition(v.namePos, ValDefColor)
89-
highlightPosition(v.tpt.pos, TypeColor)
90-
case _ : Literal =>
91-
highlightPosition(tree.pos, LiteralColor)
92-
case _ =>
73+
def ignored(tree: NameTree) = {
74+
val name = tree.name.toTermName
75+
// trees named <error> and <init> have weird positions
76+
name == nme.ERROR || name == nme.CONSTRUCTOR
9377
}
94-
traverseChildren(tree)
95-
}
96-
}
9778

98-
val parser = new Parser(source)
99-
val trees = parser.blockStatSeq()
79+
def traverse(tree: Tree)(implicit ctx: Context): Unit = {
80+
tree match {
81+
case tree: NameTree if ignored(tree) =>
82+
()
83+
case tree: MemberDef /* ValOrDefDef | ModuleDef | TypeDef */ =>
84+
for (annotation <- tree.rawMods.annotations)
85+
highlightPosition(annotation.pos, AnnotationColor)
86+
val color = if (tree.isInstanceOf[ValOrDefDef]) ValDefColor else TypeColor
87+
highlightPosition(tree.namePos, color)
88+
case tree : Ident if tree.isType =>
89+
highlightPosition(tree.pos, TypeColor)
90+
case _ : TypTree =>
91+
highlightPosition(tree.pos, TypeColor)
92+
case _ : Literal =>
93+
highlightPosition(tree.pos, LiteralColor)
94+
case _ =>
95+
}
96+
traverseChildren(tree)
97+
}
98+
}
10099

101-
for (tree <- trees)
102-
treeHighlighter.traverse(tree)
100+
val parser = new Parser(source)
101+
val trees = parser.blockStatSeq()
102+
for (tree <- trees)
103+
treeHighlighter.traverse(tree)
103104

104-
val sb = new mutable.StringBuilder()
105+
val highlighted = new StringBuilder()
105106

106-
for (idx <- colorAt.indices) {
107-
if ( (idx == 0 && colorAt(idx) != NoColor)
108-
|| (idx > 0 && colorAt(idx-1) != colorAt(idx))) {
109-
sb.append(colorAt(idx))
107+
for (idx <- colorAt.indices) {
108+
val prev = if (idx == 0) NoColor else colorAt(idx - 1)
109+
val curr = colorAt(idx)
110+
if (curr != prev)
111+
highlighted.append(curr)
112+
highlighted.append(in(idx))
110113
}
111-
sb.append(in(idx))
112-
}
113-
if (colorAt.nonEmpty && colorAt.last != NoColor) {
114-
sb.append(NoColor)
115-
}
116114

117-
sb.toString
115+
if (colorAt.last != NoColor)
116+
highlighted.append(NoColor)
117+
118+
highlighted.toString
119+
}
118120
}
119121
}

‎compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,7 @@ trait MessageRendering {
6262

6363
val syntax =
6464
if (ctx.settings.color.value != "never")
65-
SyntaxHighlighting.highlight(pos.linesSlice.mkString)(ctx).toArray
65+
SyntaxHighlighting.highlight(new String(pos.linesSlice)).toArray
6666
else pos.linesSlice
6767
val lines = linesFrom(syntax)
6868
val (before, after) = pos.beforeAndAfterPoint

‎compiler/src/dotty/tools/repl/ReplDriver.scala

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -269,7 +269,7 @@ class ReplDriver(settings: Array[String],
269269
typeAliases.map("// defined alias " + _.symbol.showUser) ++
270270
defs.map(rendering.renderMethod) ++
271271
vals.map(rendering.renderVal).flatten
272-
).foreach(str => out.println(SyntaxHighlighting.highlight(str)(ctx)))
272+
).foreach(str => out.println(SyntaxHighlighting.highlight(str)))
273273

274274
state.copy(valIndex = state.valIndex - vals.count(resAndUnit))
275275
}
@@ -284,7 +284,9 @@ class ReplDriver(settings: Array[String],
284284
x.symbol
285285
}
286286
.foreach { sym =>
287-
out.println(SyntaxHighlighting.highlight("// defined " + sym.showUser)(ctx))
287+
// FIXME syntax highlighting on comment is currently not working
288+
// out.println(SyntaxHighlighting.highlight("// defined " + sym.showUser))
289+
out.println(SyntaxHighlighting.CommentColor + "// defined " + sym.showUser + SyntaxHighlighting.NoColor)
288290
}
289291

290292

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

Lines changed: 22 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,8 @@ class SyntaxHighlightingTests extends DottyTest {
2626
}
2727
}
2828

29-
@Ignore("comments are not properly supported yet")
3029
@Test
30+
@Ignore("Comments are currently not supported")
3131
def comments = {
3232
test("//a", "<C|//a>")
3333
test("/** a */", "<C|/** a */>")
@@ -37,6 +37,8 @@ class SyntaxHighlightingTests extends DottyTest {
3737
@Test
3838
def types = {
3939
test("type Foo = Int", "<K|type> <T|Foo> = <T|Int>")
40+
test("type A = String | Int", "<K|type> <T|A> = <T|String | Int>")
41+
test("type B = String & Int", "<K|type> <T|B> = <T|String & Int>")
4042
}
4143

4244
@Test
@@ -51,77 +53,43 @@ class SyntaxHighlightingTests extends DottyTest {
5153
def strings = {
5254
// For some reason we currently use literal color for string
5355
test("\"Hello\"", "<L|\"Hello\">")
54-
test("s\"Hello\"", "s<L|\"Hello\">")
55-
test("s\"Hello $name\"", "s<L|\"Hello <V|$name<L|\">")
56-
test("raw\"Hello\"", "raw<L|\"Hello\">")
57-
test("raw\"\"\"Hello\"\"\"", "raw<L|\"\"\"Hello\"\"\">")
56+
test("\"\"\"Hello\"\"\"", "<L|\"\"\"Hello\"\"\">")
57+
58+
// FIXME: '$' should not be colored (literal position is off by one)
59+
// test("s\"Hello\"", "s<L|\"Hello\">")
60+
// test("s\"Hello $name\"", "s<L|\"Hello <V|$name<L|\">")
61+
// test("raw\"Hello\"", "raw<L|\"Hello\">")
62+
// test("raw\"\"\"Hello\"\"\"", "raw<L|\"\"\"Hello\"\"\">")
5863
}
5964

60-
@Ignore("annotations handling has to be improved")
6165
@Test
6266
def annotations = {
63-
val source =
64-
"""
65-
|@deprecated
66-
|class Foo {
67-
| @inline val bar = 42
68-
|}
69-
""".stripMargin
70-
71-
val expected =
72-
"""
73-
|<T|@deprecated>
74-
|<K|class> <T|Foo> {
75-
| <T|@inline> <K|val> <V|bar> = <L|42>
76-
|}
77-
""".stripMargin
78-
79-
test(source, expected)
80-
8167
test("@deprecated class Foo", "<T|@deprecated> <K|class> <T|Foo>")
68+
// test("@Test(\"Hello\") class Foo", "<T|@Test(\"Hello\")> <K|class> <T|Foo>") // FIXME
69+
test("@annotation.tailrec def foo = 1", "<T|@annotation.tailrec> <K|def> <V|foo> = <L|1>")
8270
}
8371

8472
@Test
8573
def expressions = {
74+
test("if (true) 1 else 2", "<K|if> (<L|true>) <L|1> <K|else> <L|2>")
8675
test("val x = 1 + 2 + 3", "<K|val> <V|x> = <L|1> + <L|2> + <L|3>")
8776
test("if (true) 3 else 1", "<K|if> (<K|true>) <L|3> <K|else> <L|1>")
8877
}
8978

90-
@Ignore("comments are not properly supported yet")
9179
@Test
92-
def valDef = {
80+
def valOrDefDef = {
9381
test("val a = 123", "<K|val> <V|a> = <L|123>")
94-
test("var b = 123 /*Int*/", "<K|var> <V|b> = <L|123> <C|/*Int*/>")
95-
test("""var c = "123" // String""", """<K|var> <V|c> = <L|"123"> <C|// String>""")
96-
test("var e:Int = 123;e", "<K|var> <V|e>:<T|Int> = <L|123>;e")
82+
test("var e: Int = 123", "<K|var> <V|e>: <T|Int> = <L|123>")
9783
test("def f = 123", "<K|def> <V|f> = <L|123>")
98-
test("def f1(x: Int) = 123", "<K|def> <V|f1>(x: <T|Int>) = <L|123>")
99-
test("def f2[T](x: T) = { 123 }", "<K|def> <V|f2>[<T|T>](x: <T|T>) = { <L|123> }")
100-
}
101-
102-
@Ignore("not properly supported yet")
103-
@Test
104-
def patternMatching = {
105-
test("""val aFruit: Fruit = Apple("red", 123)""",
106-
"""<K|val> <V|aFruit>: <T|Fruit> = <T|Apple>(<L|"red">, <L|123>)""")
107-
test("""val Apple(color, weight) = aFruit""",
108-
"""<K|val> <T|Apple>(<V|color>, <V|weight>) = aFruit""")
109-
test("""case Apple(_, weight) => println(s"apple: $weight kgs")""",
110-
"""<K|case> <T|Apple>(<V|_>, <V|weight>) <T|=>> println(s<L|"apple: <V|$weight <L|kgs">)""")
111-
test("""case o: Orange => println(s"orange ${o.weight} kgs")""",
112-
"""<K|case> <V|o>: <T|Orange> <T|=>> println(s<L|"orange <V|${o.weight}<L| kgs">)""")
113-
test("""case m @ Melon(weight) => println(s"melon: ${m.weight} kgs")""",
114-
"""<K|case> <V|m> @ <T|Melon>(<V|weight>) <T|=>> println(s<L|"melon: <V|${m.weight}<L| kgs">)""")
84+
test("def f1(x: Int) = 123", "<K|def> <V|f1>(<V|x>: <T|Int>) = <L|123>")
85+
test("def f2[T](x: T) = { 123 }", "<K|def> <V|f2>[<T|T>](<V|x>: <T|T>) = { <L|123> }")
11586
}
11687

11788
@Test
118-
def unionTypes = {
119-
test("type A = String|Int| Long", "<K|type> <T|A> = <T|String|Int| Long>")
120-
test("type B = String |Int| Long", "<K|type> <T|B> = <T|String |Int| Long>")
121-
test("type C = String | Int | Long", "<K|type> <T|C> = <T|String | Int | Long>")
122-
test("type D = String&Int& Long", "<K|type> <T|D> = <T|String&Int& Long>")
123-
test("type E = String &Int& Long", "<K|type> <T|E> = <T|String &Int& Long>")
124-
test("type F = String & Int & Long", "<K|type> <T|F> = <T|String & Int & Long>")
125-
test("fn[String|Char](input)", "fn[<T|String|Char>](input)")
89+
@Ignore("TODO: Not implemented")
90+
def patterns = {
91+
test("val Foo(x) = foo", ???)
92+
test("val foo @ Foo(x) = bar", ???)
93+
test("x match { case Foo | Bar => 1 }", ???)
12694
}
12795
}

0 commit comments

Comments
 (0)