Respond to Incomplete Queries Correctly

Author: thecoolwinter

CodeEdit/Features/LSP/Features/AutoComplete/AutoCompleteCoordinator.swift

@@ -21,6 +21,8 @@ class AutoCompleteCoordinator {
     private var currentFilterText: String = ""
     /// Stores the unfiltered completion items
     private var completionItems: [AutoCompleteItem] = []
+    /// Set to true when the server sends an incomplete list, indicating that we should not filter client-side.
+    private var receivedIncompleteCompletionItems: Bool = false
 
     init(_ file: CEWorkspaceFile) {
         self.file = file
@@ -51,9 +53,10 @@ class AutoCompleteCoordinator {
             // Extract the completion items list
             switch completions {
             case .optionA(let completionItems):
-                return completionItems.map { AutoCompleteItem($0) }
+                return completionItems.map { AutoCompleteItem($0) }.sorted()
             case .optionB(let completionList):
-                return completionList.items.map { AutoCompleteItem($0) }
+                receivedIncompleteCompletionItems = receivedIncompleteCompletionItems || completionList.isIncomplete
+                return completionList.items.map { AutoCompleteItem($0) }.sorted()
             case .none:
                 return []
             }
@@ -64,24 +67,15 @@ class AutoCompleteCoordinator {
 
     /// Filters completion items based on the current partial token input
     private func filterCompletionItems(_ items: [AutoCompleteItem]) -> [AutoCompleteItem] {
-        guard !currentFilterText.isEmpty else {
-            return items
+        guard !currentFilterText.isEmpty, !receivedIncompleteCompletionItems else {
+            return items.sorted()
         }
 
-        let items = items.filter { item in
-            let insertText = LSPCompletionItemsUtil.getInsertText(from: item)
-            let label = item.label.lowercased()
-            let filterText = currentFilterText.lowercased()
-            if insertText.lowercased().hasPrefix(filterText) {
-                return true
-            }
-            if label.hasPrefix(filterText) {
-                return true
-            }
-            return false
-        }
+        let items = items
+            .map { ($0.fuzzyMatch(query: currentFilterText), $0) }
+            .compactMap { $0.0.weight > 0 ? $0.1 : nil }
 
-        return items
+        return items.sorted()
     }
 }
 
@@ -91,22 +85,44 @@ extension AutoCompleteCoordinator: CodeSuggestionDelegate {
         textView: TextViewController,
         cursorPosition: CursorPosition
     ) async -> (windowPosition: CursorPosition, items: [CodeSuggestionEntry])? {
-        let tokenSubstringCount = findTreeSitterNodeAtPosition(textView: textView, cursorPosition: cursorPosition)
         currentFilterText = ""
+        let tokenSubstringCount = findTreeSitterNodeAtPosition(textView: textView, cursorPosition: cursorPosition)
+
+        let textPosition = Position(line: cursorPosition.start.line - 1, character: cursorPosition.start.column - 1)
 
-        var textPosition = Position(line: cursorPosition.start.line - 1, character: cursorPosition.start.column - 1)
-        var cursorPosition = cursorPosition
         // If we are asking for completions in the middle of a token, then
         // query the language server for completion items at the start of the token
-        if currentNode != nil {
-            textPosition = Position(
+        // but *only* if we haven't received an incomplete response.
+        let queryPosition = if currentNode != nil && !receivedIncompleteCompletionItems {
+            Position(
                 line: cursorPosition.start.line - 1,
                 character: cursorPosition.start.column - tokenSubstringCount - 1
             )
-            cursorPosition = CursorPosition(line: textPosition.line + 1, column: textPosition.character + 1)
+        } else {
+            textPosition
         }
-        completionItems = await fetchCompletions(position: textPosition)
-        return (cursorPosition, completionItems)
+        completionItems = await fetchCompletions(position: queryPosition)
+
+        if receivedIncompleteCompletionItems && queryPosition != textPosition {
+            // We need to re-request this. We've requested the wrong location and since know that the server
+            // returns incomplete items (meaning we can't filter them ourselves).
+            return await completionSuggestionsRequested(textView: textView, cursorPosition: cursorPosition)
+        }
+
+        // If we can detect that we're in a node, we still want to adjust the panel to be in the correct position
+        let cursorPosition: CursorPosition = if currentNode != nil {
+            CursorPosition(
+                line: cursorPosition.start.line,
+                column: cursorPosition.start.column - tokenSubstringCount
+            )
+        } else {
+            CursorPosition(
+                line: queryPosition.line + 1,
+                column: queryPosition.character + 1
+            )
+        }
+
+        return (cursorPosition, filterCompletionItems(completionItems))
     }
 
     func findTreeSitterNodeAtPosition(textView: TextViewController, cursorPosition: CursorPosition) -> Int {
@@ -140,7 +156,7 @@ extension AutoCompleteCoordinator: CodeSuggestionDelegate {
         textView: TextViewController,
         cursorPosition: CursorPosition
     ) -> [CodeSuggestionEntry]? {
-        guard var currentNode = currentNode, !completionItems.isEmpty else {
+        guard var currentNode = currentNode, !completionItems.isEmpty, !receivedIncompleteCompletionItems else {
             return nil
         }
         _ = findTreeSitterNodeAtPosition(textView: textView, cursorPosition: cursorPosition)

CodeEdit/Features/LSP/Features/AutoComplete/AutoCompleteItem.swift

@@ -11,7 +11,7 @@ import LanguageServerProtocol
 
 /// A Near 1:1 of `LanguageServerProtocol`'s `CompletionItem`. Wrapped for compatibility with the CESE's
 /// `CodeSuggestionEntry` protocol to deal with some optional bools.
-struct AutoCompleteItem: Hashable, Sendable, CodeSuggestionEntry {
+struct AutoCompleteItem: Hashable, Sendable, CodeSuggestionEntry, Comparable {
     let label: String
     let kind: CompletionItemKind?
     let detail: String?
@@ -62,4 +62,12 @@ struct AutoCompleteItem: Hashable, Sendable, CodeSuggestionEntry {
         self.command = item.command
         self.data = item.data
     }
+
+    static func < (lhs: AutoCompleteItem, rhs: AutoCompleteItem) -> Bool {
+        lhs.sortText ?? lhs.label < rhs.sortText ?? rhs.label
+    }
+}
+
+extension AutoCompleteItem: FuzzySearchable {
+    var searchableString: String { filterText ?? label }
 }

CodeEdit/Features/Search/FuzzySearch/Collection+FuzzySearch.swift

@@ -26,4 +26,22 @@ extension Collection where Iterator.Element: FuzzySearchable {
             $0.result.weight > $1.result.weight
         }
     }
+
+    /// Synchronously performs a fuzzy search on a collection of elements conforming to FuzzySearchable.
+    ///
+    /// - Parameter query: The query string to match against the elements.
+    ///
+    /// - Returns: An array of tuples containing FuzzySearchMatchResult and the corresponding element.
+    ///
+    /// - Note: Because this is an extension on Collection and not only array,
+    /// you can also use this on sets.
+    func fuzzySearchSync(query: String) -> [(result: FuzzySearchMatchResult, item: Iterator.Element)] {
+        return map {
+            (result: $0.fuzzyMatch(query: query), item: $0)
+        }.filter {
+            $0.result.weight > 0
+        }.sorted {
+            $0.result.weight > $1.result.weight
+        }
+    }
 }