feat: Explicit Associated Types & Constants

aztec_macros/src/transforms/functions.rs

@@ -267,7 +267,7 @@ fn create_inputs(ty: &str) -> Param {
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_context_inputs
     let type_path = chained_dep!("aztec", "context", "inputs", &path_snippet, ty);
 
-    let context_type = make_type(UnresolvedTypeData::Named(type_path, vec![], true));
+    let context_type = make_type(UnresolvedTypeData::Named(type_path, Default::default(), true));
     let visibility = Visibility::Private;
 
     Param { pattern: context_pattern, typ: context_type, visibility, span: Span::default() }
@@ -396,7 +396,7 @@ fn serialize_to_hasher(
                         Signedness::Unsigned,
                         ast::IntegerBitSize::ThirtyTwo,
                     ),
-                    span: None,
+                    span: Span::default(),
                 },
                 hasher_name,
             ))
@@ -595,7 +595,7 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
                 serialize_to_hasher(&ident(return_value_name), &current_return_type, hasher_name)
                     .ok_or_else(|| AztecMacroError::UnsupportedFunctionReturnType {
                     typ: current_return_type.clone(),
-                    span: func.return_type().span.unwrap_or_default(),
+                    span: func.return_type().span,
                 })?;
 
             replacement_statements.extend(serialization_statements);

aztec_macros/src/transforms/note_interface.rs

@@ -62,8 +62,9 @@ pub fn generate_note_interface_impl(
                     note_struct.name.0.contents
                 )),
             })?;
-        let note_interface_impl_span: Option<Span> =
-            if empty_spans { None } else { trait_impl.object_type.span };
+        let note_interface_impl_span =
+            if empty_spans { Span::default() } else { trait_impl.object_type.span };
+
         // Look for the note struct implementation, generate a default one if it doesn't exist (in order to append methods to it)
         let existing_impl = module.impls.iter_mut().find(|r#impl| match &r#impl.object_type.typ {
             UnresolvedTypeData::Named(path, _, _) => path.last_ident().eq(&note_struct.name),
@@ -87,14 +88,15 @@ pub fn generate_note_interface_impl(
         let mut note_fields = vec![];
         let note_interface_generics = trait_impl
             .trait_generics
+            .ordered_args
             .iter()
             .map(|gen| match gen.typ.clone() {
                 UnresolvedTypeData::Named(path, _, _) => Ok(path.last_name().to_string()),
                 UnresolvedTypeData::Expression(UnresolvedTypeExpression::Constant(val, _)) => {
                     Ok(val.to_string())
                 }
                 _ => Err(AztecMacroError::CouldNotImplementNoteInterface {
-                    span: trait_impl.object_type.span,
+                    span: Some(trait_impl.object_type.span),
                     secondary_message: Some(format!(
                         "NoteInterface must be generic over NOTE_LEN and NOTE_BYTES_LEN: {}",
                         note_type
@@ -119,7 +121,7 @@ pub fn generate_note_interface_impl(
                 ident("header"),
                 make_type(UnresolvedTypeData::Named(
                     chained_dep!("aztec", "note", "note_header", "NoteHeader"),
-                    vec![],
+                    Default::default(),
                     false,
                 )),
             );
@@ -231,7 +233,7 @@ fn generate_note_to_be_bytes(
     note_type: &String,
     byte_length: &str,
     serialized_length: &str,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = format!(
@@ -268,21 +270,21 @@ fn generate_note_to_be_bytes(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn to_be_bytes). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
 
 fn generate_note_get_header(
     note_type: &String,
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = format!(
@@ -300,21 +302,21 @@ fn generate_note_get_header(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn get_header). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
 
 fn generate_note_set_header(
     note_type: &String,
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = format!(
@@ -331,13 +333,13 @@ fn generate_note_set_header(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface  {
             secondary_message: Some("Failed to parse Noir macro code (fn set_header). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
@@ -346,7 +348,7 @@ fn generate_note_set_header(
 // of the conversion of the characters in the note's struct name to unsigned integers.
 fn generate_get_note_type_id(
     note_type_id: u32,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     // TODO(#7165): replace {} with dep::aztec::protocol_types::abis::note_selector::compute_note_selector(\"{}\") in the function source below
@@ -365,13 +367,13 @@ fn generate_get_note_type_id(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn get_note_type_id). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
@@ -389,7 +391,7 @@ fn generate_note_properties_struct(
     note_type: &str,
     note_fields: &[(String, String)],
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirStruct, AztecMacroError> {
     let struct_source =
@@ -400,7 +402,7 @@ fn generate_note_properties_struct(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some(format!("Failed to parse Noir macro code (struct {}Properties). This is either a bug in the compiler or the Noir macro code", note_type)),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
@@ -423,7 +425,7 @@ fn generate_note_deserialize_content(
     note_fields: &[(String, String)],
     note_serialize_len: &String,
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = generate_note_deserialize_content_source(
@@ -438,13 +440,13 @@ fn generate_note_deserialize_content(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn deserialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
@@ -461,7 +463,7 @@ fn generate_note_serialize_content(
     note_fields: &[(String, String)],
     note_serialize_len: &String,
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = generate_note_serialize_content_source(
@@ -476,13 +478,13 @@ fn generate_note_serialize_content(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn serialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
 
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
@@ -492,7 +494,7 @@ fn generate_note_properties_fn(
     note_type: &str,
     note_fields: &[(String, String)],
     note_header_field_name: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source =
@@ -502,12 +504,12 @@ fn generate_note_properties_fn(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn properties). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }
@@ -519,7 +521,7 @@ fn generate_note_properties_fn(
 //
 fn generate_compute_note_hiding_point(
     note_type: &String,
-    impl_span: Option<Span>,
+    impl_span: Span,
     empty_spans: bool,
 ) -> Result<NoirFunction, AztecMacroError> {
     // TODO(#7771): update this to do only 1 MSM call
@@ -541,12 +543,12 @@ fn generate_compute_note_hiding_point(
         dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn compute_note_hiding_point). This is either a bug in the compiler or the Noir macro code".to_string()),
-            span: impl_span
+            span: Some(impl_span)
         });
     }
     let mut function_ast = function_ast.into_sorted();
     let mut noir_fn = function_ast.functions.remove(0);
-    noir_fn.def.span = impl_span.unwrap_or_default();
+    noir_fn.def.span = impl_span;
     noir_fn.def.visibility = ItemVisibility::Public;
     Ok(noir_fn)
 }

aztec_macros/src/transforms/storage.rs

@@ -1,8 +1,9 @@
 use acvm::acir::AcirField;
 use noirc_errors::Span;
 use noirc_frontend::ast::{
-    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
-    NoirStruct, Pattern, StatementKind, TypeImpl, UnresolvedType, UnresolvedTypeData,
+    BlockExpression, Expression, ExpressionKind, FunctionDefinition, GenericTypeArgs, Ident,
+    Literal, NoirFunction, NoirStruct, Pattern, StatementKind, TypeImpl, UnresolvedType,
+    UnresolvedTypeData,
 };
 use noirc_frontend::{
     graph::CrateId,
@@ -54,13 +55,13 @@ pub fn check_for_storage_definition(
 fn inject_context_in_storage_field(field: &mut UnresolvedType) -> Result<(), AztecMacroError> {
     match &mut field.typ {
         UnresolvedTypeData::Named(path, generics, _) => {
-            generics.push(make_type(UnresolvedTypeData::Named(
+            generics.ordered_args.push(make_type(UnresolvedTypeData::Named(
                 ident_path("Context"),
-                vec![],
+                GenericTypeArgs::default(),
                 false,
             )));
             match path.last_name() {
-                "Map" => inject_context_in_storage_field(&mut generics[1]),
+                "Map" => inject_context_in_storage_field(&mut generics.ordered_args[1]),
                 _ => Ok(()),
             }
         }
@@ -144,7 +145,10 @@ pub fn generate_storage_field_constructor(
                             generate_storage_field_constructor(
                                 // Map is expected to have three generic parameters: key, value and context (i.e.
                                 // Map<K, V, Context>. Here `get(1)` fetches the value type.
-                                &(type_ident.clone(), generics.get(1).unwrap().clone()),
+                                &(
+                                    type_ident.clone(),
+                                    generics.ordered_args.get(1).unwrap().clone(),
+                                ),
                                 variable("slot"),
                             )?,
                         ),
@@ -219,8 +223,11 @@ pub fn generate_storage_implementation(
 
     // This is the type over which the impl is generic.
     let generic_context_ident = ident("Context");
-    let generic_context_type =
-        make_type(UnresolvedTypeData::Named(ident_path("Context"), vec![], true));
+    let generic_context_type = make_type(UnresolvedTypeData::Named(
+        ident_path("Context"),
+        GenericTypeArgs::default(),
+        true,
+    ));
 
     let init = NoirFunction::normal(FunctionDefinition::normal(
         &ident("init"),
@@ -231,14 +238,13 @@ pub fn generate_storage_implementation(
         &return_type(chained_path!("Self")),
     ));
 
+    let ordered_args = vec![generic_context_type.clone()];
+    let generics = GenericTypeArgs { ordered_args, named_args: Vec::new() };
+
     let storage_impl = TypeImpl {
         object_type: UnresolvedType {
-            typ: UnresolvedTypeData::Named(
-                chained_path!(storage_struct_name),
-                vec![generic_context_type.clone()],
-                true,
-            ),
-            span: Some(Span::default()),
+            typ: UnresolvedTypeData::Named(chained_path!(storage_struct_name), generics, true),
+            span: Span::default(),
         },
         type_span: Span::default(),
         generics: vec![generic_context_ident.into()],

aztec_macros/src/utils/ast_utils.rs

@@ -108,17 +108,14 @@ pub fn assignment_with_type(
 }
 
 pub fn return_type(path: Path) -> FunctionReturnType {
-    let ty = make_type(UnresolvedTypeData::Named(path, vec![], true));
+    let ty = make_type(UnresolvedTypeData::Named(path, Default::default(), true));
     FunctionReturnType::Ty(ty)
 }
 
 pub fn lambda(parameters: Vec<(Pattern, UnresolvedType)>, body: Expression) -> Expression {
     expression(ExpressionKind::Lambda(Box::new(Lambda {
         parameters,
-        return_type: UnresolvedType {
-            typ: UnresolvedTypeData::Unspecified,
-            span: Some(Span::default()),
-        },
+        return_type: UnresolvedType { typ: UnresolvedTypeData::Unspecified, span: Span::default() },
         body,
     })))
 }
@@ -179,7 +176,7 @@ pub fn cast(lhs: Expression, ty: UnresolvedTypeData) -> Expression {
 }
 
 pub fn make_type(typ: UnresolvedTypeData) -> UnresolvedType {
-    UnresolvedType { typ, span: Some(Span::default()) }
+    UnresolvedType { typ, span: Span::default() }
 }
 
 pub fn index_array(array: Ident, index: &str) -> Expression {