Send LSP Completion Item Kind (nushell#11443)

# Description

This commit fills in the completion item kind into the
`textDocument/completion` response so that LSP client can present more
information to the user.

It is an improvement in the context of nushell#10794

# User-Facing Changes

Improved information display in editor's intelli-sense menu


![output](https://github.com/nushell/nushell/assets/16558417/991dc0a9-45d1-4718-8f22-29002d687b93)

crates/nu-cli/src/completions/base.rs

@@ -13,31 +13,53 @@ pub trait Completer {
         offset: usize,
         pos: usize,
         options: &CompletionOptions,
-    ) -> Vec<Suggestion>;
+    ) -> Vec<SemanticSuggestion>;
 
     fn get_sort_by(&self) -> SortBy {
         SortBy::Ascending
     }
 
-    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+    fn sort(&self, items: Vec<SemanticSuggestion>, prefix: Vec<u8>) -> Vec<SemanticSuggestion> {
         let prefix_str = String::from_utf8_lossy(&prefix).to_string();
         let mut filtered_items = items;
 
         // Sort items
         match self.get_sort_by() {
             SortBy::LevenshteinDistance => {
                 filtered_items.sort_by(|a, b| {
-                    let a_distance = levenshtein_distance(&prefix_str, &a.value);
-                    let b_distance = levenshtein_distance(&prefix_str, &b.value);
+                    let a_distance = levenshtein_distance(&prefix_str, &a.suggestion.value);
+                    let b_distance = levenshtein_distance(&prefix_str, &b.suggestion.value);
                     a_distance.cmp(&b_distance)
                 });
             }
             SortBy::Ascending => {
-                filtered_items.sort_by(|a, b| a.value.cmp(&b.value));
+                filtered_items.sort_by(|a, b| a.suggestion.value.cmp(&b.suggestion.value));
             }
             SortBy::None => {}
         };
 
         filtered_items
     }
 }
+
+#[derive(Debug, Default, PartialEq)]
+pub struct SemanticSuggestion {
+    pub suggestion: Suggestion,
+    pub kind: Option<SuggestionKind>,
+}
+
+// TODO: think about name: maybe suggestion context?
+#[derive(Clone, Debug, PartialEq)]
+pub enum SuggestionKind {
+    Command(nu_protocol::engine::CommandType),
+    Type(nu_protocol::Type),
+}
+
+impl From<Suggestion> for SemanticSuggestion {
+    fn from(suggestion: Suggestion) -> Self {
+        Self {
+            suggestion,
+            ..Default::default()
+        }
+    }
+}

crates/nu-cli/src/completions/command_completions.rs

@@ -1,4 +1,7 @@
-use crate::completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy};
+use crate::{
+    completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy},
+    SuggestionKind,
+};
 use nu_parser::FlatShape;
 use nu_protocol::{
     engine::{CachedFile, EngineState, StateWorkingSet},
@@ -7,6 +10,8 @@ use nu_protocol::{
 use reedline::Suggestion;
 use std::sync::Arc;
 
+use super::SemanticSuggestion;
+
 pub struct CommandCompletion {
     engine_state: Arc<EngineState>,
     flattened: Vec<(Span, FlatShape)>,
@@ -83,21 +88,24 @@ impl CommandCompletion {
         offset: usize,
         find_externals: bool,
         match_algorithm: MatchAlgorithm,
-    ) -> Vec<Suggestion> {
+    ) -> Vec<SemanticSuggestion> {
         let partial = working_set.get_span_contents(span);
 
         let filter_predicate = |command: &[u8]| match_algorithm.matches_u8(command, partial);
 
         let mut results = working_set
             .find_commands_by_predicate(filter_predicate, true)
             .into_iter()
-            .map(move |x| Suggestion {
-                value: String::from_utf8_lossy(&x.0).to_string(),
-                description: x.1,
-                style: None,
-                extra: None,
-                span: reedline::Span::new(span.start - offset, span.end - offset),
-                append_whitespace: true,
+            .map(move |x| SemanticSuggestion {
+                suggestion: Suggestion {
+                    value: String::from_utf8_lossy(&x.0).to_string(),
+                    description: x.1,
+                    style: None,
+                    extra: None,
+                    span: reedline::Span::new(span.start - offset, span.end - offset),
+                    append_whitespace: true,
+                },
+                kind: Some(SuggestionKind::Command(x.2)),
             })
             .collect::<Vec<_>>();
 
@@ -108,27 +116,34 @@ impl CommandCompletion {
             let results_external = self
                 .external_command_completion(&partial, match_algorithm)
                 .into_iter()
-                .map(move |x| Suggestion {
-                    value: x,
-                    description: None,
-                    style: None,
-                    extra: None,
-                    span: reedline::Span::new(span.start - offset, span.end - offset),
-                    append_whitespace: true,
+                .map(move |x| SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: x,
+                        description: None,
+                        style: None,
+                        extra: None,
+                        span: reedline::Span::new(span.start - offset, span.end - offset),
+                        append_whitespace: true,
+                    },
+                    // TODO: is there a way to create a test?
+                    kind: None,
                 });
 
             let results_strings: Vec<String> =
-                results.clone().into_iter().map(|x| x.value).collect();
+                results.iter().map(|x| x.suggestion.value.clone()).collect();
 
             for external in results_external {
-                if results_strings.contains(&external.value) {
-                    results.push(Suggestion {
-                        value: format!("^{}", external.value),
-                        description: None,
-                        style: None,
-                        extra: None,
-                        span: external.span,
-                        append_whitespace: true,
+                if results_strings.contains(&external.suggestion.value) {
+                    results.push(SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: format!("^{}", external.suggestion.value),
+                            description: None,
+                            style: None,
+                            extra: None,
+                            span: external.suggestion.span,
+                            append_whitespace: true,
+                        },
+                        kind: external.kind,
                     })
                 } else {
                     results.push(external)
@@ -151,7 +166,7 @@ impl Completer for CommandCompletion {
         offset: usize,
         pos: usize,
         options: &CompletionOptions,
-    ) -> Vec<Suggestion> {
+    ) -> Vec<SemanticSuggestion> {
         let last = self
             .flattened
             .iter()

crates/nu-cli/src/completions/completer.rs

@@ -14,6 +14,8 @@ use reedline::{Completer as ReedlineCompleter, Suggestion};
 use std::str;
 use std::sync::Arc;
 
+use super::base::{SemanticSuggestion, SuggestionKind};
+
 #[derive(Clone)]
 pub struct NuCompleter {
     engine_state: Arc<EngineState>,
@@ -28,6 +30,10 @@ impl NuCompleter {
         }
     }
 
+    pub fn fetch_completions_at(&mut self, line: &str, pos: usize) -> Vec<SemanticSuggestion> {
+        self.completion_helper(line, pos)
+    }
+
     // Process the completion for a given completer
     fn process_completion<T: Completer>(
         &self,
@@ -37,7 +43,7 @@ impl NuCompleter {
         new_span: Span,
         offset: usize,
         pos: usize,
-    ) -> Vec<Suggestion> {
+    ) -> Vec<SemanticSuggestion> {
         let config = self.engine_state.get_config();
 
         let options = CompletionOptions {
@@ -62,7 +68,7 @@ impl NuCompleter {
         spans: &[String],
         offset: usize,
         span: Span,
-    ) -> Option<Vec<Suggestion>> {
+    ) -> Option<Vec<SemanticSuggestion>> {
         let block = self.engine_state.get_block(block_id);
         let mut callee_stack = self
             .stack
@@ -107,7 +113,7 @@ impl NuCompleter {
         None
     }
 
-    fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+    fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<SemanticSuggestion> {
         let mut working_set = StateWorkingSet::new(&self.engine_state);
         let offset = working_set.next_span_start();
         // TODO: Callers should be trimming the line themselves
@@ -397,6 +403,9 @@ impl NuCompleter {
 impl ReedlineCompleter for NuCompleter {
     fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
         self.completion_helper(line, pos)
+            .into_iter()
+            .map(|s| s.suggestion)
+            .collect()
     }
 }
 
@@ -454,20 +463,23 @@ pub fn map_value_completions<'a>(
     list: impl Iterator<Item = &'a Value>,
     span: Span,
     offset: usize,
-) -> Vec<Suggestion> {
+) -> Vec<SemanticSuggestion> {
     list.filter_map(move |x| {
         // Match for string values
         if let Ok(s) = x.coerce_string() {
-            return Some(Suggestion {
-                value: s,
-                description: None,
-                style: None,
-                extra: None,
-                span: reedline::Span {
-                    start: span.start - offset,
-                    end: span.end - offset,
+            return Some(SemanticSuggestion {
+                suggestion: Suggestion {
+                    value: s,
+                    description: None,
+                    style: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                    append_whitespace: false,
                 },
-                append_whitespace: false,
+                kind: Some(SuggestionKind::Type(x.get_type())),
             });
         }
 
@@ -516,7 +528,10 @@ pub fn map_value_completions<'a>(
                 }
             });
 
-            return Some(suggestion);
+            return Some(SemanticSuggestion {
+                suggestion,
+                kind: Some(SuggestionKind::Type(x.get_type())),
+            });
         }
 
         None
@@ -568,13 +583,13 @@ mod completer_tests {
             // Test whether the result begins with the expected value
             result
                 .iter()
-                .for_each(|x| assert!(x.value.starts_with(begins_with)));
+                .for_each(|x| assert!(x.suggestion.value.starts_with(begins_with)));
 
             // Test whether the result contains all the expected values
             assert_eq!(
                 result
                     .iter()
-                    .map(|x| expected_values.contains(&x.value.as_str()))
+                    .map(|x| expected_values.contains(&x.suggestion.value.as_str()))
                     .filter(|x| *x)
                     .count(),
                 expected_values.len(),

crates/nu-cli/src/completions/custom_completions.rs

@@ -7,10 +7,10 @@ use nu_protocol::{
     PipelineData, Span, Type, Value,
 };
 use nu_utils::IgnoreCaseExt;
-use reedline::Suggestion;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use super::base::SemanticSuggestion;
 use super::completer::map_value_completions;
 
 pub struct CustomCompletion {
@@ -42,7 +42,7 @@ impl Completer for CustomCompletion {
         offset: usize,
         pos: usize,
         completion_options: &CompletionOptions,
-    ) -> Vec<Suggestion> {
+    ) -> Vec<SemanticSuggestion> {
         // Line position
         let line_pos = pos - offset;
 
@@ -145,15 +145,22 @@ impl Completer for CustomCompletion {
     }
 }
 
-fn filter(prefix: &[u8], items: Vec<Suggestion>, options: &CompletionOptions) -> Vec<Suggestion> {
+fn filter(
+    prefix: &[u8],
+    items: Vec<SemanticSuggestion>,
+    options: &CompletionOptions,
+) -> Vec<SemanticSuggestion> {
     items
         .into_iter()
         .filter(|it| match options.match_algorithm {
             MatchAlgorithm::Prefix => match (options.case_sensitive, options.positional) {
-                (true, true) => it.value.as_bytes().starts_with(prefix),
-                (true, false) => it.value.contains(std::str::from_utf8(prefix).unwrap_or("")),
+                (true, true) => it.suggestion.value.as_bytes().starts_with(prefix),
+                (true, false) => it
+                    .suggestion
+                    .value
+                    .contains(std::str::from_utf8(prefix).unwrap_or("")),
                 (false, positional) => {
-                    let value = it.value.to_folded_case();
+                    let value = it.suggestion.value.to_folded_case();
                     let prefix = std::str::from_utf8(prefix).unwrap_or("").to_folded_case();
                     if positional {
                         value.starts_with(&prefix)
@@ -164,7 +171,7 @@ fn filter(prefix: &[u8], items: Vec<Suggestion>, options: &CompletionOptions) ->
             },
             MatchAlgorithm::Fuzzy => options
                 .match_algorithm
-                .matches_u8(it.value.as_bytes(), prefix),
+                .matches_u8(it.suggestion.value.as_bytes(), prefix),
         })
         .collect()
 }