add sourceroot flag with absolute root path of the sandbox worker in order to make the filepath relative in the tasty file

this should not invalidate the bazel cache every time because of the
path mapping set in the bazel rule config

remove sourceroot flag from analysis_store file content (it's not deterministic)

add -sourceroot conditionally (it was introduced in Scala 3); change from --sourceroot to -sourceroot

!fixup add -sourceroot

!fixup add -sourceroot

!fixup add -sourceroot

Author: Blaine Freestone

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/FilteredSetup.scala

@@ -0,0 +1,44 @@
+package sbt.internal.inc
+
+import xsbti.compile.{CompileOptions, MiniSetup}
+import java.nio.file.{Path, Paths}
+
+/**
+ * Zinc's MiniSetup contains scalacOptions which include the -sourceroot flag that references absolute sandbox paths.
+ * These paths are non-deterministic across builds because the sandbox directory changes (e.g., __sandbox/4/_main vs
+ * __sandbox/8/_main), making the analysis files non-deterministic.
+ *
+ * This class filters out the -sourceroot option from the scalacOptions to ensure deterministic analysis files.
+ *
+ * TODO: Consider if there's a better way to handle this upstream in Zinc
+ */
+
+object FilteredSetup {
+  private val sourcerootFlag = "-sourceroot"
+
+  def getFilteredSetup(setup: MiniSetup): MiniSetup = {
+    val options = setup.options()
+    // Filter out the -sourceroot option and its value
+    val filteredScalacOptions = {
+      val originalOptions = options.scalacOptions()
+      val filtered = scala.collection.mutable.ArrayBuffer[String]()
+      var i = 0
+      while (i < originalOptions.length) {
+        val option = originalOptions(i)
+        if (option == sourcerootFlag) {
+          // Skip both the flag and its value (next argument)
+          i += 2
+        } else {
+          filtered += option
+          i += 1
+        }
+      }
+      filtered.toArray
+    }
+
+    // Create new CompileOptions with filtered scalac options
+    val newOptions = options.withScalacOptions(filteredScalacOptions)
+    // Create new MiniSetup with filtered options
+    setup.withOptions(newOptions)
+  }
+}

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/ZincRunner.scala

@@ -18,7 +18,7 @@ import net.sourceforge.argparse4j.impl.Arguments as Arg
 import net.sourceforge.argparse4j.inf.{ArgumentParserException, Namespace}
 import sbt.internal.inc.classpath.ClassLoaderCache
 import sbt.internal.inc.caching.ClasspathCache
-import sbt.internal.inc.{Analysis, AnalyzingCompiler, CompileFailed, FilteredInfos, FilteredRelations, IncrementalCompilerImpl, Locate, PlainVirtualFile, PlainVirtualFileConverter, ZincUtil}
+import sbt.internal.inc.{Analysis, AnalyzingCompiler, CompileFailed, FilteredInfos, FilteredRelations, FilteredSetup, IncrementalCompilerImpl, Locate, PlainVirtualFile, PlainVirtualFileConverter, ZincUtil}
 import scala.jdk.CollectionConverters.*
 import scala.util.Try
 import scala.util.control.NonFatal
@@ -212,17 +212,25 @@ object ZincRunner extends WorkerMain[ZincRunnerWorkerConfig] {
         isWorker,
       )
 
+    val shouldIncludeSourceRoot = !scalaInstance.actualVersion.startsWith("0.") &&
+      scalaInstance.actualVersion.startsWith("3")
+
+    val scalacOptions =
+      workRequest.plugins.view.map(p => s"-Xplugin:$p").toArray ++
+        workRequest.compilerOptions ++
+        workRequest.compilerOptionsReferencingPaths.toArray ++
+        (if (shouldIncludeSourceRoot)
+           Array("-sourceroot", task.workDir.toAbsolutePath().toString)
+         else
+           Array.empty[String])
+
     val compileOptions =
       CompileOptions.create
         .withSources(sources.view.map(source => PlainVirtualFile(source.toAbsolutePath().normalize())).toArray)
         .withClasspath((classesOutputDir +: deps.view.map(_.classpath)).map(path => PlainVirtualFile(path)).toArray)
         .withClassesDirectory(classesOutputDir)
         .withJavacOptions(workRequest.javaCompilerOptions)
-        .withScalacOptions(
-          workRequest.plugins.view.map(p => s"-Xplugin:$p").toArray ++
-            workRequest.compilerOptions ++
-            workRequest.compilerOptionsReferencingPaths.toArray,
-        )
+        .withScalacOptions(scalacOptions)
 
     val compilers = {
       val scalaCompiler = ZincUtil
@@ -335,14 +343,17 @@ object ZincRunner extends WorkerMain[ZincRunnerWorkerConfig] {
       )
     }
 
+    // Filter out non-deterministic --sourceroot paths from the setup
+    val filteredSetup = FilteredSetup.getFilteredSetup(compileResult.setup)
+
     val analysisStoreText = AnalysisUtil.getAnalysisStore(
       new File(pathString.substring(0, pathString.length() - 3) + ".text.gz"),
       true,
       readWriteMappers,
     )
 
-    analysisStoreText.set(AnalysisContents.create(resultAnalysis, compileResult.setup))
-    analysisStore.set(AnalysisContents.create(resultAnalysis, compileResult.setup))
+    analysisStoreText.set(AnalysisContents.create(resultAnalysis, filteredSetup))
+    analysisStore.set(AnalysisContents.create(resultAnalysis, filteredSetup))
 
     // create used deps
     val usedDeps =