chore: improve completion ranking

Added tests, and improved the following:

- improve fuzzy matches
- prefer shorter completions first
- ultimately follow `sortText`

Author: S-furi

completions/src/main/kotlin/completions/lsp/util/completions/FuzzyCompletionRanking.kt

@@ -8,7 +8,12 @@ import org.eclipse.lsp4j.CompletionItem
 internal object FuzzyCompletionRanking {
     private val objectMapper = Json { ignoreUnknownKeys = true }
 
-    private data class RankedItem(val item: CompletionItem, val score: Int)
+    private data class RankedItem(
+        val item: CompletionItem,
+        val score: Int,
+        val matchSpan: Int,
+        val candidateLength: Int
+    )
 
     /**
      * Extracts the prefix of this [CompletionItem] that triggered the completion.
@@ -23,19 +28,39 @@ internal object FuzzyCompletionRanking {
      * fuzzy scoring is performed on what has been typed by the user so far,
      * then we use [CompletionItem.sortText] to break ties.
      *
+     * Tie-breakers after the fuzzy score:
+     * - smaller match span (the window covering all matched characters)
+     * - shorter candidate length
+     * - sortText (ascending)
+     *
      * @param query the query the user has typed so far
      */
-    fun List<CompletionItem>.rankCompletions(query: String): List<CompletionItem> =
-        map { RankedItem(it, fuzzyScore(query, it.sortingKey())) }
-            .sortedWith(compareByDescending<RankedItem> { it.score }.thenBy { it.item.sortText })
+    fun List<CompletionItem>.rankCompletions(query: String): List<CompletionItem> {
+        // Empty query should rank purely by sortText (do not involve span/length)
+        if (query.isEmpty()) {
+            return this.sortedBy { it.sortText }
+        }
+        return map { item ->
+            val candidate = item.sortingKey()
+            val (score, span) = fuzzyScoreWithSpan(query, candidate)
+            RankedItem(item, score, span, candidate.length)
+        }
+            .sortedWith(
+                compareByDescending<RankedItem> { it.score }
+                    .thenBy { it.matchSpan }
+                    .thenBy { it.candidateLength }
+                    .thenBy { it.item.sortText }
+            )
             .map { it.item }
+    }
 
-    private fun fuzzyScore(query: String, candidate: String): Int {
-        if (query.isEmpty()) return 1
+    private fun fuzzyScoreWithSpan(query: String, candidate: String): Pair<Int, Int> {
+        if (query.isEmpty()) return 1 to 0
 
         var score = 0
         var queryIndex = 0
         var lastMatchIndex = -1
+        var firstMatchIndex = -1
 
         for (i in candidate.indices) {
             if (queryIndex >= query.length) break
@@ -44,16 +69,25 @@ internal object FuzzyCompletionRanking {
             val cc = candidate[i].lowercaseChar()
 
             if (cc == qc) {
+                if (firstMatchIndex == -1) firstMatchIndex = i
                 score += 10
-                if (lastMatchIndex == i - 1) score += 5 // consecutive match bonus
-                if (i == 0 || !candidate[i-1].isLetterOrDigit()) score += 3 // bonus if beginning
+                if (lastMatchIndex == i - 1) {
+                    score += 5
+                } else if (lastMatchIndex != -1) {
+                    val gap = i - lastMatchIndex - 1
+                    if (gap > 0) score -= gap
+                }
                 lastMatchIndex = i
                 queryIndex++
             }
         }
-        return if (queryIndex == query.length) score else 0
+        return if (queryIndex == query.length) {
+            val span = lastMatchIndex - firstMatchIndex + 1
+            score to span
+        } else {
+            0 to Int.MAX_VALUE
+        }
     }
 
     private fun CompletionItem.sortingKey(): String = this.filterText ?: this.label
-}
-
+}

completions/src/test/kotlin/lsp/FuzzyCompletionRankingTest.kt

@@ -0,0 +1,92 @@
+package lsp
+
+import completions.lsp.util.completions.FuzzyCompletionRanking.rankCompletions
+import lsp.RankingTestDSL.rankingTest
+import org.eclipse.lsp4j.CompletionItem
+import org.junit.jupiter.api.Assertions.assertIterableEquals
+import org.junit.jupiter.api.Test
+
+class FuzzyCompletionRankingTest {
+
+    @Test
+    fun `empty query ranks only by sortText`() = rankingTest("") {
+        val a = item("zeta", sortText = "3")
+        val b = item("alpha", sortText = "1")
+        val c = item("gamma", sortText = "2")
+        expectOrder(b, c, a)
+    }
+
+    @Test
+    fun `Kotlin common API names should be properly ranked`() = rankingTest("pr") {
+        val println = item("println", sortText = "2")
+        val print = item("print", sortText = "1")
+        val property = item("property", sortText = "4")
+        val map = item("map", sortText = "3")
+        expectOrder(print, println, property, map)
+    }
+
+    @Test
+    fun `completions are ranked by relevance and length (shortest first)`() = rankingTest("toIn") {
+        val c1 = item("toInt", sortText = "3")
+        val c2 = item("toUInt", sortText = "1")
+        val c3 = item("toInterval", sortText = "2")
+        expectOrder(c1, c3, c2)
+    }
+
+    @Test
+    fun `tie break by sortText when scores equal`() = rankingTest("pr") {
+        val a = item("prX", sortText = "1")
+        val b = item("prY", sortText = "2")
+        expectOrder(a, b)
+    }
+
+    @Test
+    fun `exact and consecutive matches outrank sparse matches`() = rankingTest("pr") {
+        val a = item("print", sortText = "2")     // exact
+        val b = item("p...r..", sortText = "1")   // non-consecutive
+        val c = item("pxxx", sortText = "3")      // sparse/non-full
+        expectOrder(a, b, c)
+    }
+
+    @Test
+    fun `case insensitive matching, tie-break with sortText`() = rankingTest("PrI") {
+        val a = item("pRiNtLn", sortText = "2")
+        val b = item("println", sortText = "1")
+        expectOrder(b, a)
+    }
+
+    @Test
+    fun `consecutive matches beat non-consecutive`() = rankingTest("io") {
+        val consecutive = item("ioScope", sortText = "2")
+        val sparse = item("iXoScope", sortText = "1")
+        expectOrder(consecutive, sparse)
+    }
+}
+
+private object RankingTestDSL {
+    data class RankingCase(private val query: String) {
+        val items = mutableListOf<CompletionItem>()
+        val expected = mutableListOf<CompletionItem>()
+
+        fun item(
+            label: String,
+            sortText: String,
+            dataJson: String? = null,
+        ): CompletionItem = CompletionItem(label).apply {
+            this.sortText = sortText
+            if (dataJson != null) this.data = dataJson
+            items += this
+        }
+
+        fun expectOrder(vararg items: CompletionItem) {
+            expected.clear()
+            expected += items
+        }
+    }
+
+    fun rankingTest(query: String, build: RankingCase.() -> Unit) {
+        val case = RankingCase(query).apply(build)
+        val ranked = case.items.rankCompletions(query)
+        assertIterableEquals(case.expected, ranked, "Expected(query=$query): ${case.expected} but got: $ranked")
+    }
+}