PR1 (M8): Make compiler-side SCIP shard emission the default

After M3-M7 the per-source SCIP shard format is stable and the
ScipShardAggregator produces equivalent output to the legacy
SemanticDB->SCIP path. This commit promotes the cheap compiler-side
half of the dual-emission to be on by default so that:

  - any javac plugin invocation (sbt, Maven, Bazel, ad-hoc) writes a
    *.scip shard under META-INF/scip/ alongside the *.semanticdb file
    without needing an explicit -emit-scip:on flag;
  - users (or build tools) that want to consume the new path only need
    to flip the CLI switch (--use-scip-shards) once the indexer runs;
  - legacy callers that only read *.semanticdb files are unaffected.

The CLI default for index-semanticdb's --use-scip-shards remains false
because the broader ecosystem (notably the Kotlin compiler and the
existing snapshot/build tool integrations) still produces only
*.semanticdb. That flip is deferred to a follow-up PR.

  semanticdb-javac:
    - SemanticdbJavacOptions.emitScip defaults to true. -emit-scip:off
      is now the explicit opt-out and is documented as the legacy path.

  scip-java:
    - SnapshotCommand: skip per-source shards (those without a
      metadata.project_root) so 'scip-java snapshot' continues to render
      only the top-level aggregator output. Per-source shards have no
      project_root and would otherwise crash with 'missing scheme'
      when their relative paths are resolved into a URI.

  build.sbt:
    - Drop the now-redundant -emit-scip:on flag from the minimized
      project; the plugin default already emits shards.

  tests/unit:
    - ScipShardEmissionSuite: invert the off-path test so it explicitly
      passes -emit-scip:off; the previous test relied on the old
      default of false.

Full snapshot suite (102 tests) and unit suite (30 tests) green.

Author: jupblb

build.sbt

@@ -550,7 +550,6 @@ lazy val minimizedSettings = List[Def.Setting[_]](
       s"-build-tool:sbt",
       s"-text:on",
       s"-verbose",
-      s"-emit-scip:on",
       s"-sourceroot:${(ThisBuild / baseDirectory).value}",
       s"-targetroot:${(Compile / semanticdbTargetRoot).value}",
       s"-randomtimestamp=${System.nanoTime()}"

scip-java/src/main/scala/com/sourcegraph/scip_java/commands/SnapshotCommand.scala

@@ -51,31 +51,37 @@ case class SnapshotCommand(
               attrs: BasicFileAttributes
           ): FileVisitResult = {
             if (scipPattern.matches(file)) {
-              foundScipFile = true
               val index = Scip.Index.parseFrom(Files.readAllBytes(file))
-              val root = URI.create(index.getMetadata.getProjectRoot)
-              index
-                .getDocumentsList
-                .asScala
-                .foreach { doc =>
-                  val sourcepath = Paths.get(root.resolve(doc.getRelativePath))
-                  val source =
-                    new String(
-                      Files.readAllBytes(sourcepath),
-                      StandardCharsets.UTF_8
+              // Skip per-source shards emitted by the compiler plugin (those don't have a
+              // project_root). The aggregator produces a single top-level index file that
+              // carries the project_root and is the canonical input for snapshot rendering.
+              val rawProjectRoot = index.getMetadata.getProjectRoot
+              if (rawProjectRoot.nonEmpty) {
+                foundScipFile = true
+                val projectRoot = URI.create(rawProjectRoot)
+                index
+                  .getDocumentsList
+                  .asScala
+                  .foreach { doc =>
+                    val sourcepath = Paths.get(projectRoot.resolve(doc.getRelativePath))
+                    val source =
+                      new String(
+                        Files.readAllBytes(sourcepath),
+                        StandardCharsets.UTF_8
+                      )
+                    val document = ScipPrinters.printTextDocument(
+                      doc,
+                      source,
+                      CommentSyntax.default
                     )
-                  val document = ScipPrinters.printTextDocument(
-                    doc,
-                    source,
-                    CommentSyntax.default
-                  )
-                  val snapshotOutput = output.resolve(doc.getRelativePath)
-                  Files.createDirectories(snapshotOutput.getParent)
-                  Files.write(
-                    snapshotOutput,
-                    document.getBytes(StandardCharsets.UTF_8)
-                  )
-                }
+                    val snapshotOutput = output.resolve(doc.getRelativePath)
+                    Files.createDirectories(snapshotOutput.getParent)
+                    Files.write(
+                      snapshotOutput,
+                      document.getBytes(StandardCharsets.UTF_8)
+                    )
+                  }
+              }
             }
             super.visitFile(file, attrs)
           }

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/SemanticdbJavacOptions.java

@@ -25,11 +25,13 @@ public class SemanticdbJavacOptions {
   public boolean includeText = false;
   public boolean verboseEnabled = false;
   /**
-   * When {@code true}, the plugin also emits {@code *.scip} shards under {@code META-INF/scip/...}
-   * alongside the existing {@code *.semanticdb} files. Defaults to {@code false} during the
-   * SemanticDB→SCIP transition.
+   * Controls whether the plugin emits {@code *.scip} shards under {@code META-INF/scip/...}
+   * alongside the existing {@code *.semanticdb} files. Defaults to {@code true}: producing the
+   * extra shard is cheap and lets the {@code scip-java index-semanticdb --use-scip-shards}
+   * pipeline run without any additional compiler-side configuration. Legacy users that only
+   * consume {@code .semanticdb} are unaffected. Pass {@code -emit-scip:off} to disable.
    */
-  public boolean emitScip = false;
+  public boolean emitScip = true;
 
   public final ArrayList<String> errors;
   public boolean alreadyReportedErrors = false;

tests/unit/src/test/scala/tests/ScipShardEmissionSuite.scala

@@ -103,12 +103,17 @@ class ScipShardEmissionSuite extends FunSuite {
     assert(barText.contains("int bar("), s"unexpected bar signature: $barText")
   }
 
-  test("compiler does not emit SCIP shards when -emit-scip is off") {
+  test("compiler does not emit SCIP shards when -emit-scip:off is set") {
     val targetroot = Files.createTempDirectory("scip-shard-off-")
     val sourceroot = Files.createTempDirectory("scip-shard-off-src-")
     val compiler =
       new TestCompiler(TestCompiler.PROCESSOR_PATH, Nil, targetroot, sourceroot)
-    val result = compiler.compileSemanticdb(Seq(source))
+    val result = compiler.compile(
+      Seq(source),
+      List(
+        s"-Xplugin:semanticdb -emit-scip:off -text:on -sourceroot:$sourceroot -targetroot:$targetroot"
+      )
+    )
     assert(result.isSuccess, s"javac failed:\n${result.stdout}")
 
     val scipPath = targetroot.resolve("META-INF/scip/example/Foo.java.scip")