fix(aztec_noir): generalise loop to not always inject a hasher instance

crates/noirc_frontend/src/hir/def_map/aztec_library.rs

@@ -318,7 +318,7 @@
                 let expression = match unresolved_type {
                     // `hasher.add_multiple({ident}.serialize())`
                     UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier),
                     // TODO: if this is an array of structs, we should call serialise on each of them (no methods currently do this yet)
                     UnresolvedTypeData::Array(..) => add_array_to_hasher(identifier),
                     // `hasher.add({ident})`
                     UnresolvedTypeData::FieldElement => add_field_to_hasher(identifier),
@@ -382,13 +382,13 @@
 /// Similarly; Structs will be pushed to the context, after serialize() is called on them.
 /// Arrays will be iterated over and each element will be pushed to the context.
 /// Any primitive type that can be cast will be casted to a field and pushed to the context.
-fn abstract_return_values(func: &mut NoirFunction) -> Option<Statement> {
+fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
     let current_return_type = func.return_type().typ;
     let len = func.def.body.len();
     let last_statement = &func.def.body.0[len - 1];
 
     // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
     // Doesnt need done until we have settled on a kernel size
     // TODO: support tuples here and in inputs -> convert into an issue
 
     // Check if the return type is an expression, if it is, we can handle it
@@ -399,7 +399,7 @@
             UnresolvedTypeData::Array(..) => Some(make_array_return_type(expression.clone())),
             // Cast these types to a field before pushing
             UnresolvedTypeData::Bool | UnresolvedTypeData::Integer(..) => {
                 Some(make_castable_return_type(expression.clone()))
             }
             UnresolvedTypeData::FieldElement => Some(make_return_push(expression.clone())),
             _ => None,
@@ -440,12 +440,12 @@
 /// ```noir
 /// `context.return_values.push_array({push_value}.serialize())`
 fn make_struct_return_type(expression: Expression) -> Statement {
     let serialised_call = method_call(
         expression.clone(), // variable
         "serialize",        // method name
         vec![],             // args
     );
     make_return_push_array(serialised_call)
 }
 
 /// Make array return type
@@ -459,16 +459,22 @@
 fn make_array_return_type(expression: Expression) -> Statement {
     let inner_cast_expression =
         cast(index_array_variable(expression.clone(), "i"), UnresolvedTypeData::FieldElement);
-    create_loop_over(expression.clone(), vec![inner_cast_expression])
+    let assignment = Statement::Semi(method_call(
+        context_return_values(), // variable
+        "push",                  // method name
+        vec![inner_cast_expression],
+    ));
+
+    create_loop_over(expression.clone(), vec![assignment])
 }
 
 /// Castable return type
 ///
 /// Translates to:
 /// ```noir
 /// context.return_values.push({ident} as Field)
 /// ```
 fn make_castable_return_type(expression: Expression) -> Statement {
     // Cast these types to a field before pushing
     let cast_expression = cast(expression.clone(), UnresolvedTypeData::FieldElement);
     make_return_push(cast_expression)
@@ -536,7 +542,7 @@
 
 fn add_struct_to_hasher(identifier: &Ident) -> Statement {
     // If this is a struct, we call serialize and add the array to the hasher
     let serialised_call = method_call(
         variable_path(path(identifier.clone())), // variable
         "serialize",                             // method name
         vec![],                                  // args
@@ -545,11 +551,11 @@
     Statement::Semi(method_call(
         variable("hasher"),    // variable
         "add_multiple",        // method name
         vec![serialised_call], // args
     ))
 }
 
-fn create_loop_over(var: Expression, loop_body: Vec<Expression>) -> Statement {
+fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     // If this is an array of primitive types (integers / fields) we can add them each to the hasher
     // casted to a field
 
@@ -562,12 +568,7 @@
 
     // What will be looped over
     // - `hasher.add({ident}[i] as Field)`
-    let for_loop_block =
-        expression(ExpressionKind::Block(BlockExpression(vec![Statement::Semi(method_call(
-            variable("hasher"), // variable
-            "add",              // method name
-            loop_body,
-        ))])));
+    let for_loop_block = expression(ExpressionKind::Block(BlockExpression(loop_body)));
 
     // `for i in 0..{ident}.len()`
     Statement::Expression(expression(ExpressionKind::For(Box::new(ForExpression {
@@ -590,12 +591,18 @@
         index_array(identifier.clone(), "i"), // lhs - `ident[i]`
         UnresolvedTypeData::FieldElement,     // cast to - `as Field`
     );
-    create_loop_over(variable_ident(identifier.clone()), vec![cast_expression])
+    let block_statement = Statement::Semi(method_call(
+        variable("hasher"), // variable
+        "add",              // method name
+        vec![cast_expression],
+    ));
+
+    create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
 }
 
 fn add_field_to_hasher(identifier: &Ident) -> Statement {
     // `hasher.add({ident})`
     let iden = variable_path(path(identifier.clone()));
     Statement::Semi(method_call(
         variable("hasher"), // variable
         "add",              // method name