Implement first-class functions

crates/iter-extended/src/lib.rs

@@ -9,7 +9,16 @@ where
     iterable.into_iter().map(f).collect()
 }
 
-/// Equivalent to .into_iter().map(f).collect()
+/// Equivalent to .into_iter().map(f).collect::<Result<Vec<_>,_>>()
+pub fn try_vecmap<T, U, E, F>(iterable: T, f: F) -> Result<Vec<U>, E>
+where
+    T: IntoIterator,
+    F: FnMut(T::Item) -> Result<U, E>,
+{
+    iterable.into_iter().map(f).collect()
+}
+
+/// Equivalent to .into_iter().map(f).collect::<BTreeMap<K, V>>()
 pub fn btree_map<T, K, V, F>(iterable: T, f: F) -> BTreeMap<K, V>
 where
     T: IntoIterator,

crates/nargo/tests/prove_and_verify.rs

@@ -41,11 +41,21 @@ mod tests {
         cdir.push(TEST_DATA_DIR);
 
         for c in fs::read_dir(cdir.as_path()).unwrap().flatten() {
-            let test_name = c.file_name().into_string();
-            if let Ok(str) = test_name {
-                if c.path().is_dir() && !conf_data["exclude"].contains(&str) {
-                    let r = nargo::cli::prove_and_verify("pp", &c.path(), false);
-                    if conf_data["fail"].contains(&str) {
+            if let Ok(test_name) = c.file_name().into_string() {
+                println!("Running test {:?}", test_name);
+                if c.path().is_dir() && !conf_data["exclude"].contains(&test_name) {
+                    let verified = std::panic::catch_unwind(|| {
+                        nargo::cli::prove_and_verify("pp", &c.path(), false)
+                    });
+
+                    let r = match verified {
+                        Ok(result) => result,
+                        Err(_) => {
+                            panic!("\n\n\nPanic occured while running test {:?} (ignore the following panic)", c.file_name());
+                        }
+                    };
+
+                    if conf_data["fail"].contains(&test_name) {
                         assert!(!r, "{:?} should not succeed", c.file_name());
                     } else {
                         assert!(r, "verification fail for {:?}", c.file_name());

crates/nargo/tests/test_data/higher-order-functions/Prover.toml

@@ -0,0 +1 @@
+return = "5"

crates/nargo/tests/test_data/higher-order-functions/src/main.nr

@@ -0,0 +1,22 @@
+fn main() -> pub Field {
+    let f = if 3 * 7 > 200 { foo } else { bar };
+    constrain f()[1] == 2;
+
+    twice(add1, 3)
+}
+
+fn foo() -> [u32; 2] {
+    [1, 3]
+}
+
+fn bar() -> [u32; 2] {
+    [3, 2]
+}
+
+fn add1(x: Field) -> Field {
+    x + 1
+}
+
+fn twice(f: fn(Field) -> Field, x: Field) -> Field {
+    f(f(x))
+}

crates/noirc_driver/src/lib.rs

@@ -186,10 +186,10 @@ impl Driver {
         let func_meta = self.context.def_interner.function_meta(&main_function);
         let abi = func_meta.into_abi(&self.context.def_interner);
 
-        let ast = monomorphise(main_function, self.context.def_interner);
+        let program = monomorphise(main_function, self.context.def_interner);
 
         // Compile Program
-        let circuit = match create_circuit(ast, np_language, show_ssa) {
+        let circuit = match create_circuit(program, np_language, show_ssa) {
             Ok(circuit) => circuit,
             Err(err) => {
                 // The FileId here will be the file id of the file with the main file

crates/noirc_evaluator/src/lib.rs

@@ -112,7 +112,7 @@ impl Evaluator {
     fn param_to_var(
         &mut self,
         name: &str,
-        def: DefinitionId,
+        def: Definition,
         param_type: &AbiType,
         visibility: &AbiVisibility,
         igen: &mut IRGenerator,
@@ -235,9 +235,10 @@ impl Evaluator {
         let abi_params = std::mem::take(&mut igen.program.abi.parameters);
         assert_eq!(main_params.len(), abi_params.len());
 
-        for ((param_id, _, param_name1, _), abi_param) in main_params.iter().zip(abi_params) {
-            assert_eq!(param_name1, &abi_param.name);
-            self.param_to_var(param_name1, *param_id, &abi_param.typ, &abi_param.visibility, igen)
+        for ((param_id, _, param_name, _), abi_param) in main_params.iter().zip(abi_params) {
+            assert_eq!(param_name, &abi_param.name);
+            let def = Definition::Local(*param_id);
+            self.param_to_var(param_name, def, &abi_param.typ, &abi_param.visibility, igen)
                 .unwrap();
         }
     }

crates/noirc_evaluator/src/ssa/block.rs

@@ -1,3 +1,5 @@
+use crate::errors::RuntimeError;
+
 use super::{
     conditional::AssumptionId,
     context::SsaContext,
@@ -110,11 +112,11 @@ impl BasicBlock {
                             result.insert(a);
                         }
                     }
-                    node::Operation::Call { func_id, returned_arrays, .. } => {
+                    node::Operation::Call { func, returned_arrays, .. } => {
                         for a in returned_arrays {
                             result.insert(a.0);
                         }
-                        if let Some(f) = ctx.get_ssafunc(*func_id) {
+                        if let Some(f) = ctx.try_get_ssafunc(*func) {
                             for typ in &f.result_types {
                                 if let node::ObjectType::Pointer(a) = typ {
                                     result.insert(*a);
@@ -474,7 +476,7 @@ pub fn merge_path(
     start: BlockId,
     end: BlockId,
     assumption: Option<NodeId>,
-) -> VecDeque<BlockId> {
+) -> Result<VecDeque<BlockId>, RuntimeError> {
     let mut removed_blocks = VecDeque::new();
     if start != end {
         let mut next = start;
@@ -518,7 +520,7 @@ pub fn merge_path(
 
         //we assign the concatened list of instructions to the start block, using a CSE pass
         let mut modified = false;
-        super::optim::cse_block(ctx, start, &mut instructions, &mut modified).unwrap();
+        super::optim::cse_block(ctx, start, &mut instructions, &mut modified)?;
         //Wires start to end
         if !end.is_dummy() {
             rewire_block_left(ctx, start, end);
@@ -528,7 +530,7 @@ pub fn merge_path(
         removed_blocks.pop_front();
     }
     //housekeeping for the caller
-    removed_blocks
+    Ok(removed_blocks)
 }
 
 // retrieve written arrays along the CFG until we reach stop