Ensure non-self executable JVM launchers' setup-ide produces working BSP connection JSON (#3876)

Gedochao · web-flow · commit a29adba3ec8b · 2025-09-23T22:12:00.000+02:00
diff --git a/build.mill.scala b/build.mill.scala
@@ -1057,6 +1057,7 @@ trait CliIntegration extends SbtModule with ScalaCliPublishModule with HasTests
            |
            |/** Build-time constants. Generated by mill. */
            |object Constants {
+           |  def cliVersion                   = "${publishVersion()}"
            |  def allJavaVersions              = Seq(${Java.allJavaVersions.sorted.mkString(", ")})
            |  def bspVersion                   = "${Deps.bsp4j.dep.versionConstraint.asString}"
            |  def bloopMinimumJvmVersion       = ${Java.minimumBloopJava}
diff --git a/modules/cli/src/main/scala/scala/cli/commands/CommandUtils.scala b/modules/cli/src/main/scala/scala/cli/commands/CommandUtils.scala
@@ -1,7 +1,7 @@
 package scala.cli.commands
 
 import java.io.File
-import java.nio.file.Paths
+import java.nio.file.{Files, Paths}
 
 import scala.build.Os
 import scala.cli.ScalaCli
@@ -48,8 +48,8 @@ object CommandUtils {
               .toString
           ).toOption
           currentLauncherPathOpt.map(currentLauncherPath =>
-            scalaCLICanonicalPathsFromPATH.get(os.Path(currentLauncherPath))
-              .getOrElse(currentLauncherPath)
+            scalaCLICanonicalPathsFromPATH
+              .getOrElse(os.Path(currentLauncherPath), currentLauncherPath)
           )
         }
         .getOrElse(programName)
@@ -59,4 +59,29 @@ object CommandUtils {
   def printablePath(path: os.Path): String =
     if (path.startsWith(Os.pwd)) "." + File.separator + path.relativeTo(Os.pwd).toString
     else path.toString
+
+  extension (launcher: os.Path) {
+    def isJar: Boolean =
+      if os.isFile(launcher) then
+        val mimeType = Files.probeContentType(launcher.toNIO)
+        mimeType match
+          case "application/java-archive" | "application/x-java-archive" => true
+          case "application/zip"                                         =>
+            // Extra check: ensure META-INF/MANIFEST.MF exists inside
+            val jarFile = new java.util.jar.JarFile(launcher.toIO)
+            try jarFile.getEntry("META-INF/MANIFEST.MF") != null
+            finally jarFile.close()
+          case _ => false
+      else false
+    def hasSelfExecutablePreamble: Boolean = {
+      // Read first 2 bytes raw: look for shebang '#!'
+      val in = Files.newInputStream(launcher.toNIO)
+      try
+        val b1 = in.read()
+        val b2 = in.read()
+        b1 == '#' && b2 == '!'
+      finally
+        in.close()
+    }
+  }
 }
diff --git a/modules/cli/src/main/scala/scala/cli/commands/setupide/SetupIde.scala b/modules/cli/src/main/scala/scala/cli/commands/setupide/SetupIde.scala
@@ -17,7 +17,9 @@ import scala.build.internal.Constants
 import scala.build.internals.EnvVar
 import scala.build.options.{BuildOptions, Scope}
 import scala.cli.CurrentParams
+import scala.cli.commands.CommandUtils.{hasSelfExecutablePreamble, isJar}
 import scala.cli.commands.shared.{SharedBspFileOptions, SharedOptions}
+import scala.cli.commands.util.JvmUtils
 import scala.cli.commands.{CommandUtils, ScalaCommand}
 import scala.cli.errors.FoundVirtualInputsError
 import scala.cli.launcher.LauncherOptions
@@ -155,13 +157,32 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
       s"-J-agentlib:jdwp=transport=dt_socket,server=n,address=localhost:$port,suspend=y"
     )
 
-    val launcher = launcherOptions.scalaRunner.initialLauncherPath
-      .getOrElse(CommandUtils.getAbsolutePathToScalaCli(progName))
+    val launcher = os.Path {
+      launcherOptions.scalaRunner.initialLauncherPath
+        .getOrElse(CommandUtils.getAbsolutePathToScalaCli(progName))
+    }
     val finalLauncherOptions = launcherOptions.copy(cliVersion =
       launcherOptions.cliVersion.orElse(launcherOptions.scalaRunner.predefinedCliVersion)
     )
+
+    val launcherCommand =
+      if launcher.isJar && !launcher.hasSelfExecutablePreamble
+      then
+        List(
+          value {
+            JvmUtils.getJavaCmdVersionOrHigher(
+              javaVersion =
+                math.max(Constants.minimumInternalJavaVersion, Constants.minimumBloopJavaVersion),
+              options = buildOptions
+            )
+          }.javaCommand,
+          "-jar",
+          launcher.toString
+        )
+      else List(launcher.toString)
+
     val bspArgs =
-      List(launcher) ++
+      launcherCommand ++
         finalLauncherOptions.toCliArgs ++
         launcherJavaPropArgs ++
         List("bsp") ++
diff --git a/modules/integration/src/test/scala/scala/cli/integration/BspSuite.scala b/modules/integration/src/test/scala/scala/cli/integration/BspSuite.scala
@@ -199,8 +199,11 @@ trait BspSuite { _: ScalaCliSuite =>
     expect(expectedPrefixes.exists(uri.startsWith))
   }
 
-  protected def readBspConfig(root: os.Path): Details = {
-    val bspFile = root / ".bsp" / "scala-cli.json"
+  protected def readBspConfig(
+    root: os.Path,
+    connectionJsonFileName: String = "scala-cli.json"
+  ): Details = {
+    val bspFile = root / ".bsp" / connectionJsonFileName
     expect(os.isFile(bspFile))
     val content = os.read.bytes(bspFile)
     // check that we can decode the connection details
diff --git a/modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala
@@ -15,8 +15,11 @@ import scala.concurrent.duration._
 import scala.jdk.CollectionConverters._
 import scala.util.Properties
 
-abstract class BspTestDefinitions extends ScalaCliSuite with TestScalaVersionArgs
-    with BspSuite with ScriptWrapperTestDefinitions {
+abstract class BspTestDefinitions extends ScalaCliSuite
+    with TestScalaVersionArgs
+    with BspSuite
+    with ScriptWrapperTestDefinitions
+    with CoursierScalaInstallationTestHelper {
   _: TestScalaVersion =>
   protected lazy val extraOptions: Seq[String] = scalaVersionArgs ++ TestUtil.extraOptions
 
@@ -31,7 +34,7 @@ abstract class BspTestDefinitions extends ScalaCliSuite with TestScalaVersionArg
       os.proc(TestUtil.cli, "setup-ide", ".", extraOptions).call(cwd = root, stdout = os.Inherit)
       val details = readBspConfig(root)
       expect(details.argv.length >= 2)
-      expect(details.argv(1) == "bsp")
+      expect(details.argv.dropWhile(_ != TestUtil.cliPath).drop(1).head == "bsp")
     }
   }
 
@@ -63,7 +66,11 @@ abstract class BspTestDefinitions extends ScalaCliSuite with TestScalaVersionArg
           expectedIdeEnvsFile.toString,
           root.toString
         )
-        expect(details.argv == expectedArgv)
+        if (TestUtil.isJvmBootstrappedCli) {
+          expect(details.argv.head.endsWith("java"))
+          expect(details.argv.drop(1).head == "-jar")
+        }
+        expect(details.argv.dropWhile(_ != TestUtil.cliPath) == expectedArgv)
         expect(os.isFile(expectedIdeOptionsFile))
         expect(os.isFile(expectedIdeInputsFile))
         expect(os.isFile(expectedIdeEnvsFile))
@@ -108,7 +115,7 @@ abstract class BspTestDefinitions extends ScalaCliSuite with TestScalaVersionArg
         (root / "directory" / Constants.workspaceDirName / "ide-envs.json").toString,
         (root / "directory" / "simple.sc").toString
       )
-      expect(details.argv == expectedArgv)
+      expect(details.argv.dropWhile(_ != TestUtil.cliPath) == expectedArgv)
     }
   }
 
@@ -2220,14 +2227,90 @@ abstract class BspTestDefinitions extends ScalaCliSuite with TestScalaVersionArg
       }
     }
 
+  for {
+    useScalaWrapper <- Seq(false, true)
+    if actualScalaVersion.coursierVersion >= "3.5.0".coursierVersion
+    withLauncher = (root: os.Path) =>
+      (f: Seq[os.Shellable] => Unit) =>
+        if (useScalaWrapper)
+          withScalaRunnerWrapper(
+            root = root,
+            localBin = root / "local-bin",
+            localCache = Some(root / "local-cache"),
+            scalaVersion = actualScalaVersion,
+            shouldCleanUp = false
+          )(launcher => f(Seq(launcher)))
+        else
+          f(Seq(TestUtil.cli))
+    launcherString         = if (useScalaWrapper) "coursier scala installation" else "Scala CLI"
+    connectionJsonFileName = if (useScalaWrapper) "scala.json" else "scala-cli.json"
+  }
+    test(
+      s"setup-ide with scala wrapper prepares valid BSP connection json with a valid launcher ($launcherString)"
+    ) {
+      TestUtil.retryOnCi() {
+        val scriptName = "example.sc"
+        TestInputs(
+          os.rel / scriptName -> s"""println("Hello")"""
+        )
+          .fromRoot { root =>
+            withLauncher(root) { launcher =>
+              val javaHome =
+                os.Path(
+                  os.proc(TestUtil.cs, "java-home", "--jvm", "zulu:8").call().out.trim(),
+                  os.pwd
+                )
+              os.proc(launcher, "setup-ide", scriptName, extraOptions)
+                .call(cwd = root, env = Map("JAVA_HOME" -> javaHome.toString))
+              val expectedIdeLauncherFile =
+                root / Constants.workspaceDirName / "ide-launcher-options.json"
+              expect(expectedIdeLauncherFile.toNIO.toFile.exists())
+              val bspConfig          = readBspConfig(root, connectionJsonFileName)
+              val bspLauncherCommand = {
+                val launcherPrefix = bspConfig.argv.takeWhile(_ != TestUtil.cliPath)
+                launcherPrefix :+ bspConfig.argv.drop(launcherPrefix.length).head
+              }
+              expect(bspLauncherCommand.last == TestUtil.cliPath)
+              if (TestUtil.isJvmBootstrappedCli) {
+                // this launcher is not self-executable and has to be launched with `java -jar`
+                expect(bspLauncherCommand.head.endsWith("java"))
+                expect(bspLauncherCommand.drop(1) == List("-jar", TestUtil.cliPath))
+                val bspJavaVersionResult = os.proc(bspLauncherCommand.head, "-version")
+                  .call(
+                    cwd = root,
+                    env = Map("JAVA_HOME" -> javaHome.toString),
+                    mergeErrIntoOut = true
+                  )
+                val bspJavaVersion = TestUtil.parseJavaVersion(bspJavaVersionResult.out.trim()).get
+                // the bsp launcher has to know to run itself on a supported JVM
+                expect(bspJavaVersion >= math.max(
+                  Constants.minimumInternalJvmVersion,
+                  Constants.bloopMinimumJvmVersion
+                ))
+              }
+              else
+                expect(bspLauncherCommand == List(TestUtil.cliPath))
+              val r = os.proc(bspLauncherCommand, "version", "--cli-version")
+                .call(cwd = root, env = Map("JAVA_HOME" -> javaHome.toString))
+              expect(r.out.trim() == Constants.cliVersion)
+            }
+          }
+      }
+    }
+
   test("setup-ide passes Java props to the BSP configuration correctly") {
     val scriptName = "hello.sc"
     TestInputs(os.rel / scriptName -> s"""println("Hello")""").fromRoot { root =>
       val javaProps = List("-Dfoo=bar", "-Dbar=baz")
       os.proc(TestUtil.cli, javaProps, "setup-ide", scriptName, extraOptions)
         .call(cwd = root)
       val bspConfig = readBspConfig(root)
-      expect(bspConfig.argv.head == TestUtil.cliPath)
+      if (TestUtil.isJvmBootstrappedCli) {
+        expect(bspConfig.argv.head.endsWith("java"))
+        expect(bspConfig.argv.drop(1).head == "-jar")
+        expect(bspConfig.argv.dropWhile(_ != TestUtil.cliPath).head == TestUtil.cliPath)
+      }
+      else expect(bspConfig.argv.head == TestUtil.cliPath)
       expect(bspConfig.argv.containsSlice(javaProps))
       expect(bspConfig.argv.indexOfSlice(javaProps) < bspConfig.argv.indexOf("bsp"))
     }
diff --git a/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala b/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala
@@ -12,20 +12,21 @@ import scala.Console._
 import scala.annotation.tailrec
 import scala.concurrent.duration.{Duration, DurationInt, FiniteDuration}
 import scala.concurrent.{Await, ExecutionContext, Future}
-import scala.util.Properties
+import scala.util.{Properties, Try}
 
 object TestUtil {
 
-  val cliKind: String              = sys.props("test.scala-cli.kind")
-  val isNativeCli: Boolean         = cliKind.startsWith("native")
-  val isJvmCli: Boolean            = cliKind.startsWith("jvm")
-  val isCI: Boolean                = System.getenv("CI") != null
-  val isM1: Boolean                = sys.props.get("os.arch").contains("aarch64")
-  val cliPath: String              = sys.props("test.scala-cli.path")
-  val debugPortOpt: Option[String] = sys.props.get("test.scala-cli.debug.port")
-  val detectCliPath: String        = if (TestUtil.isNativeCli) TestUtil.cliPath else "scala-cli"
-  val cli: Seq[String]             = cliCommand(cliPath)
-  val ltsEqualsNext: Boolean       = Constants.scala3Lts equals Constants.scala3Next
+  val cliKind: String               = sys.props("test.scala-cli.kind")
+  val isNativeCli: Boolean          = cliKind.startsWith("native")
+  val isJvmCli: Boolean             = cliKind.startsWith("jvm")
+  val isJvmBootstrappedCli: Boolean = cliKind.startsWith("jvmBootstrapped")
+  val isCI: Boolean                 = System.getenv("CI") != null
+  val isM1: Boolean                 = sys.props.get("os.arch").contains("aarch64")
+  val cliPath: String               = sys.props("test.scala-cli.path")
+  val debugPortOpt: Option[String]  = sys.props.get("test.scala-cli.debug.port")
+  val detectCliPath: String         = if (TestUtil.isNativeCli) TestUtil.cliPath else "scala-cli"
+  val cli: Seq[String]              = cliCommand(cliPath)
+  val ltsEqualsNext: Boolean        = Constants.scala3Lts equals Constants.scala3Next
 
   lazy val legacyScalaVersionsOnePerMinor: Seq[String] =
     Constants.legacyScala3Versions.sorted.reverse.distinctBy(_.split('.').take(2).mkString("."))
@@ -402,4 +403,20 @@ object TestUtil {
     def printStderrUntilRerun(timeout: Duration)(implicit ec: ExecutionContext): Unit =
       TestUtil.printStderrUntilCondition(proc, timeout)(_.contains("re-run"))()
   }
+
+  // based on the implementation from bloop-rifle:
+  // https://github.com/scalacenter/bloop/blob/65b0b290fddd6d4256665014a7d16531e29ded4f/bloop-rifle/src/main/scala/bloop/rifle/VersionUtil.scala#L13-L30
+  def parseJavaVersion(input: String): Option[Int] = {
+    val jvmReleaseRegex                             = "(1[.])?(\\d+)"
+    def jvmRelease(jvmVersion: String): Option[Int] = for {
+      regexMatch    <- jvmReleaseRegex.r.findFirstMatchIn(jvmVersion)
+      versionString <- Option(regexMatch.group(2))
+      versionInt    <- Try(versionString.toInt).toOption
+    } yield versionInt
+    for {
+      firstMatch         <- s""".*version .($jvmReleaseRegex).*""".r.findFirstMatchIn(input)
+      versionNumberGroup <- Option(firstMatch.group(1))
+      versionInt         <- jvmRelease(versionNumberGroup)
+    } yield versionInt
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -1057,6 +1057,7 @@ trait CliIntegration extends SbtModule with ScalaCliPublishModule with HasTests`
`1057`	`1057`	`\|`
`1058`	`1058`	`\|/** Build-time constants. Generated by mill. */`
`1059`	`1059`	`\|object Constants {`
	`1060`	`+ \| def cliVersion = "${publishVersion()}"`
`1060`	`1061`	`\| def allJavaVersions = Seq(${Java.allJavaVersions.sorted.mkString(", ")})`
`1061`	`1062`	`\| def bspVersion = "${Deps.bsp4j.dep.versionConstraint.asString}"`
`1062`	`1063`	`\| def bloopMinimumJvmVersion = ${Java.minimumBloopJava}`