ADFA-5231: name the diagnostics reschedule as a self-cancelling send

Author: itsaky-adfa

common/src/test/java/com/itsaky/androidide/utils/KeyedDebouncingActionSelfScheduleTest.kt

@@ -0,0 +1,58 @@
+package com.itsaky.androidide.utils
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Scheduling the key an action is *currently running for* cancels that run.
+ *
+ * The worker races `actionJob.onJoin` against `channel.onReceive`, so a send from inside the action
+ * is indistinguishable from a newer key arriving: the receive wins, the in-flight job is cancelled,
+ * and the key is re-sent. `KotlinDiagnosticProvider` relies on both halves of that - it reschedules
+ * from inside its own action and expects the analysis it just discarded to run again.
+ */
+class KeyedDebouncingActionSelfScheduleTest {
+	private companion object {
+		const val SECOND_RUN_TIMEOUT_SECONDS = 5L
+	}
+
+	@Test
+	fun `scheduling from inside the action cancels that run and re-runs it`() =
+		runBlocking {
+			val runs = AtomicInteger(0)
+			val firstRunFinished = AtomicBoolean(false)
+			val secondRunStarted = CountDownLatch(1)
+			lateinit var debouncer: KeyedDebouncingAction<String>
+
+			debouncer =
+				KeyedDebouncingAction(
+					scope = CoroutineScope(SupervisorJob()),
+					debounceDuration = 20.milliseconds,
+					action = { key, _ ->
+						if (runs.incrementAndGet() == 1) {
+							debouncer.schedule(key)
+							// A suspension point is where the cancellation from the self-send takes effect.
+							delay(200)
+							firstRunFinished.set(true)
+						} else {
+							secondRunStarted.countDown()
+						}
+					},
+				)
+
+			debouncer.schedule("k")
+
+			assertThat(secondRunStarted.await(SECOND_RUN_TIMEOUT_SECONDS, TimeUnit.SECONDS)).isTrue()
+			assertThat(firstRunFinished.get()).isFalse()
+			debouncer.cancelAll()
+		}
+}

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/diagnostic/KotlinDiagnosticProvider.kt

@@ -143,6 +143,12 @@ private fun doAnalyze(
 
 	if (superseded) {
 		logger.debug("dropping superseded diagnostics for {}", file)
+		/*
+		 * On the debounced path this is a self-send: doAnalyze runs as fileAnalyzer's own action, so the
+		 * send reads to the worker as a newer key and cancels the run it came from. Deliberate - the
+		 * reschedule still lands, and the only casualty is the NO_UPDATE publish below, which had nothing
+		 * to say anyway. Reached from KotlinLanguageServer.analyze() instead, it is a plain reschedule.
+		 */
 		env.fileAnalyzer.schedule(file)
 	} else {
 		logger.warn("File {} is not accessible", file)