Merge #172: LSP: refactor completions, add specific type cast completions

7d4e59d Fixed the typo in the LSP completion strategy (Kyryl R)
037b447 move handling completion types to nom parser (Volodymyr Herashchenko)
f203221 bump lsp crate version to 0.2.1 (Volodymyr Herashchenko)
9725182 add separate tokenizer for completions (Volodymyr Herashchenko)

Pull request description:

ACKs for top commit:
  KyrylR:
    ACK 7d4e59d

Tree-SHA512: d18df2563085d62c433bc4405104c37348744214977106b1869a49e10b4d8d396627df79107c3fae74ec29e908db5543e60d78741b7ea4f0d9c074a652054ad8

Author: KyrylR

lsp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simplicityhl-lsp"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 rust-version = "1.79"
 description = "Language Server Protocol (LSP) server for SimplicityHL."
@@ -22,6 +22,8 @@ thiserror = "2.0.17"
 ropey = "1.6.1"
 miniscript = "12"
 simplicityhl = { version = "0.3.0" }
+nom = "8.0.0"
+lazy_static = "1.5.0"
 
 [lints.rust]
 unsafe_code = "deny"

lsp/src/backend.rs

@@ -74,7 +74,7 @@ impl LanguageServer for Backend {
                 )),
                 completion_provider: Some(CompletionOptions {
                     resolve_provider: Some(false),
-                    trigger_characters: Some(vec![":".to_string()]),
+                    trigger_characters: Some(vec![":".to_string(), "<".to_string()]),
                     work_done_progress_options: WorkDoneProgressOptions::default(),
                     all_commit_characters: None,
                     completion_item: None,
@@ -174,30 +174,12 @@ impl LanguageServer for Backend {
             "RopeSlice to str conversion failed".into(),
         ))?;
 
-        let trimmed_prefix = prefix.trim_end();
-
-        if let Some(last) = trimmed_prefix
-            .rsplit(|c: char| !c.is_alphanumeric() && c != ':')
-            .next()
-        {
-            if last.starts_with("jet:::") {
-                return Ok(Some(CompletionResponse::Array(vec![])));
-            } else if last == "jet::" || last.starts_with("jet::") {
-                return Ok(Some(CompletionResponse::Array(
-                    self.completion_provider.jets().to_vec(),
-                )));
-            }
-        // Completion after a colon is needed only for jets.
-        } else if trimmed_prefix.ends_with(':') {
-            return Ok(Some(CompletionResponse::Array(vec![])));
-        }
-
-        let mut completions =
-            CompletionProvider::get_function_completions(&doc.functions.functions_and_docs());
-        completions.extend_from_slice(self.completion_provider.builtins());
-        completions.extend_from_slice(self.completion_provider.modules());
+        let completions = self
+            .completion_provider
+            .process_completions(prefix, &doc.functions.functions_and_docs())
+            .map(CompletionResponse::Array);
 
-        Ok(Some(CompletionResponse::Array(completions)))
+        Ok(completions)
     }
 
     async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {

lsp/src/completion/mod.rs

@@ -2,12 +2,17 @@ use simplicityhl::parse::Function;
 
 pub mod builtin;
 pub mod jet;
+pub mod tokens;
+pub mod type_cast;
 pub mod types;
 
 use tower_lsp_server::lsp_types::{
     CompletionItem, CompletionItemKind, Documentation, InsertTextFormat, MarkupContent, MarkupKind,
 };
 
+use tokens::parse;
+use tokens::CompletionType;
+
 /// Build and provide [`CompletionItem`] for jets and builtin functions.
 #[derive(Debug)]
 pub struct CompletionProvider {
@@ -19,6 +24,9 @@ pub struct CompletionProvider {
 
     /// Modules completions.
     modules: Vec<CompletionItem>,
+
+    /// Default Type cast completions.
+    type_casts: Vec<CompletionItem>,
 }
 
 impl CompletionProvider {
@@ -41,28 +49,28 @@ impl CompletionProvider {
         .iter()
         .map(|(module, detail)| module_to_completion((*module).to_string(), (*detail).to_string()))
         .collect();
+
+        let type_casts_completion = type_cast::TYPE_CASTS
+            .iter()
+            .map(|(&to, &from)| CompletionItem {
+                label: format!("{to} <- {from}"),
+                kind: Some(CompletionItemKind::FUNCTION),
+                detail: Some(format!("Cast into type `{to}`",)),
+                documentation: None,
+                insert_text: Some(format!("{from}>::into(${{1:{from}}})")),
+                insert_text_format: Some(InsertTextFormat::SNIPPET),
+                ..Default::default()
+            })
+            .collect::<Vec<_>>();
+
         Self {
             jets: jets_completion,
             builtin: builtin_completion,
             modules: modules_completion,
+            type_casts: type_casts_completion,
         }
     }
 
-    /// Return jets completions.
-    pub fn jets(&self) -> &[CompletionItem] {
-        &self.jets
-    }
-
-    /// Return builtin functions completions.
-    pub fn builtins(&self) -> &[CompletionItem] {
-        &self.builtin
-    }
-
-    /// Return builtin functions completions.
-    pub fn modules(&self) -> &[CompletionItem] {
-        &self.modules
-    }
-
     /// Get generic functions completions.
     pub fn get_function_completions(functions: &[(&Function, &str)]) -> Vec<CompletionItem> {
         functions
@@ -73,6 +81,57 @@ impl CompletionProvider {
             })
             .collect()
     }
+
+    /// Return completions based on line and functions provided.
+    pub fn process_completions(
+        &self,
+        prefix: &str,
+        functions: &[(&Function, &str)],
+    ) -> Option<Vec<CompletionItem>> {
+        let completion_type = parse(prefix)?;
+
+        match completion_type {
+            CompletionType::Jet => Some(self.jets.clone()),
+
+            CompletionType::Assignment(type_name) => {
+                let to = type_name.as_str();
+
+                if let Some(from) = type_cast::TYPE_CASTS.get(to) {
+                    return Some(vec![CompletionItem {
+                        label: format!("{to} <- {from}"),
+                        kind: Some(CompletionItemKind::FUNCTION),
+                        detail: Some(format!("Cast into type `{to}`",)),
+                        documentation: None,
+                        insert_text: Some(format!("{from}>::into(${{1:{from}}})")),
+                        insert_text_format: Some(InsertTextFormat::SNIPPET),
+                        ..Default::default()
+                    }]);
+                }
+                Some(self.type_casts.clone())
+            }
+
+            CompletionType::ClosingType => Some(vec![CompletionItem {
+                label: "into".to_string(),
+                kind: Some(CompletionItemKind::FUNCTION),
+                detail: Some("Cast into type".to_string()),
+                documentation: None,
+                insert_text: Some("into(${1:type})".to_string()),
+                insert_text_format: Some(InsertTextFormat::SNIPPET),
+                ..Default::default()
+            }]),
+
+            CompletionType::NonCompletionSymbol => None,
+
+            _ => {
+                let mut completions = CompletionProvider::get_function_completions(functions);
+
+                completions.extend_from_slice(&self.builtin);
+                completions.extend_from_slice(&self.modules);
+
+                Some(completions)
+            }
+        }
+    }
 }
 
 /// Convert [`simplicityhl::parse::Function`] to [`types::FunctionTemplate`].