Implement BSP buildTarget/outputPaths

Author: jturcotte

frontend/src/main/scala/bloop/bsp/BloopBspServices.scala

@@ -130,6 +130,7 @@ final class BloopBspServices(
     .requestAsync(endpoints.BuildTarget.sources)(p => schedule(sources(p)))
     .requestAsync(endpoints.BuildTarget.inverseSources)(p => schedule(inverseSources(p)))
     .requestAsync(endpoints.BuildTarget.resources)(p => schedule(resources(p)))
+    .requestAsync(endpoints.BuildTarget.outputPaths)(p => schedule(outputPaths(p)))
     .requestAsync(endpoints.BuildTarget.scalacOptions)(p => schedule(scalacOptions(p)))
     .requestAsync(endpoints.BuildTarget.javacOptions)(p => schedule(javacOptions(p)))
     .requestAsync(endpoints.BuildTarget.compile)(p => schedule(compile(p)))
@@ -311,7 +312,7 @@ final class BloopBspServices(
               dependencySourcesProvider = Some(true),
               dependencyModulesProvider = Some(true),
               resourcesProvider = Some(true),
-              outputPathsProvider = None,
+              outputPathsProvider = Some(true),
               buildTargetChangedProvider = Some(false),
               jvmTestEnvironmentProvider = Some(true),
               jvmRunEnvironmentProvider = Some(true),
@@ -1204,6 +1205,39 @@ final class BloopBspServices(
     }
   }
 
+  def outputPaths(
+      request: bsp.OutputPathsParams
+  ): BspEndpointResponse[bsp.OutputPathsResult] = {
+    def outputPaths(
+        projects: Seq[ProjectMapping],
+        state: State
+    ): BspResult[bsp.OutputPathsResult] = {
+
+      val response = bsp.OutputPathsResult(
+        projects.iterator.map {
+          case (target, project) =>
+            val outputPathItems =
+              List(
+                bsp.OutputPathItem(bsp.Uri(project.out.toBspUri), bsp.OutputPathItemKind.Directory)
+              )
+            bsp.OutputPathsItem(target, outputPathItems)
+        }.toList
+      )
+
+      Task.now((state, Right(response)))
+    }
+
+    ifInitialized(None) { (state: State, logger: BspServerLogger) =>
+      mapToProjects(request.targets, state) match {
+        case Left(error) =>
+          // Log the mapping error to the user via a log event + an error status code
+          logger.error(error)
+          Task.now((state, Right(bsp.OutputPathsResult(Nil))))
+        case Right(mappings) => outputPaths(mappings, state)
+      }
+    }
+  }
+
   def dependencyModules(
       request: bsp.DependencyModulesParams
   ): BspEndpointResponse[bsp.DependencyModulesResult] = {

frontend/src/test/scala/bloop/bsp/BspBaseSuite.scala

@@ -349,6 +349,19 @@ abstract class BspBaseSuite extends BaseSuite with BspClientTest {
       TestUtil.await(FiniteDuration(5, "s"))(resourcesTask)
     }
 
+    def requestOutputPaths(project: TestProject): bsp.OutputPathsResult = {
+      val outputPathsTask = {
+        client0
+          .request(endpoints.BuildTarget.outputPaths, bsp.OutputPathsParams(List(project.bspId)))
+          .map {
+            case RpcFailure(_, error) => fail(s"Received error ${error}")
+            case RpcSuccess(resources, _) => resources
+          }
+      }
+
+      TestUtil.await(FiniteDuration(5, "s"))(outputPathsTask)
+    }
+
     def requestDependencyModules(project: TestProject): bsp.DependencyModulesResult = {
       val dependencyModulesTask = {
         client0

frontend/src/test/scala/bloop/bsp/BspProtocolSpec.scala

@@ -516,6 +516,37 @@ class BspProtocolSpec(
     }
   }
 
+  test("outputPaths request works") {
+    TestUtil.withinWorkspace { workspace =>
+      val logger = new RecordingLogger(ansiCodesSupported = false)
+      loadBspBuildFromResources("cross-test-build-scalajs-0.6", workspace, logger) { build =>
+        val mainProject = build.projectFor("test-project")
+        val testProject = build.projectFor("test-project-test")
+        val mainJsProject = build.projectFor("test-projectJS")
+        val testJsProject = build.projectFor("test-projectJS-test")
+        val rootMain = build.projectFor("cross-test-build-scalajs-0-6")
+        val rootTest = build.projectFor("cross-test-build-scalajs-0-6-test")
+
+        def checkOutputPaths(project: TestProject): Unit = {
+          val outputPathsResult = build.state.requestOutputPaths(project)
+          assert(outputPathsResult.items.size == 1)
+          val outputPathsItem = outputPathsResult.items.head
+          assert(outputPathsItem.target == project.bspId)
+          val outputPaths = outputPathsItem.outputPaths.map(_.uri.toPath)
+          val expectedOutputPaths = List(project.config.out.toAbsolutePath())
+          assert(outputPaths == expectedOutputPaths)
+        }
+
+        checkOutputPaths(mainProject)
+        checkOutputPaths(testProject)
+        checkOutputPaths(mainJsProject)
+        checkOutputPaths(testJsProject)
+        checkOutputPaths(rootMain)
+        checkOutputPaths(rootTest)
+      }
+    }
+  }
+
   test("dependency modules request works") {
     TestUtil.withinWorkspace { workspace =>
       val logger = new RecordingLogger(ansiCodesSupported = false)

frontend/src/test/scala/bloop/bsp/TestConstants.scala

@@ -18,6 +18,7 @@ object TestConstants {
         "dependencySourcesProvider": true,
         "dependencyModulesProvider": true,
         "resourcesProvider": true,
+        "outputPathsProvider":true,
         "buildTargetChangedProvider": false,
         "jvmRunEnvironmentProvider": true,
         "jvmTestEnvironmentProvider": true,