Merge pull request #6875 from kpodsiad/backport/6858

[1.7.x] feat: implement BSP's environment requests

main/src/main/scala/sbt/Keys.scala

@@ -398,6 +398,7 @@ object Keys {
   val usePipelining = settingKey[Boolean]("Use subproject pipelining for compilation.").withRank(BSetting)
   val exportPipelining = settingKey[Boolean]("Product early output so downstream subprojects can do pipelining.").withRank(BSetting)
 
+  // BSP keys
   val bspConfig = taskKey[Unit]("Create or update the BSP connection files").withRank(DSetting)
   val bspEnabled = SettingKey[Boolean](BasicKeys.bspEnabled)
   val bspSbtEnabled = settingKey[Boolean]("Should BSP export meta-targets for the SBT build itself?")
@@ -420,6 +421,11 @@ object Keys {
   val bspBuildTargetCleanCache = inputKey[Unit]("Corresponds to buildTarget/cleanCache request").withRank(DTask)
   val bspBuildTargetScalacOptions = inputKey[Unit]("").withRank(DTask)
   val bspBuildTargetScalacOptionsItem = taskKey[ScalacOptionsItem]("").withRank(DTask)
+
+  val bspBuildTargetJVMRunEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmRunEnvironment request").withRank(DTask)
+  val bspBuildTargetJVMTestEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmTestEnvironment request").withRank(DTask)
+  val bspBuildTargetJvmEnvironmentItem = taskKey[JvmEnvironmentItem]("Computes JVM environment item").withRank(DTask)
+  
   val bspScalaTestClasses = inputKey[Unit]("Corresponds to buildTarget/scalaTestClasses request").withRank(DTask)
   val bspScalaTestClassesItem = taskKey[Seq[ScalaTestClassesItem]]("").withRank(DTask)
   val bspScalaMainClasses = inputKey[Unit]("Corresponds to buildTarget/scalaMainClasses request").withRank(DTask)

main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala

@@ -119,11 +119,7 @@ object BuildServerProtocol {
       }
     }.value,
     // https://github.com/build-server-protocol/build-server-protocol/blob/master/docs/specification.md#build-target-sources-request
-    bspBuildTargetSources := Def.inputTaskDyn {
-      val s = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspBuildTargetSources := bspInputTask { (state, _, workspace, filter) =>
       // run the worker task concurrently
       Def.task {
         val items = bspBuildTargetSourcesItem.result.all(filter).value
@@ -147,64 +143,48 @@ object BuildServerProtocol {
         }
         val successfulItems = anyOrThrow(items ++ buildItems)
         val result = SourcesResult(successfulItems.toVector)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
     bspBuildTargetSources / aggregate := false,
-    bspBuildTargetResources := Def.inputTaskDyn {
-      val s = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      workspace.warnIfBuildsNonEmpty(Method.Resources, s.log)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspBuildTargetResources := bspInputTask { (state, _, workspace, filter) =>
+      workspace.warnIfBuildsNonEmpty(Method.Resources, state.log)
       // run the worker task concurrently
       Def.task {
         val items = bspBuildTargetResourcesItem.result.all(filter).value
         val successfulItems = anyOrThrow(items)
         val result = ResourcesResult(successfulItems.toVector)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
     bspBuildTargetResources / aggregate := false,
-    bspBuildTargetDependencySources := Def.inputTaskDyn {
-      val s = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspBuildTargetDependencySources := bspInputTask { (state, _, workspace, filter) =>
       // run the worker task concurrently
       Def.task {
         import sbt.internal.bsp.codec.JsonProtocol._
         val items = bspBuildTargetDependencySourcesItem.result.all(filter).value
         val successfulItems = anyOrThrow(items)
         val result = DependencySourcesResult(successfulItems.toVector)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
     bspBuildTargetDependencySources / aggregate := false,
-    bspBuildTargetCompile := Def.inputTaskDyn {
-      val s: State = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      workspace.warnIfBuildsNonEmpty(Method.Compile, s.log)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspBuildTargetCompile := bspInputTask { (state, _, workspace, filter) =>
+      workspace.warnIfBuildsNonEmpty(Method.Compile, state.log)
       Def.task {
         val statusCodes = Keys.bspBuildTargetCompileItem.result.all(filter).value
         val aggregatedStatusCode = allOrThrow(statusCodes) match {
           case Seq() => StatusCode.Success
           case codes => codes.max
         }
-        s.respondEvent(BspCompileResult(None, aggregatedStatusCode))
+        state.respondEvent(BspCompileResult(None, aggregatedStatusCode))
       }
     }.evaluated,
     bspBuildTargetCompile / aggregate := false,
     bspBuildTargetTest := bspTestTask.evaluated,
     bspBuildTargetTest / aggregate := false,
-    bspBuildTargetCleanCache := Def.inputTaskDyn {
-      val s: State = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      workspace.warnIfBuildsNonEmpty(Method.CleanCache, s.log)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspBuildTargetCleanCache := bspInputTask { (state, targets, workspace, filter) =>
+      workspace.warnIfBuildsNonEmpty(Method.CleanCache, state.log)
       Def.task {
         val results = Keys.clean.result.all(filter).value
         val successes = anyOrThrow(results).size
@@ -214,18 +194,12 @@ object BuildServerProtocol {
         // checking that the executed results plus this entry is equal to the total number of targets.
         // When rebuilding a single module, the root build isn't sent, just the requested targets.
         val cleaned = successes + workspace.builds.size == targets.size
-        s.respondEvent(CleanCacheResult(None, cleaned))
+        state.respondEvent(CleanCacheResult(None, cleaned))
       }
     }.evaluated,
     bspBuildTargetCleanCache / aggregate := false,
-    bspBuildTargetScalacOptions := Def.inputTaskDyn {
-      val s = state.value
-
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
+    bspBuildTargetScalacOptions := bspInputTask { (state, _, workspace, filter) =>
       val builds = workspace.builds
-
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
       Def.task {
         val items = bspBuildTargetScalacOptionsItem.result.all(filter).value
         val appProvider = appConfiguration.value.provider()
@@ -246,34 +220,26 @@ object BuildServerProtocol {
         }
         val successfulItems = anyOrThrow(items ++ buildItems)
         val result = ScalacOptionsResult(successfulItems.toVector)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
     bspBuildTargetScalacOptions / aggregate := false,
-    bspScalaTestClasses := Def.inputTaskDyn {
-      val s = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      workspace.warnIfBuildsNonEmpty(Method.ScalaTestClasses, s.log)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspScalaTestClasses := bspInputTask { (state, _, workspace, filter) =>
+      workspace.warnIfBuildsNonEmpty(Method.ScalaTestClasses, state.log)
       Def.task {
         val items = bspScalaTestClassesItem.result.all(filter).value
         val successfulItems = anyOrThrow(items).flatten.toVector
         val result = ScalaTestClassesResult(successfulItems.toVector, None)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
-    bspScalaMainClasses := Def.inputTaskDyn {
-      val s = state.value
-      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
-      val workspace = bspFullWorkspace.value.filter(targets)
-      workspace.warnIfBuildsNonEmpty(Method.ScalaMainClasses, s.log)
-      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+    bspScalaMainClasses := bspInputTask { (state, _, workspace, filter) =>
+      workspace.warnIfBuildsNonEmpty(Method.ScalaMainClasses, state.log)
       Def.task {
         val items = bspScalaMainClassesItem.result.all(filter).value
         val successfulItems = anyOrThrow(items)
         val result = ScalaMainClassesResult(successfulItems.toVector, None)
-        s.respondEvent(result)
+        state.respondEvent(result)
       }
     }.evaluated,
     bspScalaMainClasses / aggregate := false
@@ -315,6 +281,23 @@ object BuildServerProtocol {
     bspBuildTargetCompileItem := bspCompileTask.value,
     bspBuildTargetRun := bspRunTask.evaluated,
     bspBuildTargetScalacOptionsItem := scalacOptionsTask.value,
+    bspBuildTargetJVMRunEnvironment := bspInputTask { (state, _, _, filter) =>
+      Def.task {
+        val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value
+        val successfulItems = anyOrThrow(items)
+        val result = JvmRunEnvironmentResult(successfulItems.toVector, None)
+        state.respondEvent(result)
+      }
+    }.evaluated,
+    bspBuildTargetJVMTestEnvironment := bspInputTask { (state, _, _, filter) =>
+      Def.task {
+        val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value
+        val successfulItems = anyOrThrow(items)
+        val result = JvmTestEnvironmentResult(successfulItems.toVector, None)
+        state.respondEvent(result)
+      }
+    }.evaluated,
+    bspBuildTargetJvmEnvironmentItem := jvmEnvironmentItem().value,
     bspInternalDependencyConfigurations := internalDependencyConfigurationsSetting.value,
     bspScalaTestClassesItem := scalaTestClassesTask.value,
     bspScalaMainClassesItem := scalaMainClassesTask.value,
@@ -344,6 +327,8 @@ object BuildServerProtocol {
     final val Run = "buildTarget/run"
     final val CleanCache = "buildTarget/cleanCache"
     final val ScalacOptions = "buildTarget/scalacOptions"
+    final val JvmRunEnvironment = "buildTarget/jvmRunEnvironment"
+    final val JvmTestEnvironment = "buildTarget/jvmTestEnvironment"
     final val ScalaTestClasses = "buildTarget/scalaTestClasses"
     final val ScalaMainClasses = "buildTarget/scalaMainClasses"
     final val Exit = "build/exit"
@@ -443,6 +428,18 @@ object BuildServerProtocol {
             val command = Keys.bspBuildTargetScalacOptions.key
             val _ = callback.appendExec(s"$command $targets", Some(r.id))
 
+          case r if r.method == Method.JvmRunEnvironment =>
+            val param = Converter.fromJson[JvmRunEnvironmentParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetJVMRunEnvironment.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r if r.method == Method.JvmTestEnvironment =>
+            val param = Converter.fromJson[JvmTestEnvironmentParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetJVMTestEnvironment.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
           case r if r.method == Method.ScalaTestClasses =>
             val param = Converter.fromJson[ScalaTestClassesParams](json(r)).get
             val targets = param.targets.map(_.uri).mkString(" ")
@@ -648,6 +645,38 @@ object BuildServerProtocol {
     )
   }
 
+  private def bspInputTask[T](
+      taskImpl: (
+          State,
+          Seq[BuildTargetIdentifier],
+          BspFullWorkspace,
+          ScopeFilter
+      ) => Def.Initialize[Task[T]]
+  ): Def.Initialize[InputTask[T]] =
+    Def.inputTaskDyn {
+      val s = state.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val workspace: BspFullWorkspace = bspFullWorkspace.value.filter(targets)
+      val filter = ScopeFilter.in(workspace.scopes.values.toList)
+      taskImpl(s, targets, workspace, filter)
+    }
+
+  private def jvmEnvironmentItem(): Initialize[Task[JvmEnvironmentItem]] = Def.task {
+    val target = Keys.bspTargetIdentifier.value
+    val classpath = Keys.fullClasspath.value.map(_.data.toURI).toVector
+    val jvmOptions = Keys.javaOptions.value.toVector
+    val baseDir = Keys.baseDirectory.value.toURI().toString()
+    val env = envVars.value
+
+    JvmEnvironmentItem(
+      target,
+      classpath,
+      jvmOptions,
+      baseDir,
+      env
+    )
+  }
+
   private def scalacOptionsTask: Def.Initialize[Task[ScalacOptionsItem]] = Def.taskDyn {
     val target = Keys.bspTargetIdentifier.value
     val scalacOptions = Keys.scalacOptions.value

protocol/src/main/contraband-scala/sbt/internal/bsp/JvmEnvironmentItem.scala

@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class JvmEnvironmentItem private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val classpath: Vector[java.net.URI],
+  val jvmOptions: Vector[String],
+  val workingDirectory: String,
+  val environmentVariables: scala.collection.immutable.Map[String, String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JvmEnvironmentItem => (this.target == x.target) && (this.classpath == x.classpath) && (this.jvmOptions == x.jvmOptions) && (this.workingDirectory == x.workingDirectory) && (this.environmentVariables == x.environmentVariables)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmEnvironmentItem".##) + target.##) + classpath.##) + jvmOptions.##) + workingDirectory.##) + environmentVariables.##)
+  }
+  override def toString: String = {
+    "JvmEnvironmentItem(" + target + ", " + classpath + ", " + jvmOptions + ", " + workingDirectory + ", " + environmentVariables + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, classpath: Vector[java.net.URI] = classpath, jvmOptions: Vector[String] = jvmOptions, workingDirectory: String = workingDirectory, environmentVariables: scala.collection.immutable.Map[String, String] = environmentVariables): JvmEnvironmentItem = {
+    new JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): JvmEnvironmentItem = {
+    copy(target = target)
+  }
+  def withClasspath(classpath: Vector[java.net.URI]): JvmEnvironmentItem = {
+    copy(classpath = classpath)
+  }
+  def withJvmOptions(jvmOptions: Vector[String]): JvmEnvironmentItem = {
+    copy(jvmOptions = jvmOptions)
+  }
+  def withWorkingDirectory(workingDirectory: String): JvmEnvironmentItem = {
+    copy(workingDirectory = workingDirectory)
+  }
+  def withEnvironmentVariables(environmentVariables: scala.collection.immutable.Map[String, String]): JvmEnvironmentItem = {
+    copy(environmentVariables = environmentVariables)
+  }
+}
+object JvmEnvironmentItem {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, classpath: Vector[java.net.URI], jvmOptions: Vector[String], workingDirectory: String, environmentVariables: scala.collection.immutable.Map[String, String]): JvmEnvironmentItem = new JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables)
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentParams.scala

@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class JvmRunEnvironmentParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JvmRunEnvironmentParams => (this.targets == x.targets) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmRunEnvironmentParams".##) + targets.##) + originId.##)
+  }
+  override def toString: String = {
+    "JvmRunEnvironmentParams(" + targets + ", " + originId + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): JvmRunEnvironmentParams = {
+    new JvmRunEnvironmentParams(targets, originId)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JvmRunEnvironmentParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): JvmRunEnvironmentParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): JvmRunEnvironmentParams = {
+    copy(originId = Option(originId))
+  }
+}
+object JvmRunEnvironmentParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): JvmRunEnvironmentParams = new JvmRunEnvironmentParams(targets, originId)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): JvmRunEnvironmentParams = new JvmRunEnvironmentParams(targets, Option(originId))
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentResult.scala

@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class JvmRunEnvironmentResult private (
+  val items: Vector[sbt.internal.bsp.JvmEnvironmentItem],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JvmRunEnvironmentResult => (this.items == x.items) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmRunEnvironmentResult".##) + items.##) + originId.##)
+  }
+  override def toString: String = {
+    "JvmRunEnvironmentResult(" + items + ", " + originId + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.JvmEnvironmentItem] = items, originId: Option[String] = originId): JvmRunEnvironmentResult = {
+    new JvmRunEnvironmentResult(items, originId)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.JvmEnvironmentItem]): JvmRunEnvironmentResult = {
+    copy(items = items)
+  }
+  def withOriginId(originId: Option[String]): JvmRunEnvironmentResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): JvmRunEnvironmentResult = {
+    copy(originId = Option(originId))
+  }
+}
+object JvmRunEnvironmentResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: Option[String]): JvmRunEnvironmentResult = new JvmRunEnvironmentResult(items, originId)
+  def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: String): JvmRunEnvironmentResult = new JvmRunEnvironmentResult(items, Option(originId))
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentParams.scala

@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class JvmTestEnvironmentParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JvmTestEnvironmentParams => (this.targets == x.targets) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmTestEnvironmentParams".##) + targets.##) + originId.##)
+  }
+  override def toString: String = {
+    "JvmTestEnvironmentParams(" + targets + ", " + originId + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): JvmTestEnvironmentParams = {
+    new JvmTestEnvironmentParams(targets, originId)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JvmTestEnvironmentParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): JvmTestEnvironmentParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): JvmTestEnvironmentParams = {
+    copy(originId = Option(originId))
+  }
+}
+object JvmTestEnvironmentParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): JvmTestEnvironmentParams = new JvmTestEnvironmentParams(targets, originId)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): JvmTestEnvironmentParams = new JvmTestEnvironmentParams(targets, Option(originId))
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentResult.scala

@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class JvmTestEnvironmentResult private (
+  val items: Vector[sbt.internal.bsp.JvmEnvironmentItem],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JvmTestEnvironmentResult => (this.items == x.items) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmTestEnvironmentResult".##) + items.##) + originId.##)
+  }
+  override def toString: String = {
+    "JvmTestEnvironmentResult(" + items + ", " + originId + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.JvmEnvironmentItem] = items, originId: Option[String] = originId): JvmTestEnvironmentResult = {
+    new JvmTestEnvironmentResult(items, originId)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.JvmEnvironmentItem]): JvmTestEnvironmentResult = {
+    copy(items = items)
+  }
+  def withOriginId(originId: Option[String]): JvmTestEnvironmentResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): JvmTestEnvironmentResult = {
+    copy(originId = Option(originId))
+  }
+}
+object JvmTestEnvironmentResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: Option[String]): JvmTestEnvironmentResult = new JvmTestEnvironmentResult(items, originId)
+  def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: String): JvmTestEnvironmentResult = new JvmTestEnvironmentResult(items, Option(originId))
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala

@@ -63,4 +63,9 @@ trait JsonProtocol extends sjsonnew.BasicJsonProtocol
   with sbt.internal.bsp.codec.ResourcesParamsFormats
   with sbt.internal.bsp.codec.ResourcesItemFormats
   with sbt.internal.bsp.codec.ResourcesResultFormats
+  with sbt.internal.bsp.codec.JvmEnvironmentItemFormats
+  with sbt.internal.bsp.codec.JvmTestEnvironmentParamsFormats
+  with sbt.internal.bsp.codec.JvmTestEnvironmentResultFormats
+  with sbt.internal.bsp.codec.JvmRunEnvironmentParamsFormats
+  with sbt.internal.bsp.codec.JvmRunEnvironmentResultFormats
 object JsonProtocol extends JsonProtocol

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmEnvironmentItemFormats.scala

@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait JvmEnvironmentItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val JvmEnvironmentItemFormat: JsonFormat[sbt.internal.bsp.JvmEnvironmentItem] = new JsonFormat[sbt.internal.bsp.JvmEnvironmentItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmEnvironmentItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val classpath = unbuilder.readField[Vector[java.net.URI]]("classpath")
+      val jvmOptions = unbuilder.readField[Vector[String]]("jvmOptions")
+      val workingDirectory = unbuilder.readField[String]("workingDirectory")
+      val environmentVariables = unbuilder.readField[scala.collection.immutable.Map[String, String]]("environmentVariables")
+      unbuilder.endObject()
+      sbt.internal.bsp.JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.JvmEnvironmentItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("classpath", obj.classpath)
+    builder.addField("jvmOptions", obj.jvmOptions)
+    builder.addField("workingDirectory", obj.workingDirectory)
+    builder.addField("environmentVariables", obj.environmentVariables)
+    builder.endObject()
+  }
+}
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentParamsFormats.scala

@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait JvmRunEnvironmentParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val JvmRunEnvironmentParamsFormat: JsonFormat[sbt.internal.bsp.JvmRunEnvironmentParams] = new JsonFormat[sbt.internal.bsp.JvmRunEnvironmentParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmRunEnvironmentParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.JvmRunEnvironmentParams(targets, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.JvmRunEnvironmentParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentResultFormats.scala

@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait JvmRunEnvironmentResultFormats { self: sbt.internal.bsp.codec.JvmEnvironmentItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val JvmRunEnvironmentResultFormat: JsonFormat[sbt.internal.bsp.JvmRunEnvironmentResult] = new JsonFormat[sbt.internal.bsp.JvmRunEnvironmentResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmRunEnvironmentResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.JvmEnvironmentItem]]("items")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.JvmRunEnvironmentResult(items, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.JvmRunEnvironmentResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentParamsFormats.scala

@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait JvmTestEnvironmentParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val JvmTestEnvironmentParamsFormat: JsonFormat[sbt.internal.bsp.JvmTestEnvironmentParams] = new JsonFormat[sbt.internal.bsp.JvmTestEnvironmentParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmTestEnvironmentParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.JvmTestEnvironmentParams(targets, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.JvmTestEnvironmentParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}

protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentResultFormats.scala

@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait JvmTestEnvironmentResultFormats { self: sbt.internal.bsp.codec.JvmEnvironmentItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val JvmTestEnvironmentResultFormat: JsonFormat[sbt.internal.bsp.JvmTestEnvironmentResult] = new JsonFormat[sbt.internal.bsp.JvmTestEnvironmentResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmTestEnvironmentResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.JvmEnvironmentItem]]("items")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.JvmTestEnvironmentResult(items, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.JvmTestEnvironmentResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}

protocol/src/main/contraband/bsp.contra

@@ -696,3 +696,34 @@ type ResourcesItem {
    ## List of resource files.
   resources: [java.net.URI]
 }
+
+
+# JVM Environment requests
+
+type JvmEnvironmentItem {
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+  classpath: [java.net.URI]!
+  jvmOptions: [String]!
+  workingDirectory: String!
+  environmentVariables: StringStringMap!
+}
+
+type JvmTestEnvironmentParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]!
+  originId: String
+}
+
+type JvmTestEnvironmentResult{
+  items: [sbt.internal.bsp.JvmEnvironmentItem]!
+  originId: String
+}
+
+type JvmRunEnvironmentParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]!
+  originId: String
+}
+
+type JvmRunEnvironmentResult{
+  items: [sbt.internal.bsp.JvmEnvironmentItem]!
+  originId: String
+}

server-test/src/server-test/buildserver/build.sbt

@@ -1,10 +1,16 @@
-ThisBuild / scalaVersion := "2.13.1"
+ThisBuild / scalaVersion := "2.13.8"
 
 Global / serverLog / logLevel := Level.Debug
 
 lazy val runAndTest = project.in(file("run-and-test"))
   .settings(
+    libraryDependencies += "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core" % "2.13.11",
     libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.8" % "test",
+    Compile / javaOptions := Vector("Xmx256M"),
+    Compile / envVars := Map("KEY" -> "VALUE"),
+
+    Test / javaOptions := Vector("Xmx512M"),
+    Test / envVars := Map("KEY_TEST" -> "VALUE_TEST"),
   )
   .dependsOn(util)
 

server-test/src/test/scala/testpkg/BuildServerTest.scala

@@ -157,7 +157,7 @@ object BuildServerTest extends AbstractServerTest {
     assert(processing("buildTarget/scalacOptions"))
     assert(svr.waitForString(10.seconds) { s =>
       (s contains """"id":"40"""") &&
-      (s contains "scala-library-2.13.1.jar")
+      (s contains "scala-library-2.13.8.jar")
     })
   }
 
@@ -311,6 +311,49 @@ object BuildServerTest extends AbstractServerTest {
     })
   }
 
+  test("buildTarget/jvmRunEnvironment") { _ =>
+    val buildTarget = buildTargetUri("runAndTest", "Compile")
+    svr.sendJsonRpc(
+      s"""|{ "jsonrpc": "2.0",
+          |  "id": "97",
+          |  "method": "buildTarget/jvmRunEnvironment",
+          |  "params": { "targets": [{ "uri": "$buildTarget" }] }
+          |}""".stripMargin
+    )
+    assert(processing("buildTarget/jvmRunEnvironment"))
+    assert {
+      svr.waitForString(10.seconds) { s =>
+        (s contains """"id":"97"""") &&
+        (s contains "jsoniter-scala-core_2.13-2.13.11.jar") && // compile dependency
+        (s contains "\"jvmOptions\":[\"Xmx256M\"]") &&
+        (s contains "\"environmentVariables\":{\"KEY\":\"VALUE\"}") &&
+        (s contains "/buildserver/run-and-test/") // working directory
+      }
+    }
+  }
+
+  test("buildTarget/jvmTestEnvironment") { _ =>
+    val buildTarget = buildTargetUri("runAndTest", "Test")
+    svr.sendJsonRpc(
+      s"""|{ "jsonrpc": "2.0", 
+          |  "id": "98", 
+          |  "method": "buildTarget/jvmTestEnvironment", 
+          |  "params": { "targets": [{ "uri": "$buildTarget" }] } 
+          |}""".stripMargin
+    )
+    assert(processing("buildTarget/jvmTestEnvironment"))
+    assert {
+      svr.waitForString(10.seconds) { s =>
+        (s contains """"id":"98"""") &&
+        // test depends on compile so it has dependencies from both
+        (s contains "jsoniter-scala-core_2.13-2.13.11.jar") && // compile dependency
+        (s contains "scalatest_2.13-3.0.8.jar") && // test dependency
+        (s contains "\"jvmOptions\":[\"Xmx512M\"]") &&
+        (s contains "\"environmentVariables\":{\"KEY_TEST\":\"VALUE_TEST\"}")
+      }
+    }
+  }
+
   test("buildTarget/scalaTestClasses") { _ =>
     val buildTarget = buildTargetUri("runAndTest", "Test")
     val badBuildTarget = buildTargetUri("badBuildTarget", "Test")