Remove the dependency to bsp and zinc from core modules

15 files changed, 197 insertions, 162 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 _ =>
diff --git a/main/api/src/mill/api/BspCompileArguments.scala b/main/api/src/mill/api/BspCompileArguments.scala
deleted file mode 100644
index 73586cc8..00000000
--- a/main/api/src/mill/api/BspCompileArguments.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-package mill.api
-
-/**
-  * Data structure to represent Bsp client-specified
-  * compilation arguments
-  */
-class BspCompileArguments {
-  var arguments: Seq[String] = Seq.empty[String]
-
-  /**
-    * Return the compilation arguments specified by the
-    * Bsp client, which may or may not be found in the
-    * compiler options of any module from the build file.
-    */
-  def args: Seq[String] = {
-    arguments
-  }
-}
diff --git a/main/api/src/mill/api/BspContext.scala b/main/api/src/mill/api/BspContext.scala
deleted file mode 100644
index 1281518d..00000000
--- a/main/api/src/mill/api/BspContext.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-package mill.api
-
-import sbt.testing.Event
-
-/**
-  * Bsp Context with functionality for retrieving compile
-  * arguments provided by a Bsp client, as well as for logging
-  * the start and finish of a task triggered by the request of
-  * a Bsp client. Can be integrated into mill's Ctx to inject
-  * Bsp functionality into tasks like compile/run/test.
-  */
-trait BspContext extends BspCompileArguments with TestReporter
-
-/**
-  * Dummy Bsp Context that does nothing
-  * upon starting or finishing a task, and
-  * contains no client-specified compilation
-  * arguments
-  */
-object DummyBspContext extends BspContext {
-  override def args = Seq.empty[String]
-
-  override def logStart(event:  Event): Unit = {
-
-  }
-
-  override def logFinish(event:  Event): Unit = {
-
-  }
-}
\ No newline at end of file
diff --git a/main/api/src/mill/api/Ctx.scala b/main/api/src/mill/api/Ctx.scala
index 02d50b22..96da84eb 100644
--- a/main/api/src/mill/api/Ctx.scala
+++ b/main/api/src/mill/api/Ctx.scala
@@ -3,7 +3,6 @@ package mill.api
 import scala.annotation.{StaticAnnotation, compileTimeOnly}
 import scala.language.implicitConversions
 import os.Path
-import sbt.internal.inc.ManagedLoggedReporter
 
 /**
  * Provides access to various resources in the context of a currently execution Target.
@@ -56,13 +55,13 @@ object Ctx {
 
 
 class Ctx(
-  val args: IndexedSeq[_],
-  dest0: () => os.Path,
-  val log: Logger,
-  val home: os.Path,
-  val env: Map[String, String],
-  val reporter: Int => Option[ManagedLoggedReporter],
-  val bsp: BspContext
+           val args: IndexedSeq[_],
+           dest0: () => os.Path,
+           val log: Logger,
+           val home: os.Path,
+           val env: Map[String, String],
+           val reporter: Int => Option[BuildProblemReporter],
+           val testReporter: TestReporter
 )
   extends Ctx.Dest
   with Ctx.Log
diff --git a/main/api/src/mill/api/TestReporter.scala b/main/api/src/mill/api/TestReporter.scala
index 97dec761..8adea687 100644
--- a/main/api/src/mill/api/TestReporter.scala
+++ b/main/api/src/mill/api/TestReporter.scala
@@ -1,5 +1,7 @@
 package mill.api
 
+import java.io.File
+
 import sbt.testing._
 
 /**
@@ -20,12 +22,66 @@ trait TestReporter {
   * Dummy Test Reporter that doesn't report
   * anything for any testing event.
   */
-object  DummyReporter extends TestReporter {
+object  DummyTestReporter extends TestReporter {
   override def logStart(event:  Event): Unit = {
 
   }
-
   override def logFinish(event:  Event): Unit = {
 
   }
 }
+
+trait BuildProblemReporter {
+  def logError(problem: Problem): Unit
+
+  def logWarning(problem: Problem): Unit
+
+  def logInfo(problem: Problem): Unit
+
+  def printSummary(): Unit
+}
+
+trait ProblemPosition {
+  def line: Option[Int]
+
+  def lineContent: String
+
+  def offset: Option[Int]
+
+  def pointer: Option[Int]
+
+  def pointerSpace: Option[String]
+
+  def sourcePath: Option[String]
+
+  def sourceFile: Option[File]
+
+  def startOffset: Option[Int] = Option.empty
+
+  def endOffset: Option[Int] = Option.empty
+
+  def startLine: Option[Int] = Option.empty
+
+  def startColumn: Option[Int] = Option.empty
+
+  def endLine: Option[Int] = Option.empty
+
+  def endColumn: Option[Int] = Option.empty
+}
+
+sealed trait Severity
+case object Info extends Severity
+case object Error extends Severity
+case object Warn extends Severity
+
+trait Problem {
+  def category: String
+
+  def severity: Severity
+
+  def message: String
+
+  def position: ProblemPosition
+}
+
+
diff --git a/main/core/src/eval/Evaluator.scala b/main/core/src/eval/Evaluator.scala
index 75103398..37de69b3 100644
--- a/main/core/src/eval/Evaluator.scala
+++ b/main/core/src/eval/Evaluator.scala
@@ -2,21 +2,18 @@ package mill.eval
 
 import java.net.URLClassLoader
 
-import scala.collection.JavaConverters._
-import scala.collection.mutable
-import scala.util.control.NonFatal
 import ammonite.runtime.SpecialClassLoader
-import mill.api.{BspContext, DummyBspContext}
-import mill.util.Router.EntryPoint
-import mill.define.{Ctx => _, _}
 import mill.api.Result.{Aborted, OuterStack, Success}
+import mill.api.Strict.Agg
+import mill.api.{DummyTestReporter, TestReporter, BuildProblemReporter}
+import mill.define.{Ctx => _, _}
 import mill.util
+import mill.util.Router.EntryPoint
 import mill.util._
-import mill.api.Strict.Agg
-import sbt.internal.inc.{CompilerArguments, ManagedLoggedReporter}
-import sbt.internal.util.{ConsoleOut, MainAppender}
-import sbt.testing.Event
-import sbt.util.LogExchange
+
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+import scala.util.control.NonFatal
 
 case class Labelled[T](task: NamedTask[T],
                        segments: Segments){
@@ -45,8 +42,8 @@ case class Evaluator(home: os.Path,
   val classLoaderSignHash = classLoaderSig.hashCode()
 
   def evaluate(goals: Agg[Task[_]],
-               reporter: Int => Option[ManagedLoggedReporter] = (int: Int) => Option.empty[ManagedLoggedReporter],
-               bspContext: BspContext = DummyBspContext,
+               reporter: Int => Option[BuildProblemReporter] = (int: Int) => Option.empty[BuildProblemReporter],
+               testReporter: TestReporter = DummyTestReporter,
                logger: Logger = log): Evaluator.Results = {
     os.makeDir.all(outPath)
     val (sortedGroups, transitive) = Evaluator.plan(rootModule, goals)
@@ -74,7 +71,7 @@ case class Evaluator(home: os.Path,
         results,
         counterMsg,
         reporter,
-        bspContext,
+        testReporter,
         logger
       )
       someTaskFailed = someTaskFailed || newResults.exists(task => !task._2.isInstanceOf[Success[_]])
@@ -121,8 +118,8 @@ case class Evaluator(home: os.Path,
                           group: Agg[Task[_]],
                           results: collection.Map[Task[_], Result[(Any, Int)]],
                           counterMsg: String,
-                          reporter: Int => Option[ManagedLoggedReporter],
-                          bspContext: BspContext,
+                          zincProblemReporter: Int => Option[BuildProblemReporter],
+                          testReporter: TestReporter,
                           logger: Logger
                          ): (collection.Map[Task[_], Result[(Any, Int)]], Seq[Task[_]], Boolean) = {
 
@@ -146,8 +143,8 @@ case class Evaluator(home: os.Path,
           paths = None,
           maybeTargetLabel = None,
           counterMsg = counterMsg,
-          reporter,
-          bspContext,
+          zincProblemReporter,
+          testReporter,
           logger
         )
         (newResults, newEvaluated, false)
@@ -201,8 +198,8 @@ case class Evaluator(home: os.Path,
               paths = Some(paths),
               maybeTargetLabel = Some(msgParts.mkString),
               counterMsg = counterMsg,
-              reporter,
-              bspContext,
+              zincProblemReporter,
+              testReporter,
               logger
             )
 
@@ -278,8 +275,8 @@ case class Evaluator(home: os.Path,
                     paths: Option[Evaluator.Paths],
                     maybeTargetLabel: Option[String],
                     counterMsg: String,
-                    reporter: Int => Option[ManagedLoggedReporter],
-                    bspContext: BspContext,
+                    reporter: Int => Option[BuildProblemReporter],
+                    testReporter: TestReporter,
                     logger: Logger): (mutable.LinkedHashMap[Task[_], Result[(Any, Int)]], mutable.Buffer[Task[_]]) = {
 
 
@@ -342,7 +339,7 @@ case class Evaluator(home: os.Path,
             home,
             env,
             reporter,
-            bspContext
+            testReporter
           )
 
           val out = System.out
diff --git a/scalajslib/src/ScalaJSModule.scala b/scalajslib/src/ScalaJSModule.scala
index d970cc11..741ab29e 100644
--- a/scalajslib/src/ScalaJSModule.scala
+++ b/scalajslib/src/ScalaJSModule.scala
@@ -196,7 +196,7 @@ trait TestScalaJSModule extends ScalaJSModule with TestModule {
         runClasspath().map(_.path),
         Agg(compile().classes.path),
         args,
-        T.ctx.bsp
+        T.ctx.testReporter
       )
     val res = TestModule.handleResults(doneMsg, results)
     // Hack to try and let the Node.js subprocess finish streaming it's stdout
diff --git a/scalalib/api/src/ZincWorkerApi.scala b/scalalib/api/src/ZincWorkerApi.scala
index e80895d6..dfda44b8 100644
--- a/scalalib/api/src/ZincWorkerApi.scala
+++ b/scalalib/api/src/ZincWorkerApi.scala
@@ -1,9 +1,10 @@
 package mill.scalalib.api
 
 import mill.api.Loose.Agg
-import mill.api.PathRef
+import mill.api.{PathRef, BuildProblemReporter}
 import mill.api.JsonFormatters._
-import sbt.internal.inc._
+
+
 
 object ZincWorkerApi{
   type Ctx = mill.api.Ctx.Dest with mill.api.Ctx.Log with mill.api.Ctx.Home
@@ -14,7 +15,7 @@ trait ZincWorkerApi {
                   sources: Agg[os.Path],
                   compileClasspath: Agg[os.Path],
                   javacOptions: Seq[String],
-                  reporter: Option[ManagedLoggedReporter])
+                  reporter: Option[BuildProblemReporter])
                  (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[CompilationResult]
 
   /** Compile a mixed Scala/Java or Scala-only project */
@@ -27,7 +28,7 @@ trait ZincWorkerApi {
                    scalacOptions: Seq[String],
                    compilerClasspath: Agg[os.Path],
                    scalacPluginClasspath: Agg[os.Path],
-                   reporter: Option[ManagedLoggedReporter])
+                   reporter: Option[BuildProblemReporter])
                   (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[CompilationResult]
 
   def discoverMainClasses(compilationResult: CompilationResult)
diff --git a/scalalib/src/JavaModule.scala b/scalalib/src/JavaModule.scala
index 5405828f..051f6804 100644
--- a/scalalib/src/JavaModule.scala
+++ b/scalalib/src/JavaModule.scala
@@ -13,9 +13,6 @@ import mill.modules.Jvm.{createAssembly, createJar}
 import Lib._
 import mill.scalalib.publish.{Artifact, Scope}
 import mill.api.Loose.Agg
-import sbt.internal.inc.ManagedLoggedReporter
-import sbt.internal.util.{ConsoleOut, MainAppender}
-import sbt.util.LogExchange
 
 /**
   * Core configuration required to compile a single Scala compilation target
@@ -221,7 +218,7 @@ trait JavaModule extends mill.Module with TaskModule with GenIdeaModule { outer
       upstreamCompileOutput(),
       allSourceFiles().map(_.path),
       compileClasspath().map(_.path),
-      javacOptions() ++ T.ctx().bsp.args,
+      javacOptions(),
       T.ctx().reporter(hashCode)
     )
   }
@@ -613,7 +610,7 @@ trait TestModule extends JavaModule with TaskModule {
       runClasspath().map(_.path),
       Agg(compile().classes.path),
       args,
-      T.ctx().bsp
+      T.ctx().testReporter
     )
 
     TestModule.handleResults(doneMsg, results)
diff --git a/scalalib/src/ScalaModule.scala b/scalalib/src/ScalaModule.scala
index 5669ca8c..daf4adcc 100644
--- a/scalalib/src/ScalaModule.scala
+++ b/scalalib/src/ScalaModule.scala
@@ -10,9 +10,6 @@ import mill.scalalib.api.Util.isDotty
 import Lib._
 import mill.api.Loose.Agg
 import mill.api.DummyInputStream
-import sbt.internal.inc.ManagedLoggedReporter
-import sbt.internal.util.{ConsoleOut, MainAppender}
-import sbt.util.LogExchange
 
 /**
   * Core configuration required to compile a single Scala compilation target
@@ -140,7 +137,7 @@ trait ScalaModule extends JavaModule { outer =>
       javacOptions(),
       scalaVersion(),
       scalaOrganization(),
-      scalacOptions() ++ T.ctx.bsp.args,
+      scalacOptions(),
       scalaCompilerClasspath().map(_.path),
       scalacPluginClasspath().map(_.path),
       T.ctx().reporter(hashCode)
diff --git a/scalalib/src/TestRunner.scala b/scalalib/src/TestRunner.scala
index 2e6c2ba9..8d69723f 100644
--- a/scalalib/src/TestRunner.scala
+++ b/scalalib/src/TestRunner.scala
@@ -1,7 +1,7 @@
 package mill.scalalib
 import ammonite.util.Colors
 import mill.Agg
-import mill.api.{DummyReporter, TestReporter}
+import mill.api.{DummyTestReporter, TestReporter}
 import mill.modules.Jvm
 import mill.scalalib.Lib.discoverTests
 import mill.util.{Ctx, PrintLogger}
@@ -48,7 +48,7 @@ object TestRunner {
         entireClasspath = Agg.from(classpath.map(os.Path(_))),
         testClassfilePath = Agg(os.Path(testCp)),
         args = arguments,
-        DummyReporter
+        DummyTestReporter
       )(ctx)
 
       // Clear interrupted state in case some badly-behaved test suite
diff --git a/scalalib/worker/src/ZincWorkerImpl.scala b/scalalib/worker/src/ZincWorkerImpl.scala
index a1d632df..0f2cbf10 100644
--- a/scalalib/worker/src/ZincWorkerImpl.scala
+++ b/scalalib/worker/src/ZincWorkerImpl.scala
@@ -3,16 +3,17 @@ package mill.scalalib.worker
 import java.io.File
 import java.util.Optional
 
-import scala.ref.WeakReference
 import mill.api.Loose.Agg
-import mill.api.{KeyedLockedCache, PathRef}
-import xsbti.compile.{CompilerCache => _, FileAnalysisStore => _, ScalaInstance => _, _}
+import mill.api.{Info, KeyedLockedCache, PathRef, Problem, ProblemPosition, Severity, Warn, BuildProblemReporter}
 import mill.scalalib.api.Util.{grepJar, isDotty, scalaBinaryVersion}
+import mill.scalalib.api.{CompilationResult, ZincWorkerApi}
 import sbt.internal.inc._
 import sbt.internal.util.{ConsoleOut, MainAppender}
 import sbt.util.LogExchange
-import mill.scalalib.api.{CompilationResult, ZincWorkerApi}
-import upickle.core.Visitor
+import xsbti.compile.{CompilerCache => _, FileAnalysisStore => _, ScalaInstance => _, _}
+
+import scala.ref.WeakReference
+
 case class MockedLookup(am: File => Optional[CompileAnalysis]) extends PerClasspathEntryLookup {
   override def analysis(classpathEntry: File): Optional[CompileAnalysis] =
     am(classpathEntry)
@@ -21,6 +22,45 @@ case class MockedLookup(am: File => Optional[CompileAnalysis]) extends PerClassp
     Locate.definesClass(classpathEntry)
 }
 
+class ZincProblem(base: xsbti.Problem) extends Problem {
+  override def category: String = base.category()
+
+  override def severity: Severity = base.severity() match {
+    case xsbti.Severity.Info => mill.api.Info
+    case xsbti.Severity.Warn => mill.api.Warn
+    case xsbti.Severity.Error => mill.api.Error
+  }
+
+  override def message: String = base.message()
+
+  override def position: ProblemPosition = new ZincProblemPosition(base.position())
+}
+
+class ZincProblemPosition(base: xsbti.Position) extends ProblemPosition {
+
+  object JavaOptionConverter {
+    implicit def convertInt(x: Optional[Integer]): Option[Int] = if (x.isEmpty) None else Some(x.get().intValue())
+    implicit def convert[T](x: Optional[T]): Option[T] = if (x.isEmpty) None else Some(x.get())
+  }
+
+  import JavaOptionConverter._
+
+  override def line: Option[Int] = base.line()
+
+  override def lineContent: String = base.lineContent()
+
+  override def offset: Option[Int] = base.offset()
+
+  override def pointer: Option[Int] = base.pointer()
+
+  override def pointerSpace: Option[String] = base.pointerSpace()
+
+  override def sourcePath: Option[String] = base.sourcePath()
+
+  override def sourceFile: Option[File] = base.sourceFile()
+}
+
+
 class ZincWorkerImpl(compilerBridge: Either[
                        (ZincWorkerApi.Ctx, (String, String) => (Option[Array[os.Path]], os.Path)),
                        String => os.Path
@@ -156,7 +196,7 @@ class ZincWorkerImpl(compilerBridge: Either[
                   sources: Agg[os.Path],
                   compileClasspath: Agg[os.Path],
                   javacOptions: Seq[String],
-                  reporter: Option[ManagedLoggedReporter])
+                  reporter: Option[BuildProblemReporter])
                  (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[CompilationResult] = {
 
     for(res <- compileJava0(
@@ -171,7 +211,7 @@ class ZincWorkerImpl(compilerBridge: Either[
                    sources: Agg[os.Path],
                    compileClasspath: Agg[os.Path],
                    javacOptions: Seq[String],
-                   reporter: Option[ManagedLoggedReporter])
+                   reporter: Option[BuildProblemReporter])
                   (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[(os.Path, os.Path)] = {
     compileInternal(
       upstreamCompileOutput,
@@ -193,7 +233,7 @@ class ZincWorkerImpl(compilerBridge: Either[
                    scalacOptions: Seq[String],
                    compilerClasspath: Agg[os.Path],
                    scalacPluginClasspath: Agg[os.Path],
-                   reporter: Option[ManagedLoggedReporter])
+                   reporter: Option[BuildProblemReporter])
                   (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[CompilationResult] = {
 
     for (res <- compileMixed0(
@@ -219,7 +259,7 @@ class ZincWorkerImpl(compilerBridge: Either[
                     scalacOptions: Seq[String],
                     compilerClasspath: Agg[os.Path],
                     scalacPluginClasspath: Agg[os.Path],
-                    reporter: Option[ManagedLoggedReporter])
+                    reporter: Option[BuildProblemReporter])
                    (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[(os.Path, os.Path)] = {
     withCompilers(
       scalaVersion,
@@ -307,7 +347,7 @@ class ZincWorkerImpl(compilerBridge: Either[
                               javacOptions: Seq[String],
                               scalacOptions: Seq[String],
                               compilers: Compilers,
-                              reporter: Option[ManagedLoggedReporter])
+                              reporter: Option[BuildProblemReporter])
                              (implicit ctx: ZincWorkerApi.Ctx): mill.api.Result[(os.Path, os.Path)] = {
     os.makeDir.all(ctx.dest)
 
@@ -323,7 +363,22 @@ class ZincWorkerImpl(compilerBridge: Either[
     }
     val newReporter = reporter match {
       case None => new ManagedLoggedReporter(10, logger)
-      case r: Option[ManagedLoggedReporter] => r.get
+      case Some(r) => new ManagedLoggedReporter(10, logger) {
+        override def logError(problem: xsbti.Problem): Unit = {
+          r.logError(new ZincProblem(problem))
+          super.logError(problem)
+        }
+
+        override def logWarning(problem: xsbti.Problem): Unit = {
+          r.logWarning(new ZincProblem(problem))
+          super.logWarning(problem)
+        }
+
+        override def logInfo(problem: xsbti.Problem): Unit = {
+          r.logInfo(new ZincProblem(problem))
+          super.logInfo(problem)
+        }
+      }
     }
     val analysisMap0 = upstreamCompileOutput.map(_.swap).toMap
 
diff --git a/scalanativelib/src/ScalaNativeModule.scala b/scalanativelib/src/ScalaNativeModule.scala
index 933e35fc..389d1b6a 100644
--- a/scalanativelib/src/ScalaNativeModule.scala
+++ b/scalanativelib/src/ScalaNativeModule.scala
@@ -189,7 +189,7 @@ trait TestScalaNativeModule extends ScalaNativeModule with TestModule { testOute
       runClasspath().map(_.path),
       Agg(compile().classes.path),
       args,
-      T.ctx.bsp
+      T.ctx.testReporter
     )
 
     TestModule.handleResults(doneMsg, results)