Improve Xprint

* Do not reprint a tree that has not changed.
* Highlight changes in yellow.

Author: nicolasstucki

project/Build.scala

@@ -100,6 +100,7 @@ object DottyBuild extends Build {
                                   "org.scala-lang.modules" %% "scala-partest" % "1.0.11" % "test",
                                   "com.novocode" % "junit-interface" % "0.11" % "test",
                                   "jline" % "jline" % "2.12",
+                                  "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0",
                                   "com.typesafe.sbt" % "sbt-interface" % sbtVersion.value),
       // enable improved incremental compilation algorithm
       incOptions := incOptions.value.withNameHashing(true),

src/dotty/tools/dotc/Run.scala

@@ -10,12 +10,17 @@ import reporting.Reporter
 import transform.TreeChecker
 import rewrite.Rewrites
 import java.io.{BufferedWriter, OutputStreamWriter}
+
+import scala.annotation.tailrec
 import scala.reflect.io.VirtualFile
 import scala.util.control.NonFatal
 
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler)(implicit ctx: Context) {
 
+  private final val ANSI_DEFAULT = "\u001B[0m"
+  private final val ANSI_YELLOW = "\u001B[33m"
+
   assert(comp.phases.last.last.id <= Periods.MaxPossiblePhaseId)
   assert(ctx.runId <= Periods.MaxPossibleRunId)
 
@@ -56,26 +61,89 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     val phases = ctx.squashPhases(ctx.phasePlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, ctx.settings.YstopAfter.value, ctx.settings.Ycheck.value)
     ctx.usePhases(phases)
+    var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
       if (!ctx.reporter.hasErrors) {
         val start = System.currentTimeMillis
         units = phase.runOn(units)
-        def foreachUnit(op: Context => Unit)(implicit ctx: Context): Unit =
-          for (unit <- units) op(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
-        if (ctx.settings.Xprint.value.containsPhase(phase))
-          foreachUnit(printTree)
+        if (ctx.settings.Xprint.value.containsPhase(phase)) {
+          for (unit <- units) {
+            lastPrintedTree =
+              printTree(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit), lastPrintedTree)
+          }
+        }
         ctx.informTime(s"$phase ", start)
       }
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
   }
 
-  private def printTree(ctx: Context) = {
+  private sealed trait PrintedTree
+  private final case class SomePrintedTree(phase: String, tree: String) extends PrintedTree
+  private object NoPrintedTree extends PrintedTree
+
+  private def printTree(ctx: Context, last: PrintedTree): PrintedTree = {
     val unit = ctx.compilationUnit
     val prevPhase = ctx.phase.prev // can be a mini-phase
     val squashedPhase = ctx.squashed(prevPhase)
+    val treeString = unit.tpdTree.show(ctx)
+
+    ctx.echo(s"result of $unit after $squashedPhase:")
+
+    last match {
+      case SomePrintedTree(phase, lastTreeSting) if lastTreeSting != treeString =>
+        ctx.echo(mkColoredDiffTree(treeString, lastTreeSting))
+        SomePrintedTree(squashedPhase.toString, treeString)
+
+      case SomePrintedTree(phase, lastTreeSting) =>
+        ctx.echo("  Unchanged since " + phase)
+        last
+
+      case NoPrintedTree =>
+        ctx.echo(treeString)
+        SomePrintedTree(squashedPhase.toString, treeString)
+    }
+  }
+
+  private def mkColoredDiffTree(treeString: String, lastTreeSting: String): String = {
+    import difflib._
+    import scala.collection.JavaConversions._
+
+    @tailrec def split(str: String, acc: List[String]): List[String] = {
+      if (str == "") {
+        acc.reverse
+      } else {
+        val head = str.charAt(0)
+        val (token, rest) = if (Character.isAlphabetic(head) || Character.isDigit(head)) {
+          str.span(c => Character.isAlphabetic(c) || Character.isDigit(c))
+        } else if (Character.isMirrored(head) || Character.isWhitespace(head)) {
+          str.splitAt(1)
+        } else {
+          str.span { c =>
+            !Character.isAlphabetic(c) && !Character.isDigit(c) &&
+            !Character.isMirrored(c) && !Character.isWhitespace(c)
+          }
+        }
+        split(rest, token :: acc)
+      }
+    }
+
+    val lines = split(treeString, Nil).toArray
+
+    val diff = DiffUtils.diff(split(lastTreeSting, Nil), lines.toList)
+    for (delta <- diff.getDeltas) {
+      val pos = delta.getRevised.getPosition
+      val endPos = pos + delta.getRevised.getLines.size - 1
+
+      delta.getType match {
+        case Delta.TYPE.CHANGE | Delta.TYPE.INSERT =>
+          lines(pos) = ANSI_YELLOW + lines(pos)
+          lines(endPos) = lines(endPos) + ANSI_DEFAULT
+
+        case Delta.TYPE.DELETE =>
+      }
+    }
 
-    ctx.echo(s"result of $unit after ${squashedPhase}:")
-    ctx.echo(unit.tpdTree.show(ctx))
+    lines.mkString
   }
 
   def compile(sourceCode: String): Unit = {