Skip files the Kotlin analysis cannot handle, and always exit

A top-level destructuring declaration in a .kt file (`val (a, b) = ...`)
is not valid Kotlin, so the Analysis API has no FIR for it, and asking for
its type threw "No fir element was found for KtDestructuringDeclaration".
That exception aborted the whole run. Afterwards a non-daemon pooled
thread kept the JVM alive, so the process hung instead of exiting.

- Skip a top-level destructuring declaration instead of resolving it.
- If indexing a file throws, skip that file (no shard, one line on
  stderr) and keep indexing the rest.
- Exit with status 1 when the run fails, so the process never hangs.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: ofir-blaus

scip-kotlin-analysis/src/main/kotlin/org/scip_code/scip_java/kotlin_analysis/KotlinAnalysisIndexer.kt

@@ -126,7 +126,16 @@ class KotlinAnalysisIndexer(
             val documents = mutableListOf<Document>()
             val ktFiles = session.modulesWithFiles.values.flatten().filterIsInstance<KtFile>()
             for (ktFile in ktFiles) {
-                val document = indexFile(ktFile)
+                val document =
+                    try {
+                        indexFile(ktFile)
+                    } catch (e: Exception) {
+                        val reason = e.message?.lineSequence()?.firstOrNull()
+                        System.err.println(
+                            "scip-kotlin-analysis: skipped ${ktFile.virtualFilePath}: ${e.javaClass.name}: $reason"
+                        )
+                        continue
+                    }
                 writeShard(ktFile, document)
                 callback(document)
                 documents.add(document)
@@ -583,6 +592,7 @@ class KotlinAnalysisIndexer(
         override fun visitDestructuringDeclaration(
             destructuringDeclaration: KtDestructuringDeclaration
         ) {
+            if (destructuringDeclaration.parent is KtFile) return
             val isParameter = destructuringDeclaration.parent is KtParameter
             val type =
                 destructuringDeclaration.initializer?.let { renderedExpressionType(it) }

scip-kotlin-analysis/src/main/kotlin/org/scip_code/scip_java/kotlin_analysis/Main.kt

@@ -37,15 +37,20 @@ fun main(args: Array<String>) {
     require(sourceroot != null) { "missing required flag: --sourceroot" }
     require(targetroot != null) { "missing required flag: --targetroot" }
     require(sourceRoots.isNotEmpty()) { "missing source files or directories" }
-    KotlinAnalysisIndexer(
-            sourceroot = sourceroot,
-            targetroot = targetroot,
-            sourceRoots = sourceRoots,
-            classpath = classpath,
-            jdkHome = jdkHome,
-        )
-        .run()
     // The Analysis API environment leaves non-daemon threads behind; exit
     // explicitly so callers are not left waiting on them.
+    try {
+        KotlinAnalysisIndexer(
+                sourceroot = sourceroot,
+                targetroot = targetroot,
+                sourceRoots = sourceRoots,
+                classpath = classpath,
+                jdkHome = jdkHome,
+            )
+            .run()
+    } catch (e: Throwable) {
+        e.printStackTrace()
+        exitProcess(1)
+    }
     exitProcess(0)
 }

scip-kotlin-analysis/src/test/kotlin/org/scip_code/scip_java/kotlin_analysis/KotlinAnalysisIndexerTest.kt

@@ -93,6 +93,50 @@ class KotlinAnalysisIndexerTest {
         )
     }
 
+    @Test
+    fun `a top-level destructuring in a kt file is skipped, not the file or the run`() {
+        val sourceroot = Files.createTempDirectory("scip-kotlin-analysis").toRealPath()
+        val src = Files.createDirectories(sourceroot.resolve("src"))
+        Files.writeString(
+            src.resolve("Broken.kt"),
+            """
+            |package snapshots
+            |
+            |fun before(): Int = 1
+            |
+            |val (first, second) = Pair(1, 2)
+            |
+            |fun after(): Int = before()
+            """
+                .trimMargin(),
+        )
+        Files.writeString(
+            src.resolve("Other.kt"),
+            """
+            |package snapshots
+            |
+            |fun other(): Int = after()
+            """
+                .trimMargin(),
+        )
+        val documents =
+            KotlinAnalysisIndexer(
+                    sourceroot = sourceroot,
+                    targetroot = sourceroot.resolve("scip-targetroot"),
+                    sourceRoots = listOf(src),
+                    classpath = listOf(kotlinStdlibJar()),
+                )
+                .run()
+                .sortedBy { it.relativePath }
+
+        assertEquals(listOf("src/Broken.kt", "src/Other.kt"), documents.map { it.relativePath })
+        val broken = definitions(documents[0])
+        assertContains(broken, "snapshots/before().")
+        assertContains(broken, "snapshots/after().")
+        assertContains(references(documents[0]), "snapshots/before().")
+        assertContains(references(documents[1]), "snapshots/after().")
+    }
+
     private fun definitions(document: Document): List<String> =
         document.occurrencesList
             .filter { it.symbolRoles and SymbolRole.Definition.number != 0 }