BSP: implement buildTarget/OutputPaths request

bsp/src/mill/bsp/BspCompileProblemReporter.scala

@@ -1,18 +1,17 @@
 package mill.bsp
 
-import java.io.File
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger}
-
 import ch.epfl.scala.bsp4j._
 import ch.epfl.scala.{bsp4j => bsp}
 import mill.api.{CompileProblemReporter, Problem}
-import scala.collection.JavaConverters._
+import os.Path
+
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger}
 import scala.collection.concurrent
+import scala.jdk.CollectionConverters._
 import scala.language.implicitConversions
 
-import os.Path
-
 /**
  * Specialized reporter that sends compilation diagnostics
  * for each problem it logs, either as information, warning or

bsp/src/mill/bsp/BspTestReporter.scala

@@ -1,10 +1,28 @@
 package mill.bsp
 
 import java.io.{PrintWriter, StringWriter}
-
-import ch.epfl.scala.bsp4j._
+import ch.epfl.scala.bsp4j.{
+  BuildClient,
+  BuildTargetIdentifier,
+  StatusCode,
+  TaskDataKind,
+  TaskFinishParams,
+  TaskId,
+  TaskStartParams,
+  TestFinish,
+  TestReport,
+  TestStart,
+  TestStatus
+}
 import mill.api.TestReporter
-import sbt.testing._
+import sbt.testing.{
+  Event,
+  NestedSuiteSelector,
+  NestedTestSelector,
+  SuiteSelector,
+  TestSelector,
+  TestWildcardSelector
+}
 
 /**
  * Context class for BSP, specialized for sending `task-start` and

bsp/src/mill/bsp/MillBuildServer.scala

@@ -26,6 +26,11 @@ import ch.epfl.scala.bsp4j.{
   InitializeBuildResult,
   InverseSourcesParams,
   InverseSourcesResult,
+  OutputPathItem,
+  OutputPathItemKind,
+  OutputPathsItem,
+  OutputPathsParams,
+  OutputPathsResult,
   ResourcesItem,
   ResourcesParams,
   ResourcesResult,
@@ -178,14 +183,6 @@ class MillBuildServer(
 
       // TODO: scan BspModules and infer their capabilities
 
-//      if (request.getRootUri != bspIdByModule(millBuildTarget).getUri) {
-//        log.debug(
-//          s"Workspace root differs from mill build root! Requested root: ${request.getRootUri} Mill root: ${millBuildTarget.buildTargetId.getUri}"
-//        )
-//      }
-
-//      val moduleBspInfo = bspModulesById.values.map(_.bspBuildTarget).toSeq
-
       val clientCaps = request.getCapabilities().getLanguageIds().asScala
 
 //      val compileLangs = moduleBspInfo.filter(_.canCompile).flatMap(_.languageIds).distinct.filter(
@@ -206,21 +203,20 @@ class MillBuildServer(
 
       val supportedLangs = Seq("java", "scala").asJava
       val capabilities = new BuildServerCapabilities
+
+      capabilities.setBuildTargetChangedProvider(false)
+      capabilities.setCanReload(canReload)
       capabilities.setCompileProvider(new CompileProvider(supportedLangs))
-      capabilities.setRunProvider(new RunProvider(supportedLangs))
-      capabilities.setTestProvider(new TestProvider(supportedLangs))
       capabilities.setDebugProvider(new DebugProvider(Seq().asJava))
-      capabilities.setDependencySourcesProvider(true)
-
       capabilities.setDependencyModulesProvider(true)
+      capabilities.setDependencySourcesProvider(true)
       capabilities.setInverseSourcesProvider(true)
-      capabilities.setResourcesProvider(true)
-      capabilities.setBuildTargetChangedProvider(
-        false
-      )
-      capabilities.setCanReload(canReload)
       capabilities.setJvmRunEnvironmentProvider(true)
       capabilities.setJvmTestEnvironmentProvider(true)
+      capabilities.setOutputPathsProvider(true)
+      capabilities.setResourcesProvider(true)
+      capabilities.setRunProvider(new RunProvider(supportedLangs))
+      capabilities.setTestProvider(new TestProvider(supportedLangs))
 
       request.getDisplayName match {
         case "IntelliJ-BSP" => clientIsIntelliJ = true
@@ -362,13 +358,6 @@ class MillBuildServer(
             sources.setRoots(Seq(sanitizeUri(evaluator.rootModule.millSourcePath)).asJava)
             sources
           }
-//        case (id, `millBuildTarget`) =>
-//          T.task {
-//            new SourcesItem(
-//              id,
-//              Seq(sourceItem(evaluator.rootModule.millSourcePath / "build.sc", false)).asJava
-//            )
-//          }
         case (id, module: JavaModule) =>
           T.task {
             val items = module.sources().map(p => sourceItem(p.path, false)) ++
@@ -412,13 +401,6 @@ class MillBuildServer(
         targetIds = p.getTargets.asScala.toSeq,
         agg = (items: Seq[DependencySourcesItem]) => new DependencySourcesResult(items.asJava)
       ) {
-//        case (id, `millBuildTarget`) =>
-//          T.task {
-//            new DependencySourcesItem(
-//              id,
-//              ModuleUtils.getMillBuildClasspath(evaluator, sources = true).asJava
-//            )
-//          }
         case (id, m: JavaModule) =>
           T.task {
             val sources = m.resolveDeps(
@@ -500,6 +482,36 @@ class MillBuildServer(
       compileResult // TODO: See in what form IntelliJ expects data about products of compilation in order to set data field
     }
 
+  override def buildTargetOutputPaths(params: OutputPathsParams)
+      : CompletableFuture[OutputPathsResult] =
+    completable(s"buildTargetOutputPaths ${params}") { state =>
+      import state._
+
+      val outItems = new OutputPathItem(
+        // Spec says, a directory must end with a forward slash
+        sanitizeUri.apply(evaluator.outPath) + "/",
+        OutputPathItemKind.DIRECTORY
+      )
+
+      val extItems = new OutputPathItem(
+        // Spec says, a directory must end with a forward slash
+        sanitizeUri.apply(evaluator.externalOutPath) + "/",
+        OutputPathItemKind.DIRECTORY
+      )
+
+      val items = for {
+        target <- params.getTargets.asScala
+        module <- bspModulesById.get(target)
+      } yield {
+        val items =
+          if (module.millOuterCtx.external) List(extItems)
+          else List(outItems)
+        new OutputPathsItem(target, items.asJava)
+      }
+
+      new OutputPathsResult(items.asJava)
+    }
+
   override def buildTargetRun(runParams: RunParams): CompletableFuture[RunResult] =
     completable(s"buildTargetRun ${runParams}") { state =>
       import state._

bsp/src/mill/bsp/TaskParameters.scala

@@ -2,7 +2,7 @@ package mill.bsp
 
 import ch.epfl.scala.bsp4j.{BuildTargetIdentifier, CompileParams, RunParams, TestParams}
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 
 /**
  * Common trait to represent BSP request parameters that

bsp/src/mill/bsp/Utils.scala

@@ -1,9 +1,8 @@
 package mill.bsp
 
 import ch.epfl.scala.bsp4j.{BuildClient, BuildTargetIdentifier, StatusCode, TaskId}
-import mill._
+import mill.api.CompileProblemReporter
 import mill.api.Result.{Skipped, Success}
-import mill.api.{CompileProblemReporter}
 import mill.eval.Evaluator
 import mill.scalalib.JavaModule
 import mill.scalalib.bsp.BspModule

build.sc

@@ -179,7 +179,7 @@ object Deps {
   val utest = ivy"com.lihaoyi::utest:0.7.11"
   val windowsAnsi = ivy"io.github.alexarchambault.windows-ansi:windows-ansi:0.0.4"
   val zinc = ivy"org.scala-sbt::zinc:1.8.0"
-  val bsp = ivy"ch.epfl.scala:bsp4j:2.1.0-M1"
+  val bsp = ivy"ch.epfl.scala:bsp4j:2.1.0-M3"
   val fansi = ivy"com.lihaoyi::fansi:0.4.0"
   val jarjarabrams = ivy"com.eed3si9n.jarjarabrams::jarjar-abrams-core:1.8.1"
   val requests = ivy"com.lihaoyi::requests:0.7.1"