Improve string distance measurement

Use the sift4 algorithm for code completions and move the
completion-related functiosn into a StringUtils module.

Author: fwcd

server/src/main/kotlin/org/javacs/kt/completion/Completions.kt

@@ -7,8 +7,10 @@ import org.eclipse.lsp4j.CompletionList
 import org.javacs.kt.CompiledFile
 import org.javacs.kt.LOG
 import org.javacs.kt.CompletionConfiguration
+import org.javacs.kt.util.containsCharactersInOrder
 import org.javacs.kt.util.findParent
 import org.javacs.kt.util.noResult
+import org.javacs.kt.util.stringDistance
 import org.javacs.kt.util.toPath
 import org.javacs.kt.util.onEachIndexed
 import org.jetbrains.kotlin.container.get
@@ -43,6 +45,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import java.util.concurrent.TimeUnit
 
 private const val MAX_COMPLETION_ITEMS = 50
+private const val MAX_STRING_DISTANCE = 10
 
 /** Finds completions at the specified position. */
 fun completions(file: CompiledFile, cursor: Int, config: CompletionConfiguration): CompletionList {
@@ -74,8 +77,7 @@ private fun elementCompletionItems(file: CompiledFile, cursor: Int, config: Comp
     val surroundingElement = completableElement(file, cursor) ?: return emptySequence()
     val completions = elementCompletions(file, cursor, surroundingElement)
 
-    val nameFilter = matchesPartialIdentifier(partial)
-    val matchesName = completions.filter(nameFilter)
+    val matchesName = completions.sortedBy { stringDistance(name(it), partial).takeIf { it < MAX_STRING_DISTANCE || partial.isEmpty() } }
     val visible = matchesName.filter(isVisible(file, cursor))
 
     return visible.map { completionItem(it, surroundingElement, file, config) }
@@ -348,15 +350,8 @@ private fun implicitMembers(scope: HierarchicalScope): Sequence<DeclarationDescr
     return implicit.type.memberScope.getContributedDescriptors().asSequence()
 }
 
-private fun equalsIdentifier(identifier: String): (DeclarationDescriptor) -> Boolean {
-    return { name(it) == identifier }
-}
-
-private fun matchesPartialIdentifier(partialIdentifier: String): (DeclarationDescriptor) -> Boolean {
-    return {
-        containsCharactersInOrder(name(it), partialIdentifier, false)
-    }
-}
+private fun equalsIdentifier(identifier: String): (DeclarationDescriptor) -> Boolean =
+    { name(it) == identifier }
 
 private fun name(d: DeclarationDescriptor): String {
     if (d is ConstructorDescriptor)
@@ -365,29 +360,6 @@ private fun name(d: DeclarationDescriptor): String {
         return d.name.identifier
 }
 
-fun containsCharactersInOrder(
-        candidate: CharSequence, pattern: CharSequence, caseSensitive: Boolean): Boolean {
-    var iCandidate = 0
-    var iPattern = 0
-
-    while (iCandidate < candidate.length && iPattern < pattern.length) {
-        var patternChar = pattern[iPattern]
-        var testChar = candidate[iCandidate]
-
-        if (!caseSensitive) {
-            patternChar = Character.toLowerCase(patternChar)
-            testChar = Character.toLowerCase(testChar)
-        }
-
-        if (patternChar == testChar) {
-            iPattern++
-            iCandidate++
-        } else iCandidate++
-    }
-
-    return iPattern == pattern.length
-}
-
 private fun isVisible(file: CompiledFile, cursor: Int): (DeclarationDescriptor) -> Boolean {
     val el = file.elementAtPoint(cursor) ?: return { true }
     val from = el.parentsWithSelf

server/src/main/kotlin/org/javacs/kt/symbols/Symbols.kt

@@ -7,8 +7,8 @@ import org.eclipse.lsp4j.SymbolKind
 import org.eclipse.lsp4j.DocumentSymbol
 import org.eclipse.lsp4j.jsonrpc.messages.Either
 import org.javacs.kt.SourcePath
-import org.javacs.kt.completion.containsCharactersInOrder
 import org.javacs.kt.position.range
+import org.javacs.kt.util.containsCharactersInOrder
 import org.javacs.kt.util.preOrderTraversal
 import org.javacs.kt.util.toPath
 import org.jetbrains.kotlin.psi.*

shared/src/main/kotlin/org/javacs/kt/util/StringUtils.kt

@@ -0,0 +1,94 @@
+package org.javacs.kt.util
+
+/**
+ * Computes a string distance using a slightly modified
+ * variant of the SIFT4 algorithm in linear time.
+ * Note that the function is asymmetric with respect to
+ * its two input strings and thus is not a metric in the
+ * mathematical sense.
+ *
+ * Based on the JavaScript implementation from
+ * https://siderite.dev/blog/super-fast-and-accurate-string-distance.html/
+ *
+ * @param candidate The first string
+ * @param pattern The second string
+ * @param maxOffset The number of characters to search for matching letters
+ */
+fun stringDistance(candidate: CharSequence, pattern: CharSequence, maxOffset: Int = 4): Int = when {
+    candidate.length == 0 -> pattern.length
+    pattern.length == 0 -> candidate.length
+    else -> {
+        val candidateLength = candidate.length
+        val patternLength = pattern.length
+        var iCandidate = 0
+        var iPattern = 0
+        var longestCommonSubsequence = 0
+        var localCommonSubstring = 0
+
+        while (iCandidate < candidateLength && iPattern < patternLength) {
+            if (candidate[iCandidate] == pattern[iPattern]) {
+                localCommonSubstring++
+            } else {
+                longestCommonSubsequence += localCommonSubstring
+                localCommonSubstring = 0
+
+                if (iCandidate != iPattern) {
+                    // Using max to bypass the need for computer transpositions ("ab" vs "ba")
+                    val iMax = Math.max(iCandidate, iPattern)
+                    iCandidate = iMax
+                    iPattern = iMax
+                }
+
+                searchWindow@
+                for (i in 0 until maxOffset) {
+                    when {
+                        (iCandidate + i) < candidateLength -> {
+                            if (candidate[iCandidate + i] == pattern[iPattern]) {
+                                iCandidate += i
+                                localCommonSubstring++
+                                break@searchWindow
+                            }
+                        }
+                        (iPattern + i) < patternLength -> {
+                            if (candidate[iCandidate] == pattern[iPattern + i]) {
+                                iPattern += i
+                                localCommonSubstring++
+                                break@searchWindow
+                            }
+                        }
+                        else -> break@searchWindow
+                    }
+                }
+            }
+
+            iCandidate++
+            iPattern++
+        }
+
+        longestCommonSubsequence += localCommonSubstring
+        Math.max(candidateLength, patternLength) - longestCommonSubsequence
+    }
+}
+
+/** Checks whether the candidate contains the pattern in order. */
+fun containsCharactersInOrder(candidate: CharSequence, pattern: CharSequence, caseSensitive: Boolean): Boolean {
+    var iCandidate = 0
+    var iPattern = 0
+
+    while (iCandidate < candidate.length && iPattern < pattern.length) {
+        var patternChar = pattern[iPattern]
+        var testChar = candidate[iCandidate]
+
+        if (!caseSensitive) {
+            patternChar = Character.toLowerCase(patternChar)
+            testChar = Character.toLowerCase(testChar)
+        }
+
+        if (patternChar == testChar) {
+            iPattern++
+        }
+        iCandidate++
+    }
+
+    return iPattern == pattern.length
+}