chore: rename FunctionCompletionTemplate to FunctionTemplate

Author: gerau

src/completion/builtin.rs

@@ -1,4 +1,4 @@
-use crate::completion::types::FunctionCompletionTemplate;
+use crate::completion::types::FunctionTemplate;
 
 /// Macro to convert string literals into `Vec<String>`
 macro_rules! str_vec {
@@ -13,62 +13,62 @@ macro_rules! str_vec {
 // TODO: More verbose descriptions with examples
 
 /// Get completion of builtin functions. They are all defined in `simplicityhl::parse::CallName`
-pub fn get_builtin_functions() -> Vec<FunctionCompletionTemplate> {
+pub fn get_builtin_functions() -> Vec<FunctionTemplate> {
     vec![
-        FunctionCompletionTemplate::simple(
+        FunctionTemplate::simple(
             "assert!",
             str_vec!["bool"],
             "",
             "Fails program if argument is 'false'",
         ),
-        FunctionCompletionTemplate::simple(
+        FunctionTemplate::simple(
             "dbg!",
             str_vec!["type"],
             "type",
             "Print value and return it",
         ),
-        FunctionCompletionTemplate::simple("panic!", str_vec![], "", "Fails program"),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::simple("panic!", str_vec![], "", "Fails program"),
+        FunctionTemplate::new(
             "unwrap_left::<T>",
             "unwrap_left",
             str_vec!["T"],
             str_vec!["Either<T, U>"],
             "T",
             "Unwrap left side of Either",
         ),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::new(
             "unwrap_right::<U>",
             "unwrap_right",
             str_vec!["U"],
             str_vec!["Either<T, U>"],
             "U",
             "Unwrap right side of Either",
         ),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::new(
             "is_none::<T>",
             "is_none",
             str_vec!["T"],
             str_vec!["Option<T>"],
             "bool",
             "Check if Option is None",
         ),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::new(
             "fold::<F, B>",
             "fold",
             str_vec!["F", "B"],
             str_vec!["iter", "init"],
             "B",
             "Fold operation over an iterator",
         ),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::new(
             "array_fold::<F, N>",
             "array_fold",
             str_vec!["F", "N"],
             str_vec!["array", "init"],
             "B",
             "Fold operation over an array of size N",
         ),
-        FunctionCompletionTemplate::new(
+        FunctionTemplate::new(
             "for_while::<F>",
             "for_while",
             str_vec!["F"],

src/completion/jet.rs

@@ -4,12 +4,12 @@ use simplicityhl::jet;
 use simplicityhl::simplicity::jet::Elements;
 
 /// Convert all jets to `FunctionCompletionTemplate`.
-pub fn get_jets_completions() -> Vec<types::FunctionCompletionTemplate> {
+pub fn get_jets_completions() -> Vec<types::FunctionTemplate> {
     Elements::ALL
         .iter()
         .copied()
         .map(|jet| {
-            types::FunctionCompletionTemplate::simple(
+            types::FunctionTemplate::simple(
                 jet.to_string(),
                 jet::source_type(jet)
                     .iter()

src/completion/mod.rs

@@ -54,7 +54,7 @@ impl CompletionProvider {
 
 /// Convert `simplicityhl::parse::Function` to `CompletionItem`.
 fn function_to_completion_item(func: &Function) -> CompletionItem {
-    let template = types::FunctionCompletionTemplate::simple(
+    let template = types::FunctionTemplate::simple(
         func.name().to_string(),
         func.params()
             .iter()
@@ -70,7 +70,7 @@ fn function_to_completion_item(func: &Function) -> CompletionItem {
 }
 
 /// Convert `FunctionCompletionTemplate` to `CompletionItem`.
-fn template_to_completion(func: &types::FunctionCompletionTemplate) -> CompletionItem {
+fn template_to_completion(func: &types::FunctionTemplate) -> CompletionItem {
     CompletionItem {
         label: func.display_name.clone(),
         kind: Some(CompletionItemKind::FUNCTION),

src/completion/types.rs

@@ -1,6 +1,6 @@
 /// Template for all functions
 #[derive(Debug, Clone)]
-pub struct FunctionCompletionTemplate {
+pub struct FunctionTemplate {
     /// Display name shown in completion list
     pub display_name: String,
     /// Base name for snippet
@@ -15,7 +15,7 @@ pub struct FunctionCompletionTemplate {
     pub description: String,
 }
 
-impl FunctionCompletionTemplate {
+impl FunctionTemplate {
     /// Create a template with generics (currently used only for builtin functions)
     pub fn new(
         display_name: impl Into<String>,