Merge pull request scalacenter#1704 from Duhemm/implement-inverse-sources

Implement buildTarget/inverseSources BSP endpoint

Author: tgodzik

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

@@ -101,6 +101,7 @@ final class BloopBspServices(
     .notificationAsync(endpoints.Build.exit)(p => exit(p))
     .requestAsync(endpoints.Workspace.buildTargets)(p => schedule(buildTargets(p)))
     .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.scalacOptions)(p => schedule(scalacOptions(p)))
     .requestAsync(endpoints.BuildTarget.javacOptions)(p => schedule(javacOptions(p)))
@@ -1070,6 +1071,23 @@ final class BloopBspServices(
     }
   }
 
+  def inverseSources(request: bsp.InverseSourcesParams): BspEndpointResponse[bsp.InverseSourcesResult] = {
+    def matchesSources(document: Path, project: Project): Boolean =
+      project.sources.exists(src => document.startsWith(src.underlying))
+    def matchesGlobs(document: Path, project: Project): Boolean =
+      project.sourcesGlobs.exists(glob => glob.matches(document))
+    val document = AbsolutePath(request.textDocument.uri.toPath).underlying
+    ifInitialized(None) { (state: State, logger: BspServerLogger) => 
+      val matchingProjects = state.build.loadedProjects.filter { loadedProject =>
+        val project = loadedProject.project
+        matchesSources(document, project) || matchesGlobs(document, project)
+      }.map { loadedProject =>
+        bsp.BuildTargetIdentifier(loadedProject.project.bspUri)
+      }
+      Task.now((state, Right(bsp.InverseSourcesResult(matchingProjects))))
+    }
+  }
+
   def resources(
       request: bsp.ResourcesParams
   ): BspEndpointResponse[bsp.ResourcesResult] = {

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

@@ -290,6 +290,19 @@ abstract class BspBaseSuite extends BaseSuite with BspClientTest {
       TestUtil.await(FiniteDuration(5, "s"))(dependencySourcesTask)
     }
 
+    def requestInverseSources(document: AbsolutePath): bsp.InverseSourcesResult = {
+      val inverseSourcesTask = {
+        endpoints.BuildTarget.inverseSources
+          .request(bsp.InverseSourcesParams(bsp.TextDocumentIdentifier(bsp.Uri(document.toBspUri))))
+          .map {
+            case Left(error) => fail(s"Received error ${error}")
+            case Right(targets) => targets
+          }
+      }
+
+      TestUtil.await(FiniteDuration(5, "s"))(inverseSourcesTask)
+    }
+
     import bloop.cli.ExitStatus
     def toBspStatus(status: ExitStatus): bsp.StatusCode = {
       status match {

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

@@ -540,4 +540,32 @@ class BspProtocolSpec(
     }
   }
 
+  test("inverse sources 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 checkInverseSources(project: TestProject): Unit = {
+          project.sources.foreach { source =>
+            val inverseSourcesResult = build.state.requestInverseSources(source)
+            assert(inverseSourcesResult.targets.contains(project.bspId))
+          }
+        }
+
+        checkInverseSources(mainProject)
+        checkInverseSources(testProject)
+        checkInverseSources(mainJsProject)
+        checkInverseSources(testJsProject)
+        checkInverseSources(rootMain)
+        checkInverseSources(rootTest)
+      }
+    }
+  }
+
 }

frontend/src/test/scala/bloop/util/TestProject.scala

@@ -24,8 +24,8 @@ final case class TestProject(
     deps: Option[List[TestProject]]
 ) {
   def baseDir: AbsolutePath = AbsolutePath(config.directory)
+  def sources: List[AbsolutePath] = config.sources.map(AbsolutePath(_))
   def srcFor(relPath: String, exists: Boolean = true): AbsolutePath = {
-    val sources = config.sources.map(AbsolutePath(_))
     if (exists) TestProject.srcFor(sources, relPath)
     else {
       val targetPath = RelativePath(relPath.stripPrefix(java.io.File.separator))