ADFA-4165: flawed logic in KeyedDebouncingAction (#1347)

* fix: flawed logic in KeyedDebouncingAction
* fix: update variable names

Signed-off-by: Akash Yadav <akashyadav@appdevforall.org>

Author: itsaky-adfa

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

@@ -4,12 +4,15 @@ import com.itsaky.androidide.progress.ICancelChecker
 import com.itsaky.androidide.tasks.JobCancelChecker
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.selects.onTimeout
+import kotlinx.coroutines.selects.select
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.coroutines.CoroutineContext
 import kotlin.time.Duration
@@ -47,15 +50,38 @@ class KeyedDebouncingAction<T: Any>(
 		entry.channel.trySend(key)
 	}
 
+	@OptIn(ExperimentalCoroutinesApi::class)
 	private fun createEntry(): ActionEntry<T> {
 		val channel = Channel<T>(Channel.CONFLATED)
 		val job = scope.launch(actionContext) {
-			for (latestKey in channel) {
-				delay(debounceDuration)
+			while (isActive) {
+				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)
+				}
+
+				select<Unit> {
+					actionJob.onJoin {}
+					channel.onReceive { newerKey ->
+						actionJob.cancel()
+						channel.trySend(newerKey)
+					}
+				}
 
-				val cancelChecker = JobCancelChecker(currentCoroutineContext()[Job])
-				action(latestKey, cancelChecker)
+				actionJob.join()
 			}
 		}
 

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

@@ -1,10 +1,13 @@
 package com.itsaky.androidide.utils
 
 import android.os.StrictMode
+import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
 @PublishedApi
-internal val logger = LoggerFactory.getLogger("StrictModeExts")
+internal object StrictModeExts {
+	val logger: Logger = LoggerFactory.getLogger("StrictModeExts")
+}
 
 inline fun copyThreadPolicy(
 	source: StrictMode.ThreadPolicy,
@@ -24,7 +27,7 @@ inline fun <R> permitThreadPolicy(
 	val currentPolicy = StrictMode.getThreadPolicy()
 	val newPolicy = copyThreadPolicy(currentPolicy, configurePolicy)
 	return try {
-		logger.warn("Allowing {} because: {}", action, reason)
+		StrictModeExts.logger.warn("Allowing {} because: {}", action, reason)
 		StrictMode.setThreadPolicy(newPolicy)
 		task()
 	} finally {

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

@@ -523,6 +523,7 @@ internal class CompilationEnvironment(
 	}
 
 	fun onFileContentChanged(path: Path) {
+		val oldKtFile = ktSymbolIndex.getOpenedKtFile(path)
 		val newContent = FileManager.getDocumentContents(path)
 		val newKtFile = project.read {
 			parser.createFile(path.pathString, newContent)
@@ -534,12 +535,14 @@ internal class CompilationEnvironment(
 		val provider = ProjectStructureProvider.getInstance(project)
 		provider.registerInMemoryFile(path.pathString, newKtFile.virtualFile)
 
-		ktSymbolIndex.openKtFile(path, newKtFile)
-		ktSymbolIndex.queueOnFileChangedAsync(newKtFile)
-		fileAnalyzer.schedule(path)
 		project.write {
+			val toInvalidate = oldKtFile ?: newKtFile
 			KaSourceModificationService.getInstance(project)
-				.handleElementModification(newKtFile, KaElementModificationType.Unknown)
+				.handleElementModification(toInvalidate, KaElementModificationType.Unknown)
+
+			ktSymbolIndex.openKtFile(path, newKtFile)
+			ktSymbolIndex.queueOnFileChangedAsync(newKtFile)
+			fileAnalyzer.schedule(path)
 		}
 	}
 

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

@@ -3,7 +3,6 @@ package com.itsaky.androidide.lsp.kotlin.compiler.index
 import com.itsaky.androidide.lsp.kotlin.compiler.CompilationEnvironment
 import com.itsaky.androidide.lsp.kotlin.compiler.modules.backingFilePath
 import com.itsaky.androidide.lsp.kotlin.compiler.read
-import com.itsaky.androidide.lsp.kotlin.utils.toNioPathOrNull
 import com.itsaky.androidide.progress.ICancelChecker
 import com.itsaky.androidide.utils.KeyedDebouncingAction
 import kotlinx.coroutines.CoroutineScope

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

@@ -144,17 +144,6 @@ internal class KtSymbolIndex(
 		indexWorker.submitCommand(IndexCommand.RemoveFromIndex(path))
 	}
 
-	suspend fun onFileMoved(from: Path, to: Path) {
-		// always remove the source file from index
-		indexWorker.submitCommand(IndexCommand.RemoveFromIndex(from))
-
-		val toVf = getVirtualFileOrWarn(to) ?: return
-		indexWorker.apply {
-			submitCommand(IndexCommand.ScanSourceFile(toVf))
-			submitCommand(IndexCommand.IndexSourceFile(toVf))
-		}
-	}
-
 	fun queueOnFileChangedAsync(ktFile: KtFile) {
 		scope.launch {
 			queueOnFileChanged(ktFile)
@@ -165,8 +154,8 @@ internal class KtSymbolIndex(
 		indexWorker.submitCommand(IndexCommand.IndexModifiedFile(ktFile))
 	}
 
-	fun openKtFile(path: Path, ktFile: KtFile) {
-		openedFiles[path] = ktFile
+	fun openKtFile(path: Path, ktFile: KtFile): KtFile? {
+		return openedFiles.put(path, ktFile)
 	}
 
 	fun closeKtFile(path: Path) {
@@ -175,15 +164,30 @@ internal class KtSymbolIndex(
 
 	fun getOpenedKtFile(path: Path) = openedFiles[path]
 
-	fun getKtFile(vf: VirtualFile): KtFile? {
-		val path = vf.toNioPath()
+	fun getKtFile(vf: VirtualFile): KtFile? =
+		getKtFile(vf.toNioPath(), vf)
+
+	fun getKtFile(path: Path, virtualFile: VirtualFile? = null): KtFile? {
 		if (!DocumentUtils.isKotlinFile(path)) return null
 
-		openedFiles[path]?.also { return it }
-		ktFileCache.getIfPresent(path)?.also { return it }
+		openedFiles[path]?.also {
+			return it
+		}
+
+		ktFileCache.getIfPresent(path)?.also {
+			return it
+		}
 
-		val ktFile = loadKtFile(vf)
+		var file = virtualFile
+		if (file == null) {
+			file = path.toVirtualFileOrNull()
+		}
+
+		if (file == null) {
+			return null
+		}
 
+		val ktFile = loadKtFile(file)
 		ktFileCache.put(path, ktFile)
 		return ktFile
 	}

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

@@ -10,7 +10,6 @@ import com.itsaky.androidide.lsp.models.DiagnosticSeverity
 import com.itsaky.androidide.progress.ICancelChecker
 import kotlinx.coroutines.CancellationException
 import org.jetbrains.kotlin.analysis.api.KaExperimentalApi
-import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.components.KaDiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.api.diagnostics.KaDiagnosticWithPsi
 import org.jetbrains.kotlin.analysis.api.diagnostics.KaSeverity
@@ -31,14 +30,14 @@ internal data class KotlinDiagnosticExtra(
 context(env: CompilationEnvironment)
 internal fun collectDiagnosticsFor(file: Path, cancelChecker: ICancelChecker): DiagnosticResult {
 	try {
-		logger.info("Analyzing file: {}", file)
+		logger.info("analyzing file: {}", file)
 		return doAnalyze(file, cancelChecker)
 	} catch (err: Throwable) {
 		if (err is CancellationException) {
 			logger.debug("analysis cancelled")
 			throw err
 		}
-		logger.error("An error occurred analyzing file: {}", file, err)
+		logger.error("an error occurred analyzing file: {}", file, err)
 		return DiagnosticResult.NO_UPDATE
 	}
 }
@@ -75,7 +74,7 @@ private fun doAnalyze(file: Path, cancelChecker: ICancelChecker): DiagnosticResu
 			// This should be canceled as well
 			// The analysis API uses a no-op implementation of
 			// Intellij's ProgressManager for cancellations, so the following
-			// is really cancellable at the moment
+			// isn't really cancellable at the moment
 			analyzeMaybeDangling(ktFile) {
 				ktFile.collectDiagnostics(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS)
 					.forEach { diagnostic ->