Added support for sending start/finish compilation notifications even when all targets are sent to the mill evaluator together.

4 files changed, 42 insertions, 21 deletions

diff --git a/contrib/bsp/src/mill/contrib/MainMillBuildServer.scala b/contrib/bsp/src/mill/contrib/MainMillBuildServer.scala
index bfe23444..24adaf1d 100644
--- a/contrib/bsp/src/mill/contrib/MainMillBuildServer.scala
+++ b/contrib/bsp/src/mill/contrib/MainMillBuildServer.scala
@@ -172,7 +172,7 @@ object MainMillBuildServer extends ExternalModule {
 
       }
       override def onBuildTaskFinish(params: TaskFinishParams): Unit = {
-
+        println("Task Finish: " + params)
       }
       override def onBuildPublishDiagnostics(
                                               params: PublishDiagnosticsParams
diff --git a/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala b/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
index 846ffd42..8ab17d7e 100644
--- a/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
@@ -2,7 +2,7 @@ package mill.contrib.bsp
 
 import java.io.File
 
-import ch.epfl.scala.bsp4j.{BuildServer, BuildTargetIdentifier, InverseSourcesParams, ScalaBuildServer, TextDocumentIdentifier}
+import ch.epfl.scala.bsp4j.{BuildServer, BuildTargetIdentifier, CompileReport, InverseSourcesParams, ScalaBuildServer, StatusCode, TaskFinishParams, TaskId, TextDocumentIdentifier}
 import ch.epfl.scala.{bsp4j => bsp}
 import mill.api.BspContext
 import sbt.internal.inc.ManagedLoggedReporter
@@ -16,6 +16,7 @@ import scala.io.Source
 
 class BspLoggedReporter(client: bsp.BuildClient,
                         targetId: BuildTargetIdentifier,
+                        taskId: TaskId,
                         compilationOriginId: Option[String],
                         maxErrors: Int,
                         logger: ManagedLogger) extends ManagedLoggedReporter(maxErrors, logger) {
@@ -42,6 +43,20 @@ class BspLoggedReporter(client: bsp.BuildClient,
     super.logWarning(problem)
   }
 
+  override def printSummary(): Unit = {
+    val taskFinishParams = new TaskFinishParams(taskId, getStatusCode)
+    taskFinishParams.setEventTime(System.currentTimeMillis())
+    taskFinishParams.setMessage("Finished compiling target: " + targetId.getUri)
+    taskFinishParams.setDataKind("compile-report")
+    val compileReport = new CompileReport(targetId, errors, warnings)
+    compilationOriginId match {
+      case Some(id) => compileReport.setOriginId(id)
+      case None =>
+    }
+    taskFinishParams.setData(compileReport)
+    client.onBuildTaskFinish(taskFinishParams)
+  }
+
   //TODO: document that if the problem is a general information without a text document
   // associated to it, then the document field of the diagnostic is set to the uri of the target
   def getDiagnostics(problem: Problem, targetId: bsp.BuildTargetIdentifier, originId: Option[String]):
@@ -74,15 +89,8 @@ class BspLoggedReporter(client: bsp.BuildClient,
       params
     }
 
-  private[this] def getTragetId(problem: Problem, server: BuildServer with ScalaBuildServer):
-                                                                      Option[BuildTargetIdentifier] = {
-    problem.position().sourceFile().asScala match {
-      case Some(file) => Option(
-                                server.buildTargetInverseSources(
-                                new InverseSourcesParams(new TextDocumentIdentifier(file.toURI.toString))
-                                ).get.getTargets.asScala.head)
-      case None => Option.empty[BuildTargetIdentifier]
-    }
+  private[this] def getStatusCode: StatusCode = {
+    if (errors > 0) StatusCode.ERROR else StatusCode.OK
   }
 
   private[this] def getErrorCode(file: Option[File], start: bsp.Position, end: bsp.Position, position: xsbti.Position): String = {
diff --git a/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala b/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
index 3937f1ab..e87768a6 100644
--- a/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
@@ -238,12 +238,23 @@ class MillBuildServer(evaluator: Evaluator,
       l
   }
 
-  private[this] def getBspLoggedReporterPool(params: Parameters): Int => Option[ManagedLoggedReporter] = {
+  private[this] def getBspLoggedReporterPool(params: Parameters, taskStartMessage: String => String,
+                                             taskStartDataKind: String, taskStartData: BuildTargetIdentifier => Object):
+                                                                Int => Option[ManagedLoggedReporter] = {
     (int: Int) =>
+      val targetId = moduleCodeToTargetId(int)
+      val taskId = new TaskId(targetIdToModule(targetId).compile.hashCode.toString)
       if (moduleCodeToTargetId.contains(int)) {
         println("Module: " + int)
+        val taskStartParams = new TaskStartParams(taskId)
+        taskStartParams.setEventTime(System.currentTimeMillis())
+        taskStartParams.setData(taskStartData(targetId))
+        taskStartParams.setDataKind(taskStartDataKind)
+        taskStartParams.setMessage(taskStartMessage(moduleToTarget(targetIdToModule(targetId)).getDisplayName))
+        client.onBuildTaskStart(taskStartParams)
         Option(new BspLoggedReporter(client,
-          moduleCodeToTargetId(int),
+          targetId,
+          taskId,
           params.getOriginId,
           10, getCompilationLogger))}
       else Option.empty[ManagedLoggedReporter]
@@ -257,9 +268,9 @@ class MillBuildServer(evaluator: Evaluator,
       val params = TaskParameters.fromCompileParams(compileParams)
       val taskId = params.hashCode()
       val compileTasks = Strict.Agg(params.getTargets.map(targetId => targetIdToModule(targetId).compile):_*)
-
       val result = millEvaluator.evaluate(compileTasks,
-                    getBspLoggedReporterPool(params),
+                    getBspLoggedReporterPool(params, (t) => s"Started compiling target: $t",
+                    "compile-task", (targetId: BuildTargetIdentifier) => new CompileTask(targetId)),
                     new BspContext {
                       override def args: Seq[String] = params.getArguments.getOrElse(Seq.empty[String])
                       override def logStart(event: Event): Unit = {}
@@ -282,7 +293,8 @@ class MillBuildServer(evaluator: Evaluator,
         val args = params.getArguments.getOrElse(Seq.empty[String])
         val runTask = module.run(args.mkString(" "))
         val runResult = millEvaluator.evaluate(Strict.Agg(runTask),
-                        getBspLoggedReporterPool(params),
+                            getBspLoggedReporterPool(params, (t) => s"Started compiling target: $t",
+                    "compile-task", (targetId: BuildTargetIdentifier) => new CompileTask(targetId)),
                         logger = new MillBspLogger(client, runTask.hashCode(), millEvaluator.log))
         if (runResult.failing.keyCount > 0) {
           new RunResult(StatusCode.ERROR)
@@ -341,7 +353,8 @@ class MillBuildServer(evaluator: Evaluator,
 
             val results = millEvaluator.evaluate(
               Strict.Agg(testTask),
-              getBspLoggedReporterPool(params),
+              getBspLoggedReporterPool(params, (t) => s"Started compiling target: $t",
+                "compile-task", (targetId: BuildTargetIdentifier) => new CompileTask(targetId)),
               bspContext,
               new MillBspLogger(client, testTask.hashCode, millEvaluator.log))
             val endTime = System.currentTimeMillis()
diff --git a/contrib/bsp/src/mill/contrib/bsp/ModuleUtils.scala b/contrib/bsp/src/mill/contrib/bsp/ModuleUtils.scala
index 2ce3cb91..9a50f22f 100644
--- a/contrib/bsp/src/mill/contrib/bsp/ModuleUtils.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/ModuleUtils.scala
@@ -37,9 +37,9 @@ object ModuleUtils {
       for ( module <- modules ) {
         val dataBuildTarget = computeScalaBuildTarget(module, evaluator)
         val capabilities = getModuleCapabilities(module, evaluator)
-        val buildTargetTag: String = module match {
-          case m: TestModule => BuildTargetTag.TEST
-          case m: JavaModule => "-"
+        val buildTargetTag: List[String] = module match {
+          case m: TestModule => List(BuildTargetTag.TEST)
+          case m: JavaModule => List(BuildTargetTag.LIBRARY, BuildTargetTag.APPLICATION)
         }
 
         val dependencies = module match {
@@ -47,7 +47,7 @@ object ModuleUtils {
         }
 
         val buildTarget = new BuildTarget(moduleIdMap(module),
-          Collections.singletonList(buildTargetTag),
+          buildTargetTag.asJava,
           supportedLanguages.asJava,
           dependencies,
           capabilities)