fix: fix compilation using aztec feature flag

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

@@ -2,12 +2,13 @@
 use noirc_errors::{CustomDiagnostic, Span};
 
 use crate::graph::CrateId;
+use crate::token::SecondaryAttribute;
 use crate::{
-    hir::Context, token::Attribute, BlockExpression, CallExpression, CastExpression, Distinctness,
-    Expression, ExpressionKind, ForExpression, FunctionReturnType, Ident, ImportStatement,
-    IndexExpression, LetStatement, Literal, MemberAccessExpression, MethodCallExpression,
-    NoirFunction, ParsedModule, Path, PathKind, Pattern, Statement, UnresolvedType,
-    UnresolvedTypeData, Visibility,
+    hir::Context, BlockExpression, CallExpression, CastExpression, Distinctness, Expression,
+    ExpressionKind, ForExpression, FunctionReturnType, Ident, ImportStatement, IndexExpression,
+    LetStatement, Literal, MemberAccessExpression, MethodCallExpression, NoirFunction,
+    ParsedModule, Path, PathKind, Pattern, Statement, UnresolvedType, UnresolvedTypeData,
+    Visibility,
 };
 use noirc_errors::FileDiagnostic;
 
@@ -188,17 +189,19 @@
 fn transform_module(functions: &mut [NoirFunction]) -> bool {
     let mut has_annotated_functions = false;
     for func in functions.iter_mut() {
-        if let Some(Attribute::Custom(custom_attribute)) = func.def.attribute.as_ref() {
-            match custom_attribute.as_str() {
-                "aztec(private)" => {
-                    transform_function("Private", func);
-                    has_annotated_functions = true;
+        for secondary_attribute in func.def.attributes.secondary.clone() {
+            if let SecondaryAttribute::Custom(custom_attribute) = secondary_attribute {
+                match custom_attribute.as_str() {
+                    "aztec(private)" => {
+                        transform_function("Private", func);
+                        has_annotated_functions = true;
+                    }
+                    "aztec(public)" => {
+                        transform_function("Public", func);
+                        has_annotated_functions = true;
+                    }
+                    _ => continue,
                 }
-                "aztec(public)" => {
-                    transform_function("Public", func);
-                    has_annotated_functions = true;
-                }
-                _ => continue,
             }
         }
     }
@@ -318,7 +321,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),
@@ -388,7 +391,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
@@ -399,7 +402,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 +443,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
@@ -468,13 +471,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)
@@ -542,7 +545,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
@@ -551,7 +554,7 @@
     Statement::Semi(method_call(
         variable("hasher"),    // variable
         "add_multiple",        // method name
         vec![serialised_call], // args
     ))
 }
 
@@ -602,7 +605,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