fix(aztec_noir): support bools as input types

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

@@ -321,13 +321,15 @@
                 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),
                     // Add the integer to the hasher, casted to a field
                     // `hasher.add({ident} as Field)`
-                    UnresolvedTypeData::Integer(..) => add_int_to_hasher(identifier),
+                    UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
+                        add_cast_to_hasher(identifier)
+                    }
                     _ => unreachable!("[Aztec Noir] Provided parameter type is not supported"),
                 };
                 injected_expressions.push(expression);
@@ -391,7 +393,7 @@
     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
@@ -402,7 +404,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,
@@ -443,12 +445,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
@@ -471,13 +473,13 @@
     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)
@@ -545,7 +547,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
@@ -554,7 +556,7 @@
     Statement::Semi(method_call(
         variable("hasher"),    // variable
         "add_multiple",        // method name
         vec![serialised_call], // args
     ))
 }
 
@@ -605,7 +607,7 @@
 
 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
@@ -613,7 +615,7 @@
     ))
 }
 
-fn add_int_to_hasher(identifier: &Ident) -> Statement {
+fn add_cast_to_hasher(identifier: &Ident) -> Statement {
     // `hasher.add({ident} as Field)`
     // `{ident} as Field`
     let cast_operation = cast(