Merge branch 'stage' into ADFA-5446-Extension-Manager-uninstall-broken

Author: jimturner-adfa

.github/workflows/debug.yml

@@ -228,8 +228,15 @@ jobs:
       - name: Assemble Universal APK
         run: |
           echo "gradle_time_start=$(date +%s)" >> $GITHUB_ENV
-          flox activate -d flox/base -- ./gradlew :app:assembleV8Debug --no-daemon
+          set -o pipefail
+          flox activate -d flox/base -- ./gradlew :app:assembleV8Debug --no-daemon 2>&1 | tee "$RUNNER_TEMP/assemble.log"
           echo "gradle_time_end=$(date +%s)" >> $GITHUB_ENV
+          # D8 logs this (non-fatal) once per class when the pinned R8 is older than the Kotlin
+          # metadata version, burying every real diagnostic. See the `r8` pin in libs.versions.toml.
+          if grep -q "Unexpected error during rewriting of Kotlin metadata" "$RUNNER_TEMP/assemble.log"; then
+            echo "::error::D8 could not rewrite Kotlin metadata. Most likely the R8 pinned in gradle/libs.versions.toml is older than the Kotlin metadata version (bump 'r8'), or the pin no longer takes effect on the build classpath. See ADFA-6822."
+            exit 1
+          fi
 
 
       - name: Find APK file

app/src/main/java/com/itsaky/androidide/quickbuild/QuickBuildOutputLines.kt

@@ -83,10 +83,7 @@ fun quickBuildOutputLines(
 					// of narrating upcoming work.
 					listOf("the rebuild failed - save a fix to retry.")
 				} else {
-					listOf(
-						"a full build is needed - ${describe(transition.reason)}. " +
-							"Tap Quick Build to rebuild.",
-					)
+					listOf("a full build is needed - ${describe(transition.reason)}. Starting it now.")
 				}
 			}
 

app/src/test/java/com/itsaky/androidide/quickbuild/QuickBuildOutputLinesTest.kt

@@ -251,15 +251,16 @@ class QuickBuildOutputLinesTest {
 	}
 
 	@Test
-	fun `invalidation reads as information and names a next step`() {
+	fun `invalidation reads as information and says the full build is starting`() {
 		val emitted =
 			lines(
 				QuickBuildStatus.UpToDate(4L, buildDurationMillis = null),
 				QuickBuildStatus.NeedsFullBuild(InvalidationReason.MANIFEST_CHANGED, 4L),
 			).joinToString("")
 
 		assertThat(emitted).contains("the manifest changed")
-		assertThat(emitted).contains("Tap Quick Build")
+		assertThat(emitted).contains("Starting it now")
+		assertThat(emitted).doesNotContain("Tap")
 		// Not a failure - a full build is the normal answer to an unabsorbable edit.
 		assertThat(emitted).doesNotContain("failed")
 	}

app/src/test/java/com/itsaky/androidide/quickbuild/QuickBuildStatusBarTest.kt

@@ -320,7 +320,7 @@ class QuickBuildStatusBarTest {
 	}
 
 	@Test
-	fun `an invalidation names the full-build ask`() {
+	fun `an invalidation says the full build is starting`() {
 		val shown =
 			update(
 				QuickBuildStatus.UpToDate(4L, null),

build.gradle.kts

@@ -62,6 +62,8 @@ jacoco {
 
 buildscript {
 	dependencies {
+		// Must stay first: pins a D8/R8 that understands the Kotlin metadata version (ADFA-6822).
+		classpath(libs.android.r8)
 		classpath(libs.kotlin.gradle.plugin)
 		classpath(libs.nav.safe.args.gradle.plugin)
 	}

gradle/libs.versions.toml

@@ -19,6 +19,7 @@ gson = "2.10.1"
 junit-jupiter = "5.10.2"
 anroidx-test-core = "2.2.0"
 koinAndroid = "4.1.1"
+# A Kotlin minor bump may need a newer `r8` (see its entry below, ADFA-6822).
 kotlin = "2.3.0"
 kotlin-coroutines = "1.9.0"
 kotlinxCoroutinesCore = "1.10.2"
@@ -37,6 +38,9 @@ ksp = "2.3.6"
 antlr4 = "4.13.1"
 androidx-work = "2.10.0"
 androidx-espresso = "3.5.1"
+# Pinned ahead of AGP on the root buildscript classpath: AGP 8.8.2's bundled D8 8.8.34 cannot rewrite
+# Kotlin 2.3 metadata. Bump with `kotlin`; remove once AGP is upgraded (ADFA-6837).
+r8 = "8.13.25"
 retrofit = "2.11.0"
 markwon = "4.6.2"
 maven-publish-plugin = "0.27.0"
@@ -324,6 +328,7 @@ tooling-slf4j = { module = "org.slf4j:slf4j-api", version = "2.0.17" }
 snakeyaml-engine = { module = "org.snakeyaml:snakeyaml-engine", version = "2.10" }
 
 # Classpaths
+android-r8 = { module = "com.android.tools:r8", version.ref = "r8" }
 android-gradle-plugin = { module = "com.android.tools.build:gradle", version.ref = "agp" }
 kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 nav-safe-args-gradle-plugin = { module = "androidx.navigation:navigation-safe-args-gradle-plugin", version.ref = "androidx-navigation" }

lsp/jvm-symbol-index/src/main/kotlin/org/appdevforall/codeonthego/indexing/jvm/KtFileMetadataIndex.kt

@@ -8,6 +8,34 @@ import org.appdevforall.codeonthego.indexing.api.indexQuery
 import org.appdevforall.codeonthego.indexing.jvm.KtFileMetadataDescriptor.KEY_IS_INDEXED
 import org.appdevforall.codeonthego.indexing.jvm.KtFileMetadataDescriptor.KEY_PACKAGE
 import java.io.Closeable
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * A completed write to a [KtFileMetadataIndex].
+ */
+sealed interface KtFileMetadataWrite {
+	/** The record for [filePath] was inserted or replaced; its package is [packageFqName]. */
+	data class Upserted(
+		val filePath: String,
+		val packageFqName: String,
+	) : KtFileMetadataWrite
+
+	/** The records for [filePaths] were removed. */
+	data class Removed(
+		val filePaths: Collection<String>,
+	) : KtFileMetadataWrite
+
+	/** Every record was removed. */
+	data object Cleared : KtFileMetadataWrite
+}
+
+/**
+ * Receives each [KtFileMetadataWrite] after it has been applied to the index.
+ */
+fun interface KtFileMetadataWriteListener {
+	/** Called synchronously on the writing thread once [write] is visible to readers. */
+	fun onWrite(write: KtFileMetadataWrite)
+}
 
 /**
  * An index of [KtFileMetadata] entries, one per Kotlin source file.
@@ -40,20 +68,42 @@ class KtFileMetadataIndex(
 			)
 	}
 
+	private val listeners = CopyOnWriteArrayList<KtFileMetadataWriteListener>()
+
+	/**
+	 * Registers [listener] to be told about every later write.
+	 *
+	 * Closing the returned handle unregisters it.
+	 */
+	fun addWriteListener(listener: KtFileMetadataWriteListener): AutoCloseable {
+		listeners.add(listener)
+		return AutoCloseable { listeners.remove(listener) }
+	}
+
+	private fun notifyListeners(write: KtFileMetadataWrite) {
+		listeners.forEach { it.onWrite(write) }
+	}
+
 	/**
 	 * Insert or replace the metadata record for a single file.
 	 *
 	 * Because [KtFileMetadata.key] and [KtFileMetadata.sourceId] are both the
 	 * file path, a file has at most one row and an insert replaces it.
 	 */
-	suspend fun upsert(metadata: KtFileMetadata) = backing.insert(metadata)
+	suspend fun upsert(metadata: KtFileMetadata) {
+		backing.insert(metadata)
+		notifyListeners(KtFileMetadataWrite.Upserted(metadata.filePath, metadata.packageFqName))
+	}
 
 	/**
 	 * Remove the metadata record for [filePath].
 	 *
 	 * No-op if the file is not in the index.
 	 */
-	suspend fun remove(filePath: String) = backing.removeBySource(filePath)
+	suspend fun remove(filePath: String) {
+		backing.removeBySource(filePath)
+		notifyListeners(KtFileMetadataWrite.Removed(listOf(filePath)))
+	}
 
 	/**
 	 * Remove the metadata records for every path in [filePaths] as a single
@@ -63,7 +113,10 @@ class KtFileMetadataIndex(
 	 * transaction instead of N - see [Index.removeBySources]. Paths not present in
 	 * the index are ignored.
 	 */
-	suspend fun removeAll(filePaths: Collection<String>) = backing.removeBySources(filePaths)
+	suspend fun removeAll(filePaths: Collection<String>) {
+		backing.removeBySources(filePaths)
+		notifyListeners(KtFileMetadataWrite.Removed(filePaths))
+	}
 
 	/**
 	 * Return the [KtFileMetadata] for [filePath], or `null` if the file is
@@ -154,7 +207,10 @@ class KtFileMetadataIndex(
 			).map { it.filePath }
 
 	/** Remove all records from the index. */
-	suspend fun clear() = backing.clear()
+	suspend fun clear() {
+		backing.clear()
+		notifyListeners(KtFileMetadataWrite.Cleared)
+	}
 
 	/** Whether the backing index still serves reads and writes. */
 	val isOpen: Boolean

lsp/jvm-symbol-index/src/test/kotlin/org/appdevforall/codeonthego/indexing/jvm/KtFileMetadataIndexWriteListenerTest.kt

@@ -0,0 +1,78 @@
+package org.appdevforall.codeonthego.indexing.jvm
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.test.runTest
+import org.appdevforall.codeonthego.indexing.InMemoryIndex
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import java.time.Instant
+
+@RunWith(JUnit4::class)
+class KtFileMetadataIndexWriteListenerTest {
+	private val index = KtFileMetadataIndex(InMemoryIndex(KtFileMetadataDescriptor))
+	private val writes = mutableListOf<KtFileMetadataWrite>()
+
+	private fun metadata(
+		path: String,
+		pkg: String,
+	) = KtFileMetadata(path, pkg, Instant.EPOCH, 1L)
+
+	@Test
+	fun upsertReportsPathAndPackage() =
+		runTest {
+			index.addWriteListener { writes += it }
+
+			index.upsert(metadata("/a/A.kt", "com.a"))
+
+			assertThat(writes).containsExactly(KtFileMetadataWrite.Upserted("/a/A.kt", "com.a"))
+		}
+
+	@Test
+	fun removeAndRemoveAllReportPaths() =
+		runTest {
+			index.addWriteListener { writes += it }
+
+			index.remove("/a/A.kt")
+			index.removeAll(listOf("/a/B.kt", "/a/C.kt"))
+
+			assertThat(writes)
+				.containsExactly(
+					KtFileMetadataWrite.Removed(listOf("/a/A.kt")),
+					KtFileMetadataWrite.Removed(listOf("/a/B.kt", "/a/C.kt")),
+				).inOrder()
+		}
+
+	@Test
+	fun clearReportsCleared() =
+		runTest {
+			index.addWriteListener { writes += it }
+
+			index.clear()
+
+			assertThat(writes).containsExactly(KtFileMetadataWrite.Cleared)
+		}
+
+	@Test
+	fun listenerSeesTheWriteAlreadyApplied() =
+		runTest {
+			var pathsSeenInListener: List<String>? = null
+			index.addWriteListener {
+				pathsSeenInListener = index.getFilePathsForPackage("com.a").toList()
+			}
+
+			index.upsert(metadata("/a/A.kt", "com.a"))
+
+			assertThat(pathsSeenInListener).containsExactly("/a/A.kt")
+		}
+
+	@Test
+	fun closedRegistrationIsNotCalled() =
+		runTest {
+			index.addWriteListener { writes += it }.close()
+
+			index.upsert(metadata("/a/A.kt", "com.a"))
+
+			assertThat(writes).isEmpty()
+		}
+}

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

@@ -475,12 +475,13 @@ class KotlinLanguageServer : ILanguageServer {
 	@Suppress("unused")
 	fun onFileDeleted(event: FileDeletionEvent) {
 		val path = event.file.toPath()
-		if (!DocumentUtils.isKotlinFile(path)) {
+		// The file is already gone, so only its extension can say it was Kotlin.
+		if (!DocumentUtils.hasKotlinExtension(path)) {
 			return
 		}
 
 		scope.launch {
-			runCatching { compiler?.compilationEnvironmentFor(path) }
+			runCatching { compiler?.compilationEnvironmentForKotlinPath(path) }
 				.getOrNull()
 				?.onFileRemoved(path)
 		}
@@ -495,7 +496,8 @@ class KotlinLanguageServer : ILanguageServer {
 		scope.launch {
 			// One read: a rebuild can swap the compiler between two reads of the property.
 			val compiler = compiler ?: return@launch
-			val oldIsKotlinFile = DocumentUtils.isKotlinFile(fromPath)
+			// The old path no longer exists, so only its extension can say it was Kotlin.
+			val oldIsKotlinFile = DocumentUtils.hasKotlinExtension(fromPath)
 			val newIsKotlinFile = DocumentUtils.isKotlinFile(toPath)
 
 			if (!oldIsKotlinFile && newIsKotlinFile) {
@@ -511,17 +513,16 @@ class KotlinLanguageServer : ILanguageServer {
 				// only the old file was a Kotlin file
 				// so just remove it from the index
 				compiler
-					.compilationEnvironmentFor(fromPath)
+					.compilationEnvironmentForKotlinPath(fromPath)
 					?.onFileRemoved(fromPath)
 				return@launch
 			}
 
-			val fromKind = runCatching { compiler.compilationKindFor(fromPath) }.getOrNull()
-			val toKind = runCatching { compiler.compilationKindFor(toPath) }.getOrNull()
-			val fromEnv = fromKind?.let { compiler.compilationEnvironmentFor(it) }
-			val toEnv = toKind?.let { compiler.compilationEnvironmentFor(it) }
+			// Path-based, so a .kts side yields no environment instead of the kind-based overload's throw.
+			val fromEnv = runCatching { compiler.compilationEnvironmentForKotlinPath(fromPath) }.getOrNull()
+			val toEnv = runCatching { compiler.compilationEnvironmentForKotlinPath(toPath) }.getOrNull()
 
-			if (fromKind != null && fromEnv == toEnv && toEnv != null) {
+			if (fromEnv != null && fromEnv == toEnv) {
 				// file was renamed within the same compilation environment
 				toEnv.onFileMoved(fromPath, toPath)
 				return@launch