reporting callback added;

progress messages passed via compiler callback

Author: niktrop

src/dotty/tools/dotc/CompilerCallback.scala

@@ -2,6 +2,7 @@ package dotty.tools.dotc
 
 import config.CompilerCommand
 import core.Contexts.{Context, ContextBase}
+import dotty.tools.dotc.callbacks.{ReportingCallback, CompilerCallback}
 import util.DotClass
 import reporting._
 import scala.util.control.NonFatal
@@ -36,7 +37,7 @@ abstract class Driver extends DotClass {
     val summary = CompilerCommand.distill(args)(rootCtx)
     // FIXME: We should reuse rootCtx instead of creating newCtx, but this
     // makes some tests fail with "denotation module _root_ invalid in run 2."
-    val newCtx = initCtx.setCompilerCallback(rootCtx.compilerCallback)
+    val newCtx = initCtx.setCompilerCallback(rootCtx.compilerCallback).setReportingCallback(rootCtx.reportingCallback)
     implicit val ctx: Context = newCtx.fresh.setSettings(summary.sstate)
     val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)
     (fileNames, ctx)
@@ -47,8 +48,8 @@ abstract class Driver extends DotClass {
     doCompile(newCompiler(), fileNames)(ctx)
   }
 
-  def process(args: Array[String], callback: CompilerCallback): Reporter = {
-    process(args, initCtx.setCompilerCallback(callback))
+  def process(args: Array[String], callback: CompilerCallback, reportingCallback: ReportingCallback): Reporter = {
+    process(args, initCtx.setCompilerCallback(callback).setReportingCallback(reportingCallback))
   }
 
   // We overload `process` instead of using a default argument so that we

src/dotty/tools/dotc/Driver.scala

@@ -0,0 +1,54 @@
+package dotty.tools.dotc.callbacks;
+
+import java.io.File;
+
+/** This interface contains methods that can be implemented to execute code during the
+ *  compilation process.
+ *
+ *  NOTE: This trait is experimental and may be subject to arbitrary changes.
+ *
+ *  Example usage:
+ *  {{{
+ *  val args: Array[String] = ...
+ *  val callback = new CompilerCallback {
+ *    override def onClassGenerated(source: File, generatedClass: File, className: String) =
+ *      println(s"onClassGenerated($source, $generatedClass, $className)")
+ *    override def onSourceCompiled(source: File) =
+ *      println(s"onSourceCompiled($source)")
+ *  }
+ *  dotty.tools.dotc.process(args, callback)
+ *  // Or, if you have a custom root context `rootCtx`:
+ *  dotty.tools.dotc.process(args, rootCtx.setCompilerCallback(callback))
+ *  }}}
+ */
+public interface CompilerCallback {
+
+    /** Called when a class has been generated.
+     *
+     *  @param source         The source file corresponding to this class.
+     *                        Example: ./src/library/scala/collection/Seq.scala
+     *  @param generatedClass The generated classfile for this class.
+     *                        Example: ./scala/collection/Seq$.class
+     *  @param className      The name of this class.
+     *                        Example: scala.collection.Seq$
+     */
+    void onClassGenerated(File source, File generatedClass, String className);
+
+    /** Called when every class for this file has been generated.
+     *
+     *  @param source         The source file.
+     *                        Example: ./src/library/scala/collection/Seq.scala
+     */
+    void onSourceCompiled(File source);
+
+    /** Called when compilation phase starts on a given source
+     *
+     *  @param phase          Name of the current phase
+     *  @param sourcePath     Path to the processed file
+     */
+    void startUnit(String phase, String sourcePath);
+
+    /** Called to show progress of the compilation process
+     */
+    void advance(int currentProgress, int totalProgress);
+}

src/dotty/tools/dotc/callbacks/CompilerCallback.java

@@ -0,0 +1,18 @@
+package dotty.tools.dotc.callbacks;
+
+import java.io.File;
+
+public interface Position
+{
+	File sourceFile();
+
+	String sourcePath();
+
+	int line();
+
+	String lineContent();
+
+	int offset();
+
+	int column();
+}

src/dotty/tools/dotc/callbacks/Position.java

@@ -0,0 +1,17 @@
+package dotty.tools.dotc.callbacks;
+
+/**
+ * @author Nikolay.Tropin
+ */
+public interface ReportingCallback {
+
+    void info(String msg, Position pos);
+
+    void warning(String msg, Position pos);
+
+    void error(String msg, Position pos);
+
+    void debug(String msg);
+
+    void trace(Throwable exception);
+}

src/dotty/tools/dotc/callbacks/ReportingCallback.java

@@ -13,6 +13,7 @@ import NameOps._
 import Uniques._
 import SymDenotations._
 import Flags.ParamAccessor
+import dotty.tools.dotc.callbacks.{CompilerCallback, ReportingCallback}
 import util.Positions._
 import ast.Trees._
 import ast.untpd
@@ -77,6 +78,11 @@ object Contexts {
       base.compilerCallback = callback; this
     }
 
+    /** Set the reporting callback, shared by all contexts with the same `base` */
+    def setReportingCallback(callback: ReportingCallback): this.type = {
+      base.reportingCallback = callback; this
+    }
+
     /** The outer context */
     private[this] var _outer: Context = _
     protected def outer_=(outer: Context) = _outer = outer
@@ -540,6 +546,8 @@ object Contexts {
     /** The compiler callback implementation, or null if unset */
     var compilerCallback: CompilerCallback = _
 
+    var reportingCallback: ReportingCallback = _
+
     // Symbols state
 
     /** A counter for unique ids */

src/dotty/tools/dotc/core/Contexts.scala

@@ -267,6 +267,9 @@ object Phases {
 
     def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
       units.map { unit =>
+        if (ctx.compilerCallback != null)
+          ctx.compilerCallback.startUnit(phaseName, unit.source.file.path)
+
         val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
         run(unitCtx)
         unitCtx.compilationUnit

src/dotty/tools/dotc/core/Phases.scala

@@ -0,0 +1,24 @@
+package dotty.tools.dotc.reporting
+
+import java.io.File
+
+import dotty.tools.dotc.callbacks.Position
+import dotty.tools.dotc.util.SourcePosition
+
+/**
+  * @author Nikolay.Tropin
+  */
+class CallbackPositionAdapter(sourcePosition: SourcePosition) extends Position {
+
+  override def sourceFile(): File = sourcePosition.source.file.file
+
+  override def sourcePath(): String = sourcePosition.source.file.path
+
+  override def line(): Int = sourcePosition.line
+
+  override def lineContent(): String = sourcePosition.lineContents
+
+  override def column(): Int = sourcePosition.column
+
+  override def offset(): Int = sourcePosition.point
+}

src/dotty/tools/dotc/reporting/CallbackPositionAdapter.scala

@@ -71,7 +71,7 @@ object Reporter {
   }
 }
 
-import Reporter._
+import dotty.tools.dotc.reporting.Reporter._
 
 trait Reporting { this: Context =>
 
@@ -234,14 +234,16 @@ abstract class Reporter {
   }
 
   def report(d: Diagnostic)(implicit ctx: Context): Unit =
-    if (!isHidden(d) && doReport(d)(ctx.addMode(Mode.Printing)))
+    if (!isHidden(d) && doReport(d)(ctx.addMode(Mode.Printing))) {
+      doCallbackReport(d)
       d match {
         case d: ConditionalWarning if !d.enablingOption.value => unreportedWarnings(d.enablingOption.name) += 1
         case d: Warning => warningCount += 1
         case d: Error => errorCount += 1
         case d: Info => // nothing to do here
         // match error if d is something else
       }
+    }
 
   def incomplete(d: Diagnostic)(implicit ctx: Context): Unit =
     incompleteHandler(d)(ctx)
@@ -265,6 +267,19 @@ abstract class Reporter {
     case _ => n + " " + elements + "s"
   }
 
+  private def doCallbackReport(d: Diagnostic)(implicit ctx: Context): Unit = {
+    val reportingCallback = ctx.reportingCallback
+    if (reportingCallback != null) {
+      val position = if (d.pos.exists) new CallbackPositionAdapter(d.pos) else null
+      d match {
+        case d: ConditionalWarning if d.enablingOption.value => reportingCallback.warning(d.msg, position)
+        case d: Warning => reportingCallback.warning(d.msg, position)
+        case d: Error => reportingCallback.error(d.msg, position)
+        case d: Info => reportingCallback.info(d.msg, position)
+      }
+    }
+  }
+
   /** Should this diagnostic not be reported at all? */
   def isHidden(d: Diagnostic)(implicit ctx: Context): Boolean = ctx.mode.is(Mode.Printing)