Merge branch 'master' into aztec-packages

* master: (25 commits)
  feat: Complex outputs from acir call (#4952)
  fix: Require for all foldable functions to use distinct return  (#4949)
  feat!: use `distinct` return value witnesses by default (#4951)
  chore(docs): adding matomo tracking (#4898)
  chore: fix typo in `ResolverError::AbiAttributeOutsideContract` (#4933)
  chore: Add test for recursing a foldable function (#4948)
  feat: Handle `no_predicates` attribute (#4942)
  fix: ensure where clauses propagated to trait default definitions (#4894)
  chore: Remove unnecessary `pub(super)` in interpreter (#4939)
  feat: add de-sugaring for `impl Trait` in function parameters (#4919)
  feat(experimental): `comptime` globals (#4918)
  chore: update error conversion traits to act on references (#4936)
  fix: ban self-referential structs (#4883)
  chore: add regression test for #3051 (#4815)
  fix: discard ref counts during unrolling (#4923)
  feat!: Bit shift is restricted to u8 right operand (#4907)
  feat: Add `#[inline(tag)]` attribute and codegen (#4913)
  chore: rework workspace structure for utils crates (#4886)
  feat: add variable size sha256 (#4920)
  chore: delete flake.lock (#4855)
  ...

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

@@ -328,14 +328,11 @@ impl Ssa {
             bytecode: brillig.byte_code,
         });
 
-        let runtime_types = self.functions.values().map(|function| function.runtime());
-        for (acir, runtime_type) in acirs.iter_mut().zip(runtime_types) {
-            if matches!(runtime_type, RuntimeType::Acir(_)) {
-                generate_distinct_return_witnesses(acir);
-            }
+        for acir in acirs.iter_mut() {
+            generate_distinct_return_witnesses(acir);
         }
 
-        Ok((acirs, brillig, self.error_selector_to_type))
+        Ok((acirs, brillig))
     }
 }
 
@@ -732,11 +729,10 @@ impl<'a> Context<'a> {
                                 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
@@ -748,6 +744,7 @@ impl<'a> Context<'a> {
                                     output_count,
                                     self.current_side_effects_enabled_var,
                                 )?;
+
                                 let output_values =
                                     self.convert_vars_to_values(output_vars, dfg, result_ids);
 

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

@@ -19,7 +19,7 @@ use super::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
         function::RuntimeType,
-        instruction::{ConstrainError, ErrorType, InstructionId, Intrinsic},
+        instruction::{ConstrainError, InstructionId, Intrinsic},
     },
     ssa_gen::Ssa,
 };

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

@@ -12,7 +12,7 @@ use noirc_frontend::hir_def::types::Type as HirType;
 use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use crate::{
-    errors::RuntimeError,
+    errors::{InternalError, RuntimeError},
     ssa::{function_builder::data_bus::DataBusBuilder, ir::instruction::Intrinsic},
 };
 

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
+}
+