Ensure *.semanticdb files still land along with the compiled classes when a virtual directory is used by BSP

Author: Gedochao

modules/build/src/main/scala/scala/build/Build.scala

@@ -303,7 +303,10 @@ object Build {
             workspace = inputs.workspace,
             updateSemanticDbs = true,
             scalaVersion = sv,
-            buildOptions = build.options
+            buildOptions =
+              inputs.originalWorkspaceOpt.fold(build.options)(
+                build.options.withResolvedSemanticDbSourceRoot
+              )
           ).left.foreach(_.foreach(logger.message(_)))
       case _ =>
     }
@@ -942,7 +945,8 @@ object Build {
       options.scalaOptions.semanticDbOptions.generateSemanticDbs.getOrElse(false)
     val semanticDbTargetRoot = options.scalaOptions.semanticDbOptions.semanticDbTargetRoot
     val semanticDbSourceRoot =
-      options.scalaOptions.semanticDbOptions.semanticDbSourceRoot.getOrElse(inputs.workspace)
+      options.scalaOptions.semanticDbOptions.semanticDbSourceRoot
+        .getOrElse(inputs.originalWorkspaceOpt.getOrElse(inputs.workspace))
 
     val scalaCompilerParamsOpt = artifacts.scalaOpt match {
       case Some(scalaArtifacts) =>

modules/build/src/main/scala/scala/build/bsp/BspImpl.scala

@@ -363,7 +363,10 @@ final class BspImpl(
                 currentBloopSession.inputs.workspace,
                 updateSemanticDbs = true,
                 scalaVersion = sv,
-                buildOptions = data.buildOptions
+                buildOptions =
+                  currentBloopSession.inputs.originalWorkspaceOpt.fold(data.buildOptions)(
+                    data.buildOptions.withResolvedSemanticDbSourceRoot
+                  )
               ).left.foreach(_.foreach(showGlobalWarningOnce))
 
           if (res.getStatusCode == b.StatusCode.OK)

modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala

@@ -2451,18 +2451,25 @@ abstract class BspTestDefinitions extends ScalaCliSuite
     clientDescription = if isIntelliJ then "IntelliJ" else "any client"
     bspClientName     = if isIntelliJ then "IntelliJ" else "test"
   } {
-    def baseDirectoryOfMainTarget(
+    def mainTargetOf(
       remoteServer: b.BuildServer & b.ScalaBuildServer & b.JavaBuildServer & b.JvmBuildServer &
         TestBspClient.WrappedSourcesBuildServer
-    ): os.Path = {
+    ): b.BuildTarget = {
       val buildTargetsResp = remoteServer.workspaceBuildTargets().asScala.await
       val targets          = buildTargetsResp.getTargets.asScala.toSeq
-      val mainTarget       = targets.find(t => !t.getId.getUri.contains("-test")).getOrElse {
+      targets.find(t => !t.getId.getUri.contains("-test")).getOrElse {
         sys.error(s"No main build target found in ${targets.map(_.getId.getUri)}")
       }
-      os.Path(Paths.get(new URI(mainTarget.getBaseDirectory)))
     }
 
+    def baseDirectoryOf(target: b.BuildTarget): os.Path =
+      os.Path(Paths.get(new URI(target.getBaseDirectory)))
+
+    def collectSemDbFiles(root: os.Path): Seq[os.Path] =
+      os.walk(root)
+        .filter(_.last.endsWith(".semanticdb"))
+        .filter(p => !p.segments.exists(_ == "bloop-internal-classes"))
+
     test(s"workspaceBuildTargets baseDirectory: default workspace ($clientDescription)") {
       withBsp(
         inputs = TestInputs(
@@ -2476,9 +2483,21 @@ abstract class BspTestDefinitions extends ScalaCliSuite
         bspClientName = bspClientName
       ) { (root, _, remoteServer) =>
         Future {
-          val baseDir = baseDirectoryOfMainTarget(remoteServer)
+          val mainTarget = mainTargetOf(remoteServer)
+          val baseDir    = baseDirectoryOf(mainTarget)
           if isIntelliJ then expect(baseDir == root)
           else expect(baseDir == root / Constants.workspaceDirName)
+
+          val compileResp =
+            remoteServer
+              .buildTargetCompile(new b.CompileParams(List(mainTarget.getId).asJava))
+              .asScala
+              .await
+          expect(compileResp.getStatusCode == b.StatusCode.OK)
+
+          val semDbFiles = collectSemDbFiles(root)
+          expect(semDbFiles.nonEmpty)
+          expect(semDbFiles.forall(_.segments.contains(Constants.workspaceDirName)))
         }
       }
     }
@@ -2503,9 +2522,20 @@ abstract class BspTestDefinitions extends ScalaCliSuite
             ) {
               (_, _, remoteServer) =>
                 Future {
-                  val baseDir         = baseDirectoryOfMainTarget(remoteServer)
+                  val mainTarget      = mainTargetOf(remoteServer)
+                  val baseDir         = baseDirectoryOf(mainTarget)
                   val expectedBaseDir = root / "dir"
                   expect(baseDir == expectedBaseDir)
+
+                  val compileResp =
+                    remoteServer
+                      .buildTargetCompile(new b.CompileParams(List(mainTarget.getId).asJava))
+                      .asScala
+                      .await
+                  expect(compileResp.getStatusCode == b.StatusCode.OK)
+
+                  val semDbFilesUnderRoot = collectSemDbFiles(root)
+                  expect(semDbFilesUnderRoot.isEmpty)
                 }
             }
           finally os.perms.set(root / "dir", "rwxr-xr-x")

modules/options/src/main/scala/scala/build/options/BuildOptions.scala

@@ -53,6 +53,22 @@ final case class BuildOptions(
 
   import BuildOptions.JavaHomeInfo
 
+  /** When the build workspace was moved to a virtual directory (e.g. after
+    * [[scala.build.input.Inputs.checkAttributes]] fallback) and the user did not set an explicit
+    * semanticdb source root, use the given original workspace so semanticdb paths stay relative to
+    * the user's project root.
+    */
+  def withResolvedSemanticDbSourceRoot(originalWorkspace: os.Path): BuildOptions =
+    if scalaOptions.semanticDbOptions.semanticDbSourceRoot.isEmpty then
+      copy(scalaOptions =
+        scalaOptions.copy(
+          semanticDbOptions = scalaOptions.semanticDbOptions.copy(
+            semanticDbSourceRoot = Some(originalWorkspace)
+          )
+        )
+      )
+    else this
+
   lazy val platform: Positioned[Platform] =
     scalaOptions.platform.getOrElse(Positioned(List(Position.Custom("DEFAULT")), Platform.JVM))