add function module

it combines function and docs into one HashMap with clear interface for
getting functions or docs for them

Author: gerau

src/backend.rs

@@ -28,14 +28,14 @@ use simplicityhl::{
 };
 
 use crate::completion::{self, CompletionProvider};
+use crate::function::Functions;
 use crate::utils::{
     find_related_call, get_call_span, get_comments_from_lines, position_to_span, span_to_positions,
 };
 
 #[derive(Debug)]
 struct Document {
-    functions: Vec<parse::Function>,
-    functions_docs: HashMap<String, String>,
+    functions: Functions,
     text: Rope,
 }
 
@@ -243,18 +243,8 @@ impl Backend {
             return None;
         }
 
-        let mut completions = CompletionProvider::get_function_completions(
-            &doc.functions
-                .iter()
-                .map(|func| {
-                    let function_doc = doc
-                        .functions_docs
-                        .get(&func.name().to_string())
-                        .map_or(String::new(), String::clone);
-                    (func.to_owned(), function_doc)
-                })
-                .collect::<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());
 
@@ -269,8 +259,8 @@ impl Backend {
         let token_pos = params.text_document_position_params.position;
         let token_span = position_to_span(token_pos).ok()?;
 
-        let call = find_related_call(&document.functions, token_span).ok()?;
-        let call_span = get_call_span(call).ok()?;
+        let call = find_related_call(&document.functions.functions(), token_span).ok()?;
+        let call_span = get_call_span(&call).ok()?;
         let (start, end) = span_to_positions(&call_span).ok()?;
 
         let description = match call.name() {
@@ -289,8 +279,7 @@ impl Backend {
                 )
             }
             parse::CallName::Custom(func) => {
-                let function = document.functions.iter().find(|f| f.name() == func)?;
-                let function_doc = document.functions_docs.get(&func.to_string())?;
+                let (function, function_doc) = document.functions.get(func.as_inner())?;
 
                 let template = completion::function_to_template(function, function_doc);
                 format!(
@@ -335,14 +324,11 @@ impl Backend {
         let token_position = params.text_document_position_params.position;
         let token_span = position_to_span(token_position).ok()?;
 
-        let call = find_related_call(&document.functions, token_span).ok()?;
+        let call = find_related_call(&document.functions.functions(), token_span).ok()?;
 
         match call.name() {
             simplicityhl::parse::CallName::Custom(func) => {
-                let function = document
-                    .functions
-                    .iter()
-                    .find(|function| function.name() == func)?;
+                let function = document.functions.get_func(func.as_inner())?;
 
                 let (start, end) = span_to_positions(function.as_ref()).ok()?;
                 Some(GotoDefinitionResponse::from(Location::new(
@@ -358,8 +344,7 @@ impl Backend {
 /// Create [`Document`] using parsed program and code.
 fn create_document(program: &simplicityhl::parse::Program, text: &str) -> Document {
     let mut document = Document {
-        functions: vec![],
-        functions_docs: HashMap::new(),
+        functions: Functions::new(),
         text: Rope::from_str(text),
     };
 
@@ -376,9 +361,9 @@ fn create_document(program: &simplicityhl::parse::Program, text: &str) -> Docume
         .for_each(|func| {
             let start_line = u32::try_from(func.as_ref().start.line.get()).unwrap_or_default() - 1;
 
-            document.functions.push(func.to_owned());
-            document.functions_docs.insert(
+            document.functions.insert(
                 func.name().to_string(),
+                func.to_owned(),
                 get_comments_from_lines(start_line, &document.text),
             );
         });
@@ -423,7 +408,6 @@ mod tests {
         assert!(err.is_none(), "Expected no parsing error");
         let doc = doc.expect("Expected Some(Document)");
         assert_eq!(doc.functions.len(), 2);
-        assert!(doc.functions_docs.contains_key("add"));
     }
 
     #[test]

src/completion/mod.rs

@@ -64,7 +64,7 @@ impl CompletionProvider {
     }
 
     /// Get generic functions completions.
-    pub fn get_function_completions(functions: &[(Function, String)]) -> Vec<CompletionItem> {
+    pub fn get_function_completions(functions: &Vec<(&Function, &String)>) -> Vec<CompletionItem> {
         functions
             .iter()
             .map(|(func, doc)| {

src/function.rs

@@ -0,0 +1,64 @@
+use simplicityhl::parse::Function;
+use std::collections::HashMap;
+
+/// Container for parsed functions and their corresponding source text.
+#[derive(Debug, Clone)]
+pub struct Functions {
+    /// The map from function name to its parsed representation and source text.
+    pub map: HashMap<String, (Function, String)>,
+}
+
+#[allow(dead_code)]
+impl Functions {
+    /// Creates a new, empty `Functions` structure.
+    pub fn new() -> Self {
+        Self {
+            map: HashMap::new(),
+        }
+    }
+
+    /// Inserts or updates a function and its document text.
+    pub fn insert(&mut self, name: String, func: Function, doc: String) {
+        self.map.insert(name, (func, doc));
+    }
+
+    /// Get pair of function and documentation.
+    pub fn get(&self, name: &str) -> Option<(&Function, &String)> {
+        self.map.get(name).map(|(func, doc)| (func, doc))
+    }
+
+    /// Retrieves a reference to a parsed function by name.
+    pub fn get_func(&self, name: &str) -> Option<&Function> {
+        self.map.get(name).map(|(func, _)| func)
+    }
+
+    /// Retrieves a reference to the function's documentation.
+    pub fn get_doc(&self, name: &str) -> Option<&String> {
+        self.map.get(name).map(|(_, doc)| doc)
+    }
+
+    /// Returns lenght of inner map.
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Returns all function names.
+    pub fn keys(&self) -> impl Iterator<Item = &String> {
+        self.map.keys()
+    }
+
+    /// Returns a vector of all parsed functions.
+    pub fn functions(&self) -> Vec<&Function> {
+        self.map.values().map(|(func, _)| func).collect()
+    }
+
+    /// Returns a vector of all function document strings.
+    pub fn documentations(&self) -> Vec<&String> {
+        self.map.values().map(|(_, doc)| doc).collect()
+    }
+
+    /// Returns a vector of (function name, function) pairs.
+    pub fn functions_and_docs(&self) -> Vec<(&Function, &String)> {
+        self.map.values().map(|(func, doc)| (func, doc)).collect()
+    }
+}

src/main.rs

@@ -1,5 +1,6 @@
 mod backend;
 mod completion;
+mod function;
 mod utils;
 
 use backend::Backend;

src/utils.rs

@@ -159,9 +159,9 @@ pub fn get_comments_from_lines(line: u32, rope: &Rope) -> String {
 
 /// Find [`simplicityhl::parse::Call`] which contains given [`simplicityhl::error::Span`], which also have minimal Span.
 pub fn find_related_call(
-    functions: &[parse::Function],
+    functions: &[&parse::Function],
     token_span: simplicityhl::error::Span,
-) -> std::result::Result<&simplicityhl::parse::Call, &'static str> {
+) -> std::result::Result<simplicityhl::parse::Call, &'static str> {
     let func = functions
         .iter()
         .find(|func| span_contains(func.span(), &token_span))
@@ -182,7 +182,7 @@ pub fn find_related_call(
         .last()
         .ok_or("no related call found")?;
 
-    Ok(call)
+    Ok(call.to_owned())
 }
 
 pub fn get_call_span(