Merge pull request #1397 from tpasternak/scalac-options-endpoint

Implement javacOptions endpoint

Author: tgodzik

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

@@ -8,7 +8,6 @@ import java.util.concurrent.atomic.AtomicInteger
 import java.nio.file.{FileSystems, Files, Path}
 import java.util.concurrent.ConcurrentHashMap
 import java.util.stream.Collectors
-
 import bloop.io.Environment.lineSeparator
 import bloop.io.ServerHandle
 import bloop.util.JavaRuntime
@@ -33,16 +32,15 @@ import ch.epfl.scala.bsp.{
   JvmEnvironmentItem,
   MessageType,
   ShowMessageParams,
+  Uri,
   endpoints
 }
-
 import scala.meta.jsonrpc.{JsonRpcClient, Response => JsonRpcResponse, Services => JsonRpcServices}
 import monix.eval.Task
 import monix.reactive.Observer
 import monix.execution.Scheduler
 import monix.execution.atomic.AtomicInt
 import monix.execution.atomic.AtomicBoolean
-
 import scala.collection.concurrent.TrieMap
 import scala.collection.mutable
 import scala.collection.JavaConverters._
@@ -108,6 +106,7 @@ final class BloopBspServices(
     .requestAsync(endpoints.BuildTarget.sources)(p => schedule(sources(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)))
     .requestAsync(endpoints.BuildTarget.compile)(p => schedule(compile(p)))
     .requestAsync(endpoints.BuildTarget.test)(p => schedule(test(p)))
     .requestAsync(endpoints.BuildTarget.run)(p => schedule(run(p)))
@@ -1118,32 +1117,39 @@ final class BloopBspServices(
     }
   }
 
+  private def getClasspath(state: State, project: Project): List[Uri] = {
+    val uris = mutable.Map.empty[Path, bsp.Uri]
+    val dag = state.build.getDagFor(project)
+    val fullClasspath = project.fullClasspath(dag, state.client)
+    val classpath =
+      fullClasspath.map(e => uris.getOrElseUpdate(e.underlying, bsp.Uri(e.toBspUri))).toList
+    classpath
+  }
+
+  private def getClassesDir(state: State, project: Project): bsp.Uri = {
+    bsp.Uri(state.client.getUniqueClassesDirFor(project, forceGeneration = true).toBspUri)
+  }
+
   def scalacOptions(
       request: bsp.ScalacOptionsParams
   ): BspEndpointResponse[bsp.ScalacOptionsResult] = {
     def scalacOptions(
         projects: Seq[ProjectMapping],
         state: State
     ): BspResult[bsp.ScalacOptionsResult] = {
-      val uris = mutable.Map.empty[Path, bsp.Uri]
       val response = bsp.ScalacOptionsResult(
         projects.iterator.map {
           case (target, project) =>
-            val dag = state.build.getDagFor(project)
-            val fullClasspath = project.fullClasspath(dag, state.client)
-            val classpath =
-              fullClasspath.map(e => uris.getOrElseUpdate(e.underlying, bsp.Uri(e.toBspUri))).toList
-            val classesDir =
-              state.client.getUniqueClassesDirFor(project, forceGeneration = true).toBspUri
+            val classpath = getClasspath(state, project)
+            val classesDir = getClassesDir(state, project)
             bsp.ScalacOptionsItem(
               target = target,
               options = project.scalacOptions.toList,
               classpath = classpath,
-              classDirectory = bsp.Uri(classesDir)
+              classDirectory = classesDir
             )
         }.toList
       )
-
       Task.now((state, Right(response)))
     }
 
@@ -1152,13 +1158,46 @@ final class BloopBspServices(
         case Left(error) =>
           // Log the mapping error to the user via a log event + an error status code
           logger.error(error)
-          // TODO(jvican): Add status code to scalac options result
           Task.now((state, Right(bsp.ScalacOptionsResult(Nil))))
         case Right(mappings) => scalacOptions(mappings, state)
       }
     }
   }
 
+  def javacOptions(
+      request: bsp.JavacOptionsParams
+  ): BspEndpointResponse[bsp.JavacOptionsResult] = {
+    def javacOptions(
+        projects: Seq[ProjectMapping],
+        state: State
+    ): BspResult[bsp.JavacOptionsResult] = {
+      val response = bsp.JavacOptionsResult(
+        projects.iterator.map {
+          case (target, project) =>
+            val classpath = getClasspath(state, project)
+            val classesDir = getClassesDir(state, project)
+            bsp.JavacOptionsItem(
+              target = target,
+              options = project.javacOptions.toList,
+              classpath = classpath,
+              classDirectory = classesDir
+            )
+        }.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.JavacOptionsResult(Nil))))
+        case Right(mappings) => javacOptions(mappings, state)
+      }
+    }
+  }
+
   val isShutdown = scala.concurrent.Promise[BspResponse[Unit]]()
   val isShutdownTask = Task.fromFuture(isShutdown.future).memoize
   def shutdown(shutdown: bsp.Shutdown): Unit = {

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

@@ -3,7 +3,6 @@ package bloop.bsp
 import java.net.URI
 import java.nio.file.Files
 import java.util.concurrent.{ConcurrentHashMap, ExecutionException, TimeUnit}
-
 import bloop.TestSchedulers
 import bloop.bsp.BloopBspDefinitions.BloopExtraBuildParams
 import bloop.cli.{BspProtocol, Commands}
@@ -15,15 +14,14 @@ import bloop.logging.{BspClientLogger, RecordingLogger}
 import bloop.testing.BaseSuite
 import bloop.util.{TestProject, TestUtil}
 import ch.epfl.scala.bsp
-import ch.epfl.scala.bsp.{JvmTestEnvironmentResult, Uri, endpoints}
+import ch.epfl.scala.bsp.{JvmTestEnvironmentResult, ScalacOptionsResult, Uri, endpoints}
 import io.circe.Json
 import monix.eval.Task
 import monix.execution.atomic.AtomicInt
 import monix.execution.{CancelableFuture, Scheduler}
 import monix.reactive.Observable
 import monix.execution.Scheduler
 import monix.reactive.subjects.ConcurrentSubject
-
 import scala.util.Try
 import scala.concurrent.Promise
 import scala.concurrent.duration.FiniteDuration
@@ -352,16 +350,9 @@ abstract class BspBaseSuite extends BaseSuite with BspClientTest {
       TestUtil.await(timeout)(session)
     }
 
-    def scalaOptions(project: TestProject): (ManagedBspTestState, bsp.ScalacOptionsResult) = {
-      val scalacOptionsTask = runAfterTargets(project) { target =>
-        endpoints.BuildTarget.scalacOptions.request(bsp.ScalacOptionsParams(List(target))).map {
-          case Left(error) => fail(s"Received error ${error}")
-          case Right(options) => options
-        }
-      }
-
+    def await[A](task: Task[A]) = {
       TestUtil.await(FiniteDuration(5, "s")) {
-        scalacOptionsTask.flatMap { result =>
+        task.flatMap { result =>
           serverStates.headL.map { state =>
             val latestServerState = new ManagedBspTestState(
               state,
@@ -378,6 +369,26 @@ abstract class BspBaseSuite extends BaseSuite with BspClientTest {
       }
     }
 
+    def scalaOptions(project: TestProject): (ManagedBspTestState, bsp.ScalacOptionsResult) = {
+      val scalacOptionsTask: Task[ScalacOptionsResult] = runAfterTargets(project) { target =>
+        endpoints.BuildTarget.scalacOptions.request(bsp.ScalacOptionsParams(List(target))).map {
+          case Left(error) => fail(s"Received error ${error}")
+          case Right(options) => options
+        }
+      }
+      await(scalacOptionsTask)
+    }
+
+    def javacOptions(project: TestProject): (ManagedBspTestState, bsp.JavacOptionsResult) = {
+      val javacOptionsTask = runAfterTargets(project) { target =>
+        endpoints.BuildTarget.javacOptions.request(bsp.JavacOptionsParams(List(target))).map {
+          case Left(error) => fail(s"Received error ${error}")
+          case Right(options) => options
+        }
+      }
+      await(javacOptionsTask)
+    }
+
     def jvmRunEnvironment(
         project: TestProject,
         originId: Option[String]

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

@@ -27,7 +27,7 @@ class BspProtocolSpec(
     override val protocol: BspProtocol
 ) extends BspBaseSuite {
   import ch.epfl.scala.bsp
-  test("check the correct contents of scalac options") {
+  test("check the correct contents of scalac/javac options") {
     TestUtil.withinWorkspace { workspace =>
       object Sources {
         val `A.scala` =
@@ -45,12 +45,17 @@ class BspProtocolSpec(
         val B = List("-Yprint-typer")
       }
 
+      object JavacOptions {
+        val A = List("-source", "9")
+      }
+
       val logger = new RecordingLogger(ansiCodesSupported = false)
       val `A` = TestProject(
         workspace,
         "a",
         List(Sources.`A.scala`),
-        scalacOptions = ScalacOptions.`A`
+        scalacOptions = ScalacOptions.`A`,
+        javacOptions = JavacOptions.A
       )
 
       val `B` = TestProject(
@@ -93,6 +98,9 @@ class BspProtocolSpec(
         assert(stateB.status == ExitStatus.Ok)
         val classesDirB = stateB.toTestState.getClientExternalDir(`B`).underlying
         testOptions(resultB, ScalacOptions.B, classesDirB, `B`.bspId, List(classesDirB))
+
+        val (_, javacResultA) = state.javacOptions(`A`)
+        assert(javacResultA.items.flatMap(_.options) == JavacOptions.A)
       }
     }
   }

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

@@ -98,6 +98,7 @@ abstract class BaseTestProject {
       strictDependencies: Boolean = false,
       enableTests: Boolean = false,
       scalacOptions: List[String] = Nil,
+      javacOptions: List[String] = Nil,
       scalaOrg: Option[String] = None,
       scalaCompiler: Option[String] = None,
       scalaVersion: Option[String] = None,
@@ -154,6 +155,8 @@ abstract class BaseTestProject {
       Some(setup)
     )
 
+    val javacConfig = Config.Java(javacOptions)
+
     val frameworks = if (enableTests) Config.TestFramework.DefaultFrameworks else Nil
     val testConfig = Config.Test(frameworks, Config.TestOptions.empty)
     val platform = Config.Platform.Jvm(
@@ -185,7 +188,7 @@ abstract class BaseTestProject {
       classes.underlying,
       resources = compileResourcesList,
       scala = Some(scalaConfig),
-      java = None,
+      java = Some(javacConfig),
       sbt = None,
       test = Some(testConfig),
       platform = Some(platform),