Remove the dependency to bsp and zinc from core modules

3 files changed, 34 insertions, 53 deletions

diff --git a/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala b/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
index ba42a67a..b4f0260d 100644
--- a/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/BspLoggedReporter.scala
@@ -1,17 +1,16 @@
 package mill.contrib.bsp
 
 import java.io.File
-import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
 import ch.epfl.scala.bsp4j._
 import ch.epfl.scala.{bsp4j => bsp}
-import sbt.internal.inc.ManagedLoggedReporter
-import sbt.internal.util.ManagedLogger
-import xsbti.{Problem, Severity}
+import mill.api.{Info, Problem, Warn, BuildProblemReporter}
+
 import scala.collection.JavaConverters._
 import scala.collection.concurrent
-import scala.compat.java8.OptionConverters._
-
+import scala.language.implicitConversions
 
 /**
   * Specialized reporter that sends compilation diagnostics
@@ -27,16 +26,11 @@ import scala.compat.java8.OptionConverters._
   *                            the compilation request. Needs to be sent
   *                            back as part of the published diagnostics
   *                            as well as compile report
-  * @param maxErrors The maximum number of errors to be logged during the
-  *                  compilation of targetId
-  * @param logger    The logger that will log the messages for each Problem.
   */
 class BspLoggedReporter(client: bsp.BuildClient,
                         targetId: BuildTargetIdentifier,
                         taskId: TaskId,
-                        compilationOriginId: Option[String],
-                        maxErrors: Int,
-                        logger: ManagedLogger) extends ManagedLoggedReporter(maxErrors, logger) {
+                        compilationOriginId: Option[String]) extends BuildProblemReporter {
 
   var errors = new AtomicInteger(0)
   var warnings = new AtomicInteger(0)
@@ -47,19 +41,16 @@ class BspLoggedReporter(client: bsp.BuildClient,
   override def logError(problem: Problem): Unit = {
     client.onBuildPublishDiagnostics(getDiagnostics(problem, targetId, compilationOriginId))
     errors.incrementAndGet()
-    super.logError(problem)
   }
 
   override def logInfo(problem: Problem): Unit = {
     client.onBuildPublishDiagnostics(getDiagnostics(problem, targetId, compilationOriginId))
     infos.incrementAndGet()
-    super.logInfo(problem)
   }
 
   override def logWarning(problem: Problem): Unit = {
     client.onBuildPublishDiagnostics(getDiagnostics(problem, targetId, compilationOriginId))
     warnings.incrementAndGet()
-    super.logWarning(problem)
   }
 
   override def printSummary(): Unit = {
@@ -85,7 +76,7 @@ class BspLoggedReporter(client: bsp.BuildClient,
   private[this] def getDiagnostics(problem: Problem, targetId: bsp.BuildTargetIdentifier, originId: Option[String]):
                                                                                     bsp.PublishDiagnosticsParams = {
       val diagnostic = getSingleDiagnostic(problem)
-      val sourceFile = problem.position().sourceFile().asScala
+      val sourceFile = problem.position.sourceFile
       val textDocument = new TextDocumentIdentifier(
         sourceFile.getOrElse(None) match {
         case None => targetId.getUri
@@ -120,20 +111,22 @@ class BspLoggedReporter(client: bsp.BuildClient,
 
   // Computes the diagnostic related to the given Problem
   private[this] def getSingleDiagnostic(problem: Problem): Diagnostic ={
-
+    val pos = problem.position
+    val i: Integer = pos.startLine.orElse(pos.line).getOrElse[Int](0)
+    println(i)
     val start = new bsp.Position(
-      problem.position.startLine.asScala.getOrElse(problem.position.line.asScala.getOrElse(0)),
-      problem.position.startOffset.asScala.getOrElse(problem.position.offset.asScala.getOrElse(0)))
+      pos.startLine.orElse(pos.line).getOrElse[Int](0),
+      pos.startOffset.orElse(pos.offset).getOrElse[Int](0))
     val end = new bsp.Position(
-      problem.position.endLine.asScala.getOrElse(problem.position.line.asScala.getOrElse(start.getLine)),
-      problem.position.endOffset.asScala.getOrElse(problem.position.offset.asScala.getOrElse(start.getCharacter)))
+      pos.endLine.orElse(pos.line).getOrElse[Int](start.getLine.intValue()),
+      pos.endOffset.orElse(pos.offset).getOrElse[Int](start.getCharacter.intValue()))
     val diagnostic = new bsp.Diagnostic(new bsp.Range(start, end), problem.message)
-    diagnostic.setCode(problem.position.lineContent)
+    diagnostic.setCode(pos.lineContent)
     diagnostic.setSource("compiler from mill")
     diagnostic.setSeverity( problem.severity match  {
-      case Severity.Info => bsp.DiagnosticSeverity.INFORMATION
-      case Severity.Error => bsp.DiagnosticSeverity.ERROR
-      case Severity.Warn => bsp.DiagnosticSeverity.WARNING
+      case mill.api.Info => bsp.DiagnosticSeverity.INFORMATION
+      case mill.api.Error => bsp.DiagnosticSeverity.ERROR
+      case mill.api.Warn => bsp.DiagnosticSeverity.WARNING
     }
     )
     diagnostic
diff --git a/contrib/bsp/src/mill/contrib/bsp/BspTestReporter.scala b/contrib/bsp/src/mill/contrib/bsp/BspTestReporter.scala
index 05e58ec7..9681313a 100644
--- a/contrib/bsp/src/mill/contrib/bsp/BspTestReporter.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/BspTestReporter.scala
@@ -3,7 +3,7 @@ package mill.contrib.bsp
 import java.io.{PrintWriter, StringWriter}
 
 import ch.epfl.scala.bsp4j._
-import mill.api.BspContext
+import mill.api.TestReporter
 import sbt.testing._
 
 
@@ -24,7 +24,7 @@ class BspTestReporter(
                        client: BuildClient,
                        targetId: BuildTargetIdentifier,
                        taskId: TaskId,
-                       arguments: Seq[String]) extends BspContext {
+                       arguments: Seq[String]) extends TestReporter {
 
   var passed = 0
   var failed = 0
@@ -33,8 +33,6 @@ class BspTestReporter(
   var skipped = 0
   var totalTime: Long = 0
 
-  override def args: Seq[String] = arguments
-
   override def logStart(event: Event): Unit = {
     val taskStartParams = new TaskStartParams(taskId)
     taskStartParams.setEventTime(System.currentTimeMillis())
diff --git a/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala b/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
index 9557586e..40e98ef7 100644
--- a/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
+++ b/contrib/bsp/src/mill/contrib/bsp/MillBuildServer.scala
@@ -1,31 +1,27 @@
 package mill.contrib.bsp
 
-import sbt.testing._
 import java.util.concurrent.CompletableFuture
 
-import mill.scalalib.Lib.discoverTests
 import ch.epfl.scala.bsp4j._
 import com.google.gson.JsonObject
 import mill.api.Result.{Skipped, Success}
-import mill.{scalalib, _}
-import mill.api.{BspContext, Result, Strict}
+import mill.api.{DummyTestReporter, Result, Strict, BuildProblemReporter}
 import mill.contrib.bsp.ModuleUtils._
 import mill.define.Segment.Label
+import mill.define.{Discover, ExternalModule}
 import mill.eval.Evaluator
+import mill.main.{EvaluatorScopt, MainModule}
+import mill.modules.Jvm
+import mill.scalalib.Lib.discoverTests
 import mill.scalalib._
 import mill.scalalib.api.CompilationResult
-import sbt.internal.inc._
-
-import scala.collection.JavaConverters._
-import mill.modules.Jvm
 import mill.util.{Ctx, DummyLogger}
-import mill.define.{Discover, ExternalModule}
-import mill.main.{EvaluatorScopt, MainModule}
+import mill.{scalalib, _}
 import os.Path
 import sbt.internal.util.{ConsoleOut, MainAppender, ManagedLogger}
 import sbt.util.LogExchange
 
-import scala.io.Source
+import scala.collection.JavaConverters._
 
 
 class MillBuildServer(evaluator: Evaluator,
@@ -215,7 +211,7 @@ class MillBuildServer(evaluator: Evaluator,
   // module's hash code TODO: find something more reliable than the hash code
   private[this] def getBspLoggedReporterPool(params: Parameters, taskStartMessage: String => String,
                                              taskStartDataKind: String, taskStartData: BuildTargetIdentifier => Object):
-                                                                Int => Option[ManagedLoggedReporter] = {
+                                                                Int => Option[BuildProblemReporter] = {
     int: Int =>
       if (moduleCodeToTargetId.contains(int)) {
         val targetId = moduleCodeToTargetId(int)
@@ -229,9 +225,8 @@ class MillBuildServer(evaluator: Evaluator,
         Option(new BspLoggedReporter(client,
           targetId,
           taskId,
-          params.getOriginId,
-          10, getCompilationLogger))}
-      else Option.empty[ManagedLoggedReporter]
+          params.getOriginId))}
+      else None
   }
 
   //TODO: if the client wants to give compilation arguments and the module
@@ -247,12 +242,7 @@ class MillBuildServer(evaluator: Evaluator,
       val result = millEvaluator.evaluate(compileTasks,
                     getBspLoggedReporterPool(params, t => s"Started compiling target: $t",
                       TaskDataKind.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 = {}
-
-                      override def logFinish(event: Event): Unit = {}
-                    },
+                    DummyTestReporter,
                     new MillBspLogger(client, taskId, millEvaluator.log)
       )
       val compileResult = new CompileResult(getStatusCode(result))
@@ -341,7 +331,7 @@ class MillBuildServer(evaluator: Evaluator,
             taskStartParams.setData(new TestTask(targetId))
             client.onBuildTaskStart(taskStartParams)
 
-            val bspContext = new BspTestReporter(
+            val testReporter = new BspTestReporter(
               client, targetId,
               new TaskId(testTask.hashCode().toString),
               Seq.empty[String])
@@ -350,7 +340,7 @@ class MillBuildServer(evaluator: Evaluator,
               Strict.Agg(testTask),
               getBspLoggedReporterPool(params, t => s"Started compiling target: $t",
                 TaskDataKind.COMPILE_TASK, (targetId: BuildTargetIdentifier) => new CompileTask(targetId)),
-              bspContext,
+              testReporter,
               new MillBspLogger(client, testTask.hashCode, millEvaluator.log))
             val endTime = System.currentTimeMillis()
             val statusCode = getStatusCode(results)
@@ -369,7 +359,7 @@ class MillBuildServer(evaluator: Evaluator,
             taskFinishParams.setMessage("Finished testing target: " +
               moduleToTarget(targetIdToModule(targetId)).getDisplayName)
             taskFinishParams.setDataKind(TaskDataKind.TEST_REPORT)
-            taskFinishParams.setData(bspContext.getTestReport)
+            taskFinishParams.setData(testReporter.getTestReport)
             client.onBuildTaskFinish(taskFinishParams)
 
           case _ =>