ADFA-3731: add cancellation support for Kotlin diagnostics

common/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
 
 	api(libs.androidx.core.ktx)
 	api(libs.common.kotlin)
+	api(libs.kotlinx.coroutines.core)
 
 	api(projects.buildInfo)
 	api(projects.eventbusAndroid)

common/src/main/java/com/itsaky/androidide/tasks/coroutineUtils.kt

@@ -27,6 +27,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
 import java.io.InterruptedIOException
 import kotlin.coroutines.CoroutineContext
@@ -44,8 +46,17 @@ class JobCancelChecker @JvmOverloads constructor(
 		job = null
 		super.cancel()
 	}
+
+	override fun abortIfCancelled() {
+		job?.ensureActive()
+	}
 }
 
+/**
+ * Create an [ICancelChecker] for the current [Job].
+ */
+suspend fun createJobCancelChecker() = JobCancelChecker(currentCoroutineContext()[Job])
+
 /**
  * Calls [CoroutineScope.cancel] only if a job is active in the scope.
  *
@@ -66,6 +77,8 @@ fun CoroutineScope.cancelIfActive(exception: CancellationException? = null) {
 	job?.cancel(exception)
 }
 
+suspend fun ensureCoroutineContextActive() = currentCoroutineContext().ensureActive()
+
 /**
  * Launches a new coroutine without blocking the current thread. This method shows a progress
  * indicator using [Flashbar] while the [action] is being executed. The [Flashbar] is automatically

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

@@ -0,0 +1,5 @@
+package com.itsaky.androidide.utils
+
+inline fun <E, T: Collection<E>> T.ifNotEmpty(crossinline action: T.() -> Unit) {
+	if (isNotEmpty()) action()
+}

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

@@ -0,0 +1,69 @@
+package com.itsaky.androidide.utils
+
+import com.itsaky.androidide.progress.ICancelChecker
+import com.itsaky.androidide.tasks.JobCancelChecker
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.CoroutineContext
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+
+class KeyedDebouncingAction<T: Any>(
+	private val scope: CoroutineScope,
+	private val debounceDuration: Duration = DEBOUNCE_DURATION_DEFAULT,
+	private val actionContext: CoroutineContext = Dispatchers.Default,
+	private val action: suspend (T, ICancelChecker) -> Unit,
+) {
+
+	private data class ActionEntry<T>(
+		val channel: Channel<T>,
+		val job: Job,
+	) {
+		fun cancel() {
+			channel.close()
+			job.cancel()
+		}
+	}
+
+	private val pending = ConcurrentHashMap<T, ActionEntry<T>>()
+
+	companion object {
+		val DEBOUNCE_DURATION_DEFAULT = 400.milliseconds
+	}
+
+	fun cancelPending(key: T) {
+		pending.remove(key)?.cancel()
+	}
+
+	fun schedule(key: T) {
+		val entry = pending.computeIfAbsent(key) { createEntry() }
+		entry.channel.trySend(key)
+	}
+
+	private fun createEntry(): ActionEntry<T> {
+		val channel = Channel<T>(Channel.CONFLATED)
+		val job = scope.launch(actionContext) {
+			for (latestKey in channel) {
+				delay(debounceDuration)
+				ensureActive()
+
+				val cancelChecker = JobCancelChecker(currentCoroutineContext()[Job])
+				action(latestKey, cancelChecker)
+			}
+		}
+
+		return ActionEntry(channel, job)
+	}
+
+	fun cancelAll() {
+		pending.values.forEach { it.cancel() }
+		pending.clear()
+	}
+}

logger/src/main/java/com/itsaky/androidide/logging/utils/LogUtils.java

@@ -27,7 +27,7 @@
 public class LogUtils {
 
     public static final int MAX_TAG_LENGTH = 23;
-    public static final String PATTERN_LAYOUT_MESSAGE_PATTERN = "%msg%n";
+    public static final String PATTERN_LAYOUT_MESSAGE_PATTERN = "[%thread] %msg%n";
 
     public static boolean isJvm() {
         try {

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/KotlinLanguageServer.kt

@@ -22,7 +22,7 @@ import com.itsaky.androidide.app.configuration.IJdkDistributionProvider
 import com.itsaky.androidide.eventbus.events.editor.DocumentChangeEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentCloseEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
-import com.itsaky.androidide.eventbus.events.editor.DocumentSelectedEvent
+import com.itsaky.androidide.eventbus.events.editor.DocumentSaveEvent
 import com.itsaky.androidide.lsp.api.ILanguageClient
 import com.itsaky.androidide.lsp.api.ILanguageServer
 import com.itsaky.androidide.lsp.api.IServerSettings
@@ -48,17 +48,14 @@ import com.itsaky.androidide.models.Range
 import com.itsaky.androidide.projects.FileManager
 import com.itsaky.androidide.projects.ProjectManagerImpl
 import com.itsaky.androidide.projects.api.Workspace
+import com.itsaky.androidide.tasks.createJobCancelChecker
 import com.itsaky.androidide.utils.DocumentUtils
 import com.itsaky.androidide.utils.Environment
+import com.itsaky.androidide.utils.ifNotEmpty
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import org.appdevforall.codeonthego.indexing.jvm.JvmLibraryIndexingService
 import org.appdevforall.codeonthego.indexing.jvm.JvmSymbolIndex
 import org.appdevforall.codeonthego.indexing.jvm.KtFileMetadataIndex
@@ -69,23 +66,19 @@ import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.slf4j.LoggerFactory
-import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
-import kotlin.time.Duration.Companion.milliseconds
 
 class KotlinLanguageServer : ILanguageServer {
 
 	private var _client: ILanguageClient? = null
 	private var _settings: IServerSettings? = null
-	private var selectedFile: Path? = null
 	private var initialized = false
 
 	private val scope =
 		CoroutineScope(SupervisorJob() + CoroutineName(KotlinLanguageServer::class.simpleName!!))
 	private var projectModel: KotlinProjectModel? = null
 	private var compiler: Compiler? = null
-	private var analyzeJob: Job? = null
 
 	override val serverId: String = SERVER_ID
 
@@ -96,7 +89,6 @@ class KotlinLanguageServer : ILanguageServer {
 		get() = _settings ?: KotlinServerSettings.getInstance().also { _settings = it }
 
 	companion object {
-		private val ANALYZE_DEBOUNCE_DELAY = 400.milliseconds
 
 		const val SERVER_ID = "ide.lsp.kotlin"
 		private val logger = LoggerFactory.getLogger(KotlinLanguageServer::class.java)
@@ -121,6 +113,7 @@ class KotlinLanguageServer : ILanguageServer {
 
 	override fun connectClient(client: ILanguageClient?) {
 		this._client = client
+		this.compiler?.updateLanguageClient(client)
 	}
 
 	override fun applySettings(settings: IServerSettings?) {
@@ -184,13 +177,22 @@ class KotlinLanguageServer : ILanguageServer {
 				languageVersion = LanguageVersion.LATEST_STABLE,
 			)
 
+			compiler.updateLanguageClient(client)
 			this.compiler = compiler
 		} else {
 			logger.info("Updating project model")
-
 			projectModel?.update(workspace, jvmPlatform)
 		}
 
+		// Open already open files
+		// we won't get an event for these
+		FileManager.activeDocuments.ifNotEmpty {
+			forEach { document ->
+				compiler?.compilationEnvironmentFor(document.file)
+					?.openFileIfNeeded(document.file)
+			}
+		}
+
 		initialized = true
 		logger.info("Kotlin project initialized")
 	}
@@ -262,7 +264,8 @@ class KotlinLanguageServer : ILanguageServer {
 			return DiagnosticResult.NO_UPDATE
 		}
 
-		return compiler?.compilationEnvironmentFor(file)?.collectDiagnosticsFor(file)
+		return compiler?.compilationEnvironmentFor(file)
+			?.let { context(it) { collectDiagnosticsFor(file, createJobCancelChecker()) } }
 			?: DiagnosticResult.NO_UPDATE
 	}
 
@@ -273,32 +276,8 @@ class KotlinLanguageServer : ILanguageServer {
 			return
 		}
 
-		compiler?.compilationEnvironmentFor(event.openedFile)?.apply {
-			onFileOpen(event.openedFile)
-		}
-
-		selectedFile = event.openedFile
-		debouncingAnalyze()
-	}
-
-	private fun debouncingAnalyze() {
-		analyzeJob?.cancel()
-		analyzeJob = scope.launch(Dispatchers.Default) {
-			delay(ANALYZE_DEBOUNCE_DELAY)
-			analyzeSelected()
-		}
-	}
-
-	private suspend fun analyzeSelected() {
-		val file = selectedFile ?: return
-		val client = _client ?: return
-
-		if (!Files.exists(file)) return
-
-		val result = analyze(file)
-		withContext(Dispatchers.Main) {
-			client.publishDiagnostics(result)
-		}
+		compiler?.compilationEnvironmentFor(event.openedFile)
+			?.onFileOpen(event.openedFile)
 	}
 
 	@Subscribe(threadMode = ThreadMode.ASYNC)
@@ -308,11 +287,9 @@ class KotlinLanguageServer : ILanguageServer {
 			return
 		}
 
-		compiler?.compilationEnvironmentFor(event.changedFile)?.apply {
-			onFileContentChanged(event.changedFile)
-		}
+		compiler?.compilationEnvironmentFor(event.changedFile)
+			?.onFileContentChanged(event.changedFile)
 
-		debouncingAnalyze()
 	}
 
 	@Subscribe(threadMode = ThreadMode.ASYNC)
@@ -322,26 +299,19 @@ class KotlinLanguageServer : ILanguageServer {
 			return
 		}
 
-		compiler?.compilationEnvironmentFor(event.closedFile)?.apply {
-			onFileClosed(event.closedFile)
-		}
+		compiler?.compilationEnvironmentFor(event.closedFile)
+			?.onFileClosed(event.closedFile)
 
-		if (FileManager.getActiveDocumentCount() == 0) {
-			selectedFile = null
-			analyzeJob?.cancel("No active files")
-		}
 	}
 
 	@Subscribe(threadMode = ThreadMode.ASYNC)
 	@Suppress("unused")
-	fun onDocumentSelected(event: DocumentSelectedEvent) {
-		if (!DocumentUtils.isKotlinFile(event.selectedFile)) {
+	fun onDocumentSaved(event: DocumentSaveEvent) {
+		if (!DocumentUtils.isKotlinFile(event.savedFile)) {
 			return
 		}
 
-		selectedFile = event.selectedFile
-		val uri = event.selectedFile.toUri().toString()
-
-		logger.debug("onDocumentSelected: uri={}", uri)
+		compiler?.compilationEnvironmentFor(event.savedFile)
+			?.onFileSaved(event.savedFile)
 	}
 }