ADFA-4328: tolerate channel close in KeyedDebouncingAction

Sentry APPDEVFORALL-14C. Cancel job before closing channel, use
receiveCatching, add a CoroutineExceptionHandler to the LSP scope.

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

Author: fryanpan

common/src/main/java/com/itsaky/androidide/utils/KeyedDebouncingAction.kt

@@ -2,11 +2,13 @@ package com.itsaky.androidide.utils
 
 import com.itsaky.androidide.progress.ICancelChecker
 import com.itsaky.androidide.tasks.JobCancelChecker
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.isActive
@@ -30,8 +32,11 @@ class KeyedDebouncingAction<T: Any>(
 		val job: Job,
 	) {
 		fun cancel() {
-			channel.close()
+			// Cancel the job FIRST, then close the channel. Closing the channel first
+			// wakes a parked receive() with a ClosedReceiveChannelException before the
+			// job is cancelled, which can crash a worker that has no exception handling.
 			job.cancel()
+			channel.close()
 		}
 	}
 
@@ -55,33 +60,41 @@ class KeyedDebouncingAction<T: Any>(
 		val channel = Channel<T>(Channel.CONFLATED)
 		val job = scope.launch(actionContext) {
 			while (isActive) {
-				var latestKey = channel.receive()
-				var debouncing = true
-				while (debouncing) {
-					debouncing = select {
-						onTimeout(debounceDuration) { false }
-						channel.onReceive { newKey ->
-							latestKey = newKey
-							true
+				try {
+					var latestKey = channel.receive()
+					var debouncing = true
+					while (debouncing) {
+						debouncing = select {
+							onTimeout(debounceDuration) { false }
+							channel.onReceive { newKey ->
+								latestKey = newKey
+								true
+							}
 						}
 					}
-				}
 
-				ensureActive()
-				val actionJob = launch {
-					val cancelChecker = JobCancelChecker(currentCoroutineContext()[Job])
-					action(latestKey, cancelChecker)
-				}
+					ensureActive()
+					val actionJob = launch {
+						val cancelChecker = JobCancelChecker(currentCoroutineContext()[Job])
+						action(latestKey, cancelChecker)
+					}
 
-				select<Unit> {
-					actionJob.onJoin {}
-					channel.onReceive { newerKey ->
-						actionJob.cancel()
-						channel.trySend(newerKey)
+					select<Unit> {
+						actionJob.onJoin {}
+						channel.onReceive { newerKey ->
+							actionJob.cancel()
+							channel.trySend(newerKey)
+						}
 					}
-				}
 
-				actionJob.join()
+					actionJob.join()
+				} catch (e: ClosedReceiveChannelException) {
+					// The channel was closed (entry cancelled). Stop the worker cleanly
+					// instead of letting the exception propagate to an uncaught handler.
+					break
+				} catch (e: CancellationException) {
+					throw e
+				}
 			}
 		}
 

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/compiler/CompilationEnvironment.kt

@@ -17,6 +17,8 @@ import com.itsaky.androidide.projects.FileManager
 import com.itsaky.androidide.projects.api.Workspace
 import com.itsaky.androidide.utils.KeyedDebouncingAction
 import io.sentry.Sentry
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -66,7 +68,14 @@ internal class CompilationEnvironment(
 	languageVersion: LanguageVersion = DEFAULT_LANGUAGE_VERSION,
 	enableParserEventSystem: Boolean = true,
 	val coroutineScope: CoroutineScope = CoroutineScope(
-		SupervisorJob() + CoroutineName("CompilationEnv[$name]")
+		SupervisorJob() + CoroutineName("CompilationEnv[$name]") +
+			CoroutineExceptionHandler { _, t ->
+				// Defense in depth: swallow (but log) non-cancellation failures from the
+				// debounce worker so a ClosedReceiveChannelException can never crash the app.
+				if (t !is CancellationException) {
+					logger.warn("Uncaught exception in compilation environment coroutine", t)
+				}
+			}
 	),
 ) : AbstractCompilationEnvironment(
 	name = name,