add conversion from CallName in simplicity::parse to FunctionTemplate

Author: gerau

src/completion/builtin.rs

@@ -1,3 +1,12 @@
+use std::num::NonZero;
+
+use simplicityhl::{
+    num::NonZeroPow2Usize,
+    parse::CallName,
+    str::{AliasName, FunctionName},
+    types::AliasedType,
+};
+
 use crate::completion::types::FunctionTemplate;
 
 /// Macro to convert string literals into `Vec<String>`
@@ -14,67 +23,117 @@ macro_rules! str_vec {
 
 /// Get completion of builtin functions. They are all defined in `simplicityhl::parse::CallName`
 pub fn get_builtin_functions() -> Vec<FunctionTemplate> {
-    vec![
-        FunctionTemplate::simple(
+    let ty = AliasedType::from(AliasName::from_str_unchecked("T"));
+    let Some(some) = NonZero::new(1) else {
+        return vec![];
+    };
+
+    let functions = vec![
+        CallName::UnwrapLeft(ty.clone()),
+        CallName::UnwrapRight(ty.clone()),
+        CallName::Unwrap,
+        CallName::IsNone(ty.clone()),
+        CallName::Assert,
+        CallName::Debug,
+        CallName::Panic,
+        CallName::Fold(
+            FunctionName::from_str_unchecked("name"),
+            NonZeroPow2Usize::TWO,
+        ),
+        CallName::ArrayFold(FunctionName::from_str_unchecked("name"), some),
+        CallName::ForWhile(FunctionName::from_str_unchecked("name")),
+    ];
+
+    functions
+        .iter()
+        .filter_map(|func| match_callname(func.to_owned()))
+        .collect()
+}
+
+fn match_callname(call: CallName) -> Option<FunctionTemplate> {
+    match call {
+        CallName::UnwrapLeft(aliased_type) => {
+            let ty = aliased_type.to_string();
+            Some(FunctionTemplate::new(
+                format!("unwrap_left::<{ty}>"),
+                "unwrap_left",
+                str_vec![format!("{ty}")],
+                str_vec![format!("Either<{ty}, U>")],
+                ty,
+                "Unwrap left side of `Either`",
+            ))
+        }
+        CallName::UnwrapRight(aliased_type) => {
+            let ty = aliased_type.to_string();
+            Some(FunctionTemplate::new(
+                format!("unwrap_right::<{ty}>"),
+                "unwrap_left",
+                str_vec![format!("{ty}")],
+                str_vec![format!("Either<T, {ty}>")],
+                ty,
+                "Unwrap right side of `Either`",
+            ))
+        }
+        CallName::Unwrap => Some(FunctionTemplate::simple(
+            "unwrap",
+            str_vec!["Option<T>"],
+            "T",
+            "Unwrap `Option` type",
+        )),
+        CallName::IsNone(aliased_type) => {
+            let ty = aliased_type.to_string();
+            Some(FunctionTemplate::new(
+                format!("is_none::<{ty}>"),
+                "is_none",
+                str_vec![format!("{ty}")],
+                str_vec![format!("Option<{ty}>").as_str()],
+                "bool",
+                "Check if `Option` is None",
+            ))
+        }
+        CallName::Assert => Some(FunctionTemplate::simple(
             "assert!",
             str_vec!["bool"],
             "",
             "Fails program if argument is 'false'",
-        ),
-        FunctionTemplate::simple(
+        )),
+        CallName::Panic => Some(FunctionTemplate::simple(
+            "panic!",
+            str_vec![],
+            "",
+            "Fails program",
+        )),
+        CallName::Debug => Some(FunctionTemplate::simple(
             "dbg!",
-            str_vec!["type"],
-            "type",
-            "Print value and return it",
-        ),
-        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",
-        ),
-        FunctionTemplate::new(
-            "unwrap_right::<U>",
-            "unwrap_right",
-            str_vec!["U"],
-            str_vec!["Either<T, U>"],
-            "U",
-            "Unwrap right side of Either",
-        ),
-        FunctionTemplate::new(
-            "is_none::<T>",
-            "is_none",
-            str_vec!["T"],
-            str_vec!["Option<T>"],
-            "bool",
-            "Check if Option is None",
-        ),
-        FunctionTemplate::new(
+            "Print value and return it",
+        )),
+        CallName::Fold(_, _) => Some(FunctionTemplate::new(
             "fold::<F, B>",
             "fold",
             str_vec!["F", "B"],
             str_vec!["iter", "init"],
             "B",
             "Fold operation over an iterator",
-        ),
-        FunctionTemplate::new(
+        )),
+        CallName::ArrayFold(_, _) => Some(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",
-        ),
-        FunctionTemplate::new(
+        )),
+        CallName::ForWhile(_) => Some(FunctionTemplate::new(
             "for_while::<F>",
             "for_while",
             str_vec!["F"],
             str_vec!["condition", "body"],
             "()",
             "While loop with a function",
-        ),
-    ]
+        )),
+        // TODO: implement TypeCast definition
+        CallName::Jet(_) | CallName::TypeCast(_) | CallName::Custom(_) => None,
+    }
 }