ADFA-6228: Make the JVM symbol index correct enough to replace the classpath trie

lsp/indexing/src/main/kotlin/org/appdevforall/codeonthego/indexing/FilteredIndex.kt

@@ -1,5 +1,7 @@
 package org.appdevforall.codeonthego.indexing
 
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import org.appdevforall.codeonthego.indexing.api.IndexQuery
 import org.appdevforall.codeonthego.indexing.api.Indexable
 import org.appdevforall.codeonthego.indexing.api.ReadableIndex
@@ -19,8 +21,8 @@ import java.util.concurrent.ConcurrentHashMap
  */
 open class FilteredIndex<T : Indexable>(
 	private val backing: ReadableIndex<T>,
-) : ReadableIndex<T>, Closeable {
-
+) : ReadableIndex<T>,
+	Closeable {
 	/**
 	 * The set of source IDs whose entries are visible.
 	 * Uses a concurrent set for thread-safe reads during queries.
@@ -57,50 +59,70 @@ open class FilteredIndex<T : Indexable>(
 	/**
 	 * Returns the current set of active source IDs.
 	 */
-	open fun activeSources(): Set<String> =
-		activeSources.toSet()
+	fun activeSources(): Set<String> = activeSources.toSet()
+
+	/**
+	 * The source IDs whose entries are visible, or `null` if every source is.
+	 *
+	 * Override this to change what the filter admits; `null` admits every source.
+	 */
+	protected open fun visibleSourceIds(): Collection<String>? = activeSources
 
 	/**
 	 * Returns true if the source is currently active (visible).
 	 */
-	open fun isActive(sourceId: String): Boolean =
-		sourceId in activeSources
+	fun isActive(sourceId: String): Boolean = visibleSourceIds()?.contains(sourceId) ?: true
 
 	/**
 	 * Returns true if the source exists in the backing index,
 	 * regardless of whether it's active.
 	 *
 	 * Use this to check if a JAR needs indexing at all.
 	 */
-	open suspend fun isCached(sourceId: String): Boolean =
-		backing.containsSource(sourceId)
+	open suspend fun isCached(sourceId: String): Boolean = backing.containsSource(sourceId)
+
+	override fun query(query: IndexQuery): Sequence<T> = backing.query(scopedToActive(query))
+
+	/**
+	 * Narrows [query] to the active sources by rewriting its scope, rather than by filtering the
+	 * rows it returns.
+	 *
+	 * Filtering afterwards is wrong whenever the query is limited: the backing index applies the
+	 * limit first, so a page full of inactive rows yields nothing even though matches exist. Pushing
+	 * the active set into the query makes the limit count only rows the caller can actually see.
+	 */
+	private fun scopedToActive(query: IndexQuery): IndexQuery {
+		val visible = visibleSourceIds()?.toSet() ?: return query
 
-	override fun query(query: IndexQuery): Sequence<T> {
-		if (query.sourceId != null && !isActive(query.sourceId)) {
-			return emptySequence()
+		if (query.sourceId != null) {
+			// Already as narrow as a scope gets: it either survives the active set or matches nothing.
+			return if (query.sourceId in visible) query else query.copy(sourceIds = emptyList())
 		}
-		val original = backing.query(query)
-		return original.filter { isActive(it.sourceId) }
-	}
 
-	override suspend fun get(key: String): T? {
-		val entry = backing.get(key) ?: return null
-		return if (isActive(entry.sourceId)) entry else null
+		val requested = query.sourceIds
+		val scoped = requested?.filter { it in visible } ?: visible
+		return query.copy(sourceIds = scoped)
 	}
 
-	override suspend fun containsSource(sourceId: String): Boolean {
-		return isActive(sourceId) && backing.containsSource(sourceId)
-	}
+	/**
+	 * Returns the visible entry for [key], the one with the smallest source id among the visible
+	 * sources that have it.
+	 *
+	 * This is a scoped key query rather than a check on the backing index's own [get]: that returns
+	 * the smallest source id overall, and when that source is inactive a visible entry for the same
+	 * key would be missed.
+	 */
+	override suspend fun get(key: String): T? =
+		withContext(Dispatchers.IO) {
+			backing.query(scopedToActive(IndexQuery.byKey(key))).firstOrNull()
+		}
 
-	override fun distinctValues(fieldName: String): Sequence<String> {
-		// This is imprecise — the backing index may return values
-		// from inactive sources. For exact results, we'd need to
-		// query all entries and filter. For package enumeration
-		// (the main use case), this approximation is acceptable
-		// since packages from inactive JARs are harmless — they
-		// just produce empty results when queried further.
-		return backing.distinctValues(fieldName)
-	}
+	override suspend fun containsSource(sourceId: String): Boolean = isActive(sourceId) && backing.containsSource(sourceId)
+
+	override fun distinctValues(
+		fieldName: String,
+		query: IndexQuery,
+	): Sequence<String> = backing.distinctValues(fieldName, scopedToActive(query))
 
 	override fun close() {
 		activeSources.clear()