add detail in CompletionItem

Author: kiddos

src/basecode_lsp/backend.rs

@@ -77,7 +77,7 @@ impl LanguageServer for Backend {
             params.text_document.text.clone(),
         );
 
-        self.add_words(params.text_document.text.clone()).await;
+        self.add_words(params.text_document.text.clone(), params.text_document.uri.to_string()).await;
         self.maybe_update_tmux().await;
     }
 
@@ -103,7 +103,7 @@ impl LanguageServer for Backend {
             }
         }
         for content_change in params.content_changes.iter() {
-            self.add_words(content_change.text.clone()).await;
+            self.add_words(content_change.text.clone(), params.text_document.uri.to_string()).await;
         }
         self.maybe_update_tmux().await;
     }
@@ -119,16 +119,18 @@ impl LanguageServer for Backend {
                 let trie_lock = self.trie.lock().await;
                 let words = trie_lock.suggest_completions(&prefix);
                 let suffixes = get_possible_current_word(&current_line, position.character as i32);
-                words_to_completion_items(words, &suffixes, &mut completions, CompletionItemKind::TEXT);
+                words_uri_pair_to_completion_items(words, &suffixes, &mut completions, CompletionItemKind::TEXT);
 
                 let tmux_words = self.prepare_tmux_words().await;
-                words_to_completion_items(tmux_words, &suffixes, &mut completions, CompletionItemKind::REFERENCE);
+                let source = "tmux".to_string();
+                words_to_completion_items(tmux_words, source, &suffixes, &mut completions, CompletionItemKind::REFERENCE);
 
                 if self.lsp_args.command_source {
                     let mut command_words = get_command_completions();
                     command_words.sort();
                     command_words.dedup();
-                    words_to_completion_items(command_words, &suffixes, &mut completions, CompletionItemKind::KEYWORD);
+                    let source = "command".to_string();
+                    words_to_completion_items(command_words, source, &suffixes, &mut completions, CompletionItemKind::KEYWORD);
                 }
 
                 let file_uri = params.text_document_position.text_document.uri.to_string();
@@ -156,12 +158,12 @@ impl Backend {
         };
     }
 
-    async fn add_words(&self, content: String) {
+    async fn add_words(&self, content: String, uri: String) {
         let mut trie_lock = self.trie.lock().await;
         for token in content.split_whitespace() {
             let words = process_token(token, self.lsp_args.min_word_len);
             for w in words {
-                trie_lock.insert(&w);
+                trie_lock.insert(&w, &uri);
             }
         }
     }

src/basecode_lsp/trie.rs

@@ -5,6 +5,7 @@ use std::cmp::max;
 pub struct TrieNode {
     children: HashMap<char, TrieNode>,
     word_count: i32,
+    uri: String,
 }
 
 #[derive(Debug)]
@@ -19,12 +20,15 @@ impl Trie {
         }
     }
 
-    pub fn insert(&mut self, word: &str) {
+    pub fn insert(&mut self, word: &str, uri: &str) {
         let mut node = &mut self.root;
         for char in word.chars() {
             node = node.children.entry(char).or_default();
         }
         node.word_count += 1;
+        if node.uri.is_empty() {
+            node.uri = uri.to_string();
+        }
     }
 
     pub fn remove(&mut self, word: &str) {
@@ -49,7 +53,7 @@ impl Trie {
         false
     }
 
-    pub fn suggest_completions(&self, prefix: &str) -> Vec<String> {
+    pub fn suggest_completions(&self, prefix: &str) -> Vec<(String, String)> {
         let mut completions = Vec::new();
         let p: Vec<char> = prefix.chars().collect();
         self.suggest_completions_helper(&self.root, &p, 0, &mut completions);
@@ -61,7 +65,7 @@ impl Trie {
         node: &TrieNode,
         prefix: &Vec<char>,
         index: usize,
-        completions: &mut Vec<String>,
+        completions: &mut Vec<(String, String)>,
     ) {
         if index == prefix.len() {
             let mut current = prefix.clone();
@@ -74,9 +78,13 @@ impl Trie {
         }
     }
 
-    fn collect_words(node: &TrieNode, word: &mut Vec<char>, completions: &mut Vec<String>) {
-        if node.word_count > 0 {
-            completions.push(word.iter().collect());
+    fn collect_words(
+        node: &TrieNode,
+        word: &mut Vec<char>,
+        completions: &mut Vec<(String, String)>,
+    ) {
+        if node.word_count > 0 && !node.uri.is_empty() {
+            completions.push((word.iter().collect(), node.uri.to_string()));
         }
 
         for (&char, child) in node.children.iter() {
@@ -107,9 +115,9 @@ mod tests {
     fn test_insert_and_contains() {
         let mut trie = Trie::new();
 
-        trie.insert("apple");
-        trie.insert("application");
-        trie.insert("banana");
+        trie.insert("apple", "file://");
+        trie.insert("application", "file://");
+        trie.insert("banana", "file://");
 
         assert!(trie_contains(&trie, "apple"));
         assert!(trie_contains(&trie, "application"));
@@ -122,9 +130,9 @@ mod tests {
     fn test_remove() {
         let mut trie = Trie::new();
 
-        trie.insert("apple");
-        trie.insert("application");
-        trie.insert("banana");
+        trie.insert("apple", "file://");
+        trie.insert("application", "file://");
+        trie.insert("banana", "file://");
 
         assert!(trie_contains(&trie, "apple"));
         trie.remove("apple");
@@ -138,33 +146,52 @@ mod tests {
     fn test_suggest_completions() {
         let mut trie = Trie::new();
 
-        trie.insert("apple");
-        trie.insert("application");
-        trie.insert("banana");
-        trie.insert("bat");
-        trie.insert("bear");
+        trie.insert("apple", "file://");
+        trie.insert("application", "file://");
+        trie.insert("banana", "file://");
+        trie.insert("bat", "file://");
+        trie.insert("bear", "file://");
 
         let mut completions = trie.suggest_completions("ap");
         completions.sort();
-        assert_eq!(completions, vec!["apple", "application"]);
+        assert_eq!(
+            completions,
+            vec![
+                ("apple".to_string(), "file://".to_string()),
+                ("application".to_string(), "file://".to_string())
+            ]
+        );
 
         let mut completions = trie.suggest_completions("ba");
         completions.sort();
-        assert_eq!(completions, vec!["banana", "bat"]);
+        assert_eq!(
+            completions,
+            vec![
+                ("banana".to_string(), "file://".to_string()),
+                ("bat".to_string(), "file://".to_string())
+            ]
+        );
 
         let mut completions = trie.suggest_completions("b");
         completions.sort();
-        assert_eq!(completions, vec!["banana", "bat", "bear"]);
+        assert_eq!(
+            completions,
+            vec![
+                ("banana".to_string(), "file://".to_string()),
+                ("bat".to_string(), "file://".to_string()),
+                ("bear".to_string(), "file://".to_string())
+            ]
+        );
 
         let completions = trie.suggest_completions("nonexistent");
-        assert_eq!(completions, Vec::<String>::new());
+        assert_eq!(completions, Vec::<(String, String)>::new());
     }
 
     #[test]
     fn test_remove_nonexistent() {
         let mut trie = Trie::new();
 
-        trie.insert("apple");
+        trie.insert("apple", "file://");
         trie.remove("nonexistent");
         assert!(trie_contains(&trie, "apple"));
     }
@@ -173,8 +200,8 @@ mod tests {
     fn test_remove_multiple() {
         let mut trie = Trie::new();
 
-        trie.insert("apple");
-        trie.insert("apple");
+        trie.insert("apple", "file://");
+        trie.insert("apple", "file://");
         assert!(trie_contains(&trie, "apple"));
 
         trie.remove("apple");

src/basecode_lsp/util.rs

@@ -71,8 +71,29 @@ pub fn get_possible_current_word(current_line: &str, character: i32) -> Vec<Stri
     possible
 }
 
+pub fn words_uri_pair_to_completion_items(
+    words: Vec<(String, String)>,
+    suffixes: &Vec<String>,
+    completions: &mut Vec<CompletionItem>,
+    kind: CompletionItemKind,
+) {
+    let items: Vec<CompletionItem> = words
+        .iter()
+        .filter(|&item| !suffixes.contains(&item.0))
+        .map(|item| CompletionItem {
+            label: item.0.to_string(),
+            kind: Some(kind),
+            sort_text: Some(item.0.to_string()),
+            detail: Some(item.1.to_string()),
+            ..CompletionItem::default()
+        })
+        .collect();
+    completions.extend(items);
+}
+
 pub fn words_to_completion_items(
     words: Vec<String>,
+    source: String,
     suffixes: &Vec<String>,
     completions: &mut Vec<CompletionItem>,
     kind: CompletionItemKind,
@@ -84,6 +105,7 @@ pub fn words_to_completion_items(
             label: word.clone(),
             kind: Some(kind),
             sort_text: Some(word.clone()),
+            detail: Some(source.to_string()),
             ..CompletionItem::default()
         })
         .collect();