bugfix: Make sure proper runtime classpath is used when debugging

frontend/src/main/scala/bloop/dap/BloopDebuggee.scala

@@ -155,7 +155,7 @@ object BloopDebuggeeRunner {
                 modules,
                 libraries,
                 unmanagedEntries,
-                jvm.config,
+                jvm.runtimeConfig.getOrElse(jvm.config),
                 state,
                 ioScheduler,
                 project.scalaInstance.map(_.version)
@@ -184,8 +184,8 @@ object BloopDebuggeeRunner {
         val modules = getModules(dag, state.client)
         val libraries = getLibraries(dag)
         val unmanagedEntries = getUnmanagedEntries(project, dag, state.client, modules ++ libraries)
-        val Platform.Jvm(config, _, _, _, _, _) = project.platform
-        val javaRuntime = JavaRuntime(config.javaHome.underlying)
+        val Platform.Jvm(config, _, _, runtimeConfig, _, _) = project.platform
+        val javaRuntime = JavaRuntime(runtimeConfig.getOrElse(config).javaHome.underlying)
         Right(
           new TestSuiteDebugAdapter(
             projects,
@@ -229,8 +229,8 @@ object BloopDebuggeeRunner {
         val libraries = getLibraries(dag)
         val modules = getModules(dag, state.client)
         val unmanagedEntries = getUnmanagedEntries(project, dag, state.client, modules ++ libraries)
-        val Platform.Jvm(config, _, _, _, _, _) = project.platform
-        val javaRuntime = JavaRuntime(config.javaHome.underlying)
+        val Platform.Jvm(config, _, _, runtimeConfig, _, _) = project.platform
+        val javaRuntime = JavaRuntime(runtimeConfig.getOrElse(config).javaHome.underlying)
         new AttachRemoteDebugAdapter(
           modules,
           libraries,

frontend/src/test/scala/bloop/dap/DebugServerSpec.scala

@@ -7,24 +7,26 @@ import java.util.NoSuchElementException
 import java.util.concurrent.TimeUnit.MILLISECONDS
 import java.util.concurrent.TimeUnit.SECONDS
 
+import scala.collection.JavaConverters._
 import scala.collection.mutable
 import scala.concurrent.Future
 import scala.concurrent.Promise
 import scala.concurrent.TimeoutException
 import scala.concurrent.duration.Duration
 import scala.concurrent.duration.FiniteDuration
 
+import ch.epfl.scala.bsp
 import ch.epfl.scala.bsp.ScalaMainClass
 import ch.epfl.scala.debugadapter._
 
 import bloop.ScalaInstance
-import ch.epfl.scala.bsp
 import bloop.cli.ExitStatus
 import bloop.data.Platform
 import bloop.data.Project
 import bloop.engine.State
 import bloop.engine.tasks.RunMode
 import bloop.engine.tasks.Tasks
+import bloop.internal.build
 import bloop.internal.build.BuildTestInfo
 import bloop.io.AbsolutePath
 import bloop.io.Environment.lineSeparator
@@ -42,6 +44,8 @@ import bloop.util.TestUtil
 import com.microsoft.java.debug.core.protocol.Requests.SetBreakpointArguments
 import com.microsoft.java.debug.core.protocol.Types
 import com.microsoft.java.debug.core.protocol.Types.SourceBreakpoint
+import coursierapi.Dependency
+import coursierapi.Fetch
 import monix.execution.Ack
 import monix.reactive.Observer
 
@@ -202,6 +206,81 @@ object DebugServerSpec extends DebugBspBaseSuite {
     }
   }
 
+  testTask(
+    "runs-correct-runtime",
+    FiniteDuration(60, SECONDS)
+  ) {
+    TestUtil.withinWorkspace { workspace =>
+      val runtimeClasspath = Fetch
+        .create()
+        .addDependencies(
+          Dependency.of(
+            "ch.qos.logback",
+            "logback-classic",
+            "1.2.7"
+          ),
+          Dependency.of(
+            "org.scala-lang",
+            "scala-library",
+            build.BuildInfo.scalaVersion
+          )
+        )
+        .fetch()
+        .asScala
+        .map(_.toPath())
+        .toList
+
+      val main =
+        """|/main/scala/Main.scala
+           |object Main {
+           |  def main(args: Array[String]): Unit = {
+           |    println(s">>> hello world! <<<")
+           |    val cn = Class.forName("ch.qos.logback.classic.Logger")
+           |    println(s"$cn")
+           |  }
+           |}
+           |
+           |""".stripMargin
+
+      val logger = new RecordingLogger(ansiCodesSupported = false)
+      val project =
+        TestProject(workspace, "r", List(main), runtimeClasspath = Some(runtimeClasspath))
+
+      loadBspStateWithTask(workspace, List(project), logger) { state =>
+        val runner = mainRunner(
+          project,
+          state,
+          arguments = Nil,
+          jvmOptions = Nil,
+          environmentVariables = Nil
+        )
+
+        startDebugServer(runner) { server =>
+          for {
+            client <- server.startConnection
+            _ <- client.initialize()
+            _ <- client.launch(noDebug = true)
+            _ <- client.configurationDone()
+            _ <- client.exited
+            _ <- client.terminated
+            _ <- Task.fromFuture(client.closedPromise.future)
+            output <- client.takeCurrentOutput
+          } yield {
+            assert(client.socket.isClosed)
+            assertNoDiff(
+              output.linesIterator
+                .filterNot(_.contains("ERROR: JDWP Unable to get JNI 1.2 environment"))
+                .filterNot(_.contains("JDWP exit error AGENT_ERROR_NO_JNI_ENV"))
+                .mkString(lineSeparator),
+              """|>>> hello world! <<<
+                 |class ch.qos.logback.classic.Logger""".stripMargin
+            )
+          }
+        }
+      }
+    }
+  }
+
   testTask("supports scala and java breakpoints", FiniteDuration(60, SECONDS)) {
     TestUtil.withinWorkspace { workspace =>
       object Sources {

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

@@ -107,6 +107,7 @@ abstract class BaseTestProject {
       scalaVersion: Option[String] = None,
       resources: List[String] = Nil,
       runtimeResources: Option[List[String]] = None,
+      runtimeClasspath: Option[List[Path]] = None,
       jvmConfig: Option[Config.JvmConfig] = None,
       runtimeJvmConfig: Option[Config.JvmConfig] = None,
       order: Config.CompileOrder = Config.Mixed,
@@ -136,7 +137,7 @@ abstract class BaseTestProject {
       mkScalaInstance(finalScalaOrg, finalScalaCompiler, scalaVersion, jars.toList, NoopLogger)
 
     val allJars = instance.allJars.map(AbsolutePath.apply)
-    val (compileClasspath, runtimeClasspath) = {
+    val (compileClasspath, runtimeClasspathForStrict) = {
       val transitiveClasspath =
         (directDependencies.flatMap(classpathDeps) ++ allJars ++ jars).map(_.underlying)
       val directClasspath =
@@ -170,7 +171,7 @@ abstract class BaseTestProject {
       javaConfig,
       None,
       runtimeJvmConfig,
-      Some(runtimeClasspath),
+      runtimeClasspath.orElse(Some(runtimeClasspathForStrict)),
       runtimeResourcesList
     )