feat: Complex outputs from acir call

compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs

@@ -282,7 +282,7 @@
         brillig: &Brillig,
     ) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
         let mut acirs = Vec::new();
         // TODO: can we parallelise this?
         let mut shared_context = SharedContext::default();
         for function in self.functions.values() {
             let context = Context::new(&mut shared_context);
@@ -713,11 +713,10 @@
                                 assert!(!matches!(inline_type, InlineType::Inline), "ICE: Got an ACIR function named {} that should have already been inlined", func.name());
 
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
-                                // TODO(https://github.com/noir-lang/noir/issues/4608): handle complex return types from ACIR functions
-                                let output_count =
-                                    result_ids.iter().fold(0usize, |sum, result_id| {
-                                        sum + dfg.try_get_array_length(*result_id).unwrap_or(1)
-                                    });
+                                let output_count = result_ids
+                                    .iter()
+                                    .map(|result_id| dfg.type_of_value(*result_id).flattened_size())
+                                    .sum();
 
                                 let acir_function_id = ssa
                                     .entry_point_to_generated_index
@@ -729,6 +728,7 @@
                                     output_count,
                                     self.current_side_effects_enabled_var,
                                 )?;
+
                                 let output_values =
                                     self.convert_vars_to_values(output_vars, dfg, result_ids);
 

test_programs/execution_success/fold_complex_outputs/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "fold_complex_outputs"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]

test_programs/execution_success/fold_complex_outputs/Prover.toml

@@ -0,0 +1,2 @@
+x = "5"
+y = "3"

test_programs/execution_success/fold_complex_outputs/src/main.nr

@@ -0,0 +1,72 @@
+struct MyStruct {
+    x: u32,
+    y: u32,
+    z: u32,
+    nested_struct: InnerStruct
+}
+
+struct InnerStruct {
+    small_array: [u32; 2],
+    big_array: [u32; 5],
+}
+
+struct ParentStruct {
+    basic_array: [Field; 3],
+    id: u32,
+    my_structs: [MyStruct; 2],
+}
+
+fn main(x: u32, y: pub u32) {
+    let nested_struct = InnerStruct { small_array: [1 as u32; 2], big_array: [0 as u32; 5] };
+    let s = MyStruct { x, y, z: x + y, nested_struct };
+    let parent = ParentStruct { basic_array: [1; 3], id: 100, my_structs: [s, s] };
+    let new_parent = map_fields(parent);
+
+    // Now check that the outputs are as we expect them to be
+    assert(new_parent.basic_array[0] == 1);
+    assert(new_parent.basic_array[1] == 18);
+    assert(new_parent.basic_array[2] == 1);
+
+    let struct_0 = new_parent.my_structs[0];
+    assert(struct_0.x == 5);
+    assert(struct_0.y == 3);
+    assert(struct_0.z == 8);
+    assert(struct_0.nested_struct.small_array == nested_struct.small_array);
+    assert(struct_0.nested_struct.big_array == nested_struct.big_array);
+
+    let struct_1 = new_parent.my_structs[1];
+    assert(struct_1.x == 50);
+    assert(struct_1.y == 30);
+    assert(struct_1.z == 80);
+    assert(struct_1.nested_struct.small_array == [5, 10]);
+    assert(struct_1.nested_struct.big_array == [15, 20, 25, 30, 35]);
+}
+
+// Meaningless mapping to test whether the values returned are what we expect
+#[fold]
+fn map_fields(mut input: ParentStruct) -> ParentStruct {
+    let current_struct = input.my_structs[0];
+    let mut sum = 0;
+    for value in current_struct.nested_struct.small_array {
+        sum += value;
+    }
+    for value in current_struct.nested_struct.big_array {
+        sum += value;
+    }
+    sum += (current_struct.x + current_struct.y + current_struct.z);
+
+    input.basic_array[1] = sum as Field;
+
+    input.my_structs[1].nested_struct.small_array = [5, 10];
+    input.my_structs[1].nested_struct.big_array = [15, 20, 25, 30, 35];
+
+    // LHS input.my_structs[1].x == 50
+    input.my_structs[1].x = input.my_structs[1].x * 10;
+    // LHS input.my_structs[1].y == 30
+    input.my_structs[1].y = input.my_structs[1].y * 10;
+    // LHS input.my_structs[1].x == 80
+    input.my_structs[1].z = input.my_structs[1].x + input.my_structs[1].y;
+
+    input
+}
+

tooling/debugger/ignored-tests.txt

@@ -22,3 +22,4 @@ no_predicates_numeric_generic_poseidon
 regression_4709
 fold_distinct_return
 fold_fibonacci
+fold_complex_outputs