ADFA-4174: prioritize code completion requests over analyze requests

.claude/.gitignore

@@ -0,0 +1,12 @@
+# Local, machine-specific settings (not shared)
+settings.local.json
+
+# Claude Code worktrees
+worktrees/
+
+# Session/runtime artifacts
+projects/
+todos/
+shell-snapshots/
+statsig/
+.credentials.json

build.gradle.kts

@@ -96,11 +96,16 @@ subprojects {
         //     setAccessible on java.lang.Class fields.
         //   - java.base/java.io, java.util: needed by Robolectric/Gradle worker
         //     reflection in the same test JVM.
+        //   - java.base/java.util.concurrent: the embedded IntelliJ scheduler
+        //     reflectively reads FutureTask.callable; without this its periodic
+        //     thread dies, disabling the cancellation poll that makes the Kotlin
+        //     Analysis API interruptible mid-`analyze`.
         jvmArgs(
             "--add-opens=java.base/java.lang=ALL-UNNAMED",
             "--add-opens=java.base/java.lang.reflect=ALL-UNNAMED",
             "--add-opens=java.base/java.io=ALL-UNNAMED",
             "--add-opens=java.base/java.util=ALL-UNNAMED",
+            "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
             "--add-opens=jdk.unsupported/sun.misc=ALL-UNNAMED",
         )
 

editor/src/main/java/com/itsaky/androidide/editor/language/IDELanguage.kt

@@ -25,6 +25,7 @@ import com.itsaky.androidide.lsp.debug.model.BreakpointDefinition
 import com.itsaky.androidide.lsp.debug.model.BreakpointRequest
 import com.itsaky.androidide.preferences.internal.EditorPreferences
 import com.itsaky.androidide.progress.ICancelChecker
+import com.itsaky.androidide.progress.ProgressManager
 import io.github.rosemoe.sora.lang.Language
 import io.github.rosemoe.sora.lang.completion.CompletionCancelledException
 import io.github.rosemoe.sora.lang.completion.CompletionPublisher
@@ -67,11 +68,17 @@ abstract class IDELanguage : Language {
 		publisher: CompletionPublisher,
 		extraArguments: Bundle
 	) {
+		val completionThread = Thread.currentThread()
 		try {
 			val cancelChecker = CompletionCancelChecker(publisher)
 			Lookup.getDefault().update(ICancelChecker::class.java, cancelChecker)
+			// Bind the checker to this thread so cancelCompletion()'s ProgressManager.cancel(thread)
+			// routes here, letting the LSP's invokeOnCancel abort the running analysis mid-`analyze`
+			// immediately rather than only at coarse checkpoints.
+			ProgressManager.instance.register(completionThread, cancelChecker)
 			doComplete(content, position, publisher, cancelChecker, extraArguments)
 		} finally {
+			ProgressManager.instance.unregister(completionThread)
 			Lookup.getDefault().unregister(
 				ICancelChecker::class.java
 			)

editor/src/main/java/com/itsaky/androidide/editor/ui/EditorCompletionWindow.kt

@@ -41,9 +41,18 @@ class EditorCompletionWindow(val editor: IDEEditor) : EditorAutoCompletion(edito
     private var listView: ListView? = null
     private val items: MutableList<CompletionItem> = mutableListOf()
 
+    /**
+     * A scheduled-but-not-yet-started completion request, kept so a newer keystroke can cancel it.
+     * See [requireCompletion].
+     */
+    private var pendingCompletion: Runnable? = null
+
     companion object {
 
         private val log = LoggerFactory.getLogger(EditorCompletionWindow::class.java)
+
+        /** Quiet period for coalescing a keystroke burst: analysis runs only after typing pauses this long. */
+        private const val COMPLETION_DEBOUNCE_MS = 80L
     }
 
     init {
@@ -119,29 +128,54 @@ class EditorCompletionWindow(val editor: IDEEditor) : EditorAutoCompletion(edito
     }
 
     override fun cancelCompletion() {
+        // Drop any request that was scheduled but hasn't started yet.
+        pendingCompletion?.let { editor.handler.removeCallbacks(it) }
+        pendingCompletion = null
         if (completionThread != null) {
             ProgressManager.instance.cancel(completionThread)
         }
         super.cancelCompletion()
     }
 
-    override fun requireCompletion() {
+    /** Whether completion may run now; hides the window when the cursor is selected or otherwise not applicable. */
+    private fun canStartCompletion(): Boolean {
         if (cancelShowUp || !isEnabled || !editor.isAttachedToWindow) {
-            return
+            return false
         }
-
-        val text = editor.text
-        if (text.cursor.isSelected || checkNoCompletion()) {
+        if (editor.text.cursor.isSelected || checkNoCompletion()) {
             hide()
-            return
+            return false
         }
+        return true
+    }
 
-        if (System.nanoTime() - requestTime < editor.props.cancelCompletionNs) {
-            requestTime = System.nanoTime()
+    /**
+     * Coalesces a keystroke burst into one completion for the latest cursor position, keeping at most one
+     * analysis in flight. This prevents the CompletionThread/allocation pile-up that saturated the heap and
+     * froze the editor during fast typing.
+     */
+    override fun requireCompletion() {
+        if (!canStartCompletion()) {
             return
         }
 
+        // cancelCompletion() clears any in-flight and pending request, so we then schedule exactly one.
         cancelCompletion()
+
+        val request = Runnable { startCompletion() }
+        pendingCompletion = request
+        editor.handler.postDelayed(request, COMPLETION_DEBOUNCE_MS)
+    }
+
+    /** Runs on the UI thread. */
+    private fun startCompletion() {
+        pendingCompletion = null
+
+        // Editor state may have changed during the debounce delay; re-check the guards.
+        if (!canStartCompletion()) {
+            return
+        }
+
         requestTime = System.nanoTime()
         currentSelection = -1