refactor: cleaning up CallInterface related utils (#17854)

When I was looking at how to implement `self` approach in contracts I
was investigating current implementation of how `ContractInterface`
stubs are generated. This made me realize that a lot of utils there can
be removed and it can all be made much cleaner by using new Noir
features like `<type as Serialize>::N`.

When looking at the `create_stub_base` I figured that we can reuse the
serialization functionality of `derive_serialize` so I refactored the
relevant code out of `derive_serialize` into a separate function that
can be reused between the 1 functions.

I removed a lot of code so overall I think the outcome is nice.

Author: benesjan

noir-projects/aztec-nr/aztec/src/macros/dispatch.nr

@@ -1,5 +1,6 @@
-use super::utils::{compute_fn_selector, size_in_fields};
+use super::utils::compute_fn_selector;
 use poseidon::poseidon2::Poseidon2Hasher;
+use protocol_types::meta::utils::get_params_len_quote;
 use std::{collections::umap::UHashMap, hash::BuildHasherDefault, panic};
 
 /// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.
@@ -31,10 +32,7 @@ pub comptime fn generate_public_dispatch(m: Module) -> Quoted {
         }
         seen_selectors.insert(selector, fn_name);
 
-        let mut parameters_size = 0;
-        for param in parameters {
-            parameters_size += size_in_fields(param.1);
-        }
+        let params_len_quote = get_params_len_quote(parameters);
 
         let initial_read = if parameters.len() == 0 {
             quote {}
@@ -46,7 +44,7 @@ pub comptime fn generate_public_dispatch(m: Module) -> Quoted {
             // That is, exactly what is expected for a call to the target function,
             // but with a selector added at the beginning.
             quote {
-                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);
+                let input_calldata: [Field; $params_len_quote] = dep::aztec::context::public_context::calldata_copy(1, $params_len_quote);
                 let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);
             }
         };

noir-projects/aztec-nr/aztec/src/macros/functions/call_interface_stubs.nr

@@ -3,8 +3,9 @@
 // for invoking contract functions across different contexts (private, public, static, utility).
 
 use crate::macros::utils::{
-    add_to_field_array, AsStrQuote, compute_fn_selector, is_fn_private, is_fn_public, is_fn_view,
+    AsStrQuote, compute_fn_selector, is_fn_private, is_fn_public, is_fn_view,
 };
+use protocol_types::meta::utils::derive_serialization_quotes;
 use std::meta::unquote;
 
 comptime global FROM_FIELD: TypedExpr = {
@@ -17,8 +18,6 @@ comptime global FROM_FIELD: TypedExpr = {
         .as_typed_expr()
 };
 
-comptime global SERIALIZED_ARGS_NAME: Quoted = quote { serialized_args };
-
 pub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {
     let is_static_call = is_fn_view(f);
 
@@ -42,7 +41,7 @@ pub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {
 /// Utility function creating stubs used by all the stub functions in this file.
 comptime fn create_stub_base(
     f: FunctionDefinition,
-) -> (Quoted, Quoted, Quoted, Quoted, u32, Field) {
+) -> (Quoted, Quoted, Quoted, Quoted, Quoted, u32, Field) {
     // Dear privacy adventurer,
     // Chances are, you've command+clicked on the name of an external function
     // call -- seeking to view that function -- only to end up here.
@@ -63,51 +62,22 @@ comptime fn create_stub_base(
     let fn_parameters = f.parameters();
     let fn_parameters_list =
         fn_parameters.map(|(name, typ): (Quoted, Type)| quote { $name: $typ }).join(quote {,});
-    let params_num_fields =
-        fn_parameters.fold(0, |acc, (_, typ)| acc + crate::macros::utils::size_in_fields(typ));
-
-    let serialized_args_index_name = quote { serialized_args_index };
-    // Example of what the fold(...) below will generate for `target_address` and `fee_juice_limit_per_tx` function
-    // parameters:
-    // ```
-    // let mut serialized_args = [0;2];
-    // let mut serialized_args_index = 0;
-    // let target_address_serialized = aztec::protocol_types::traits::Serialize::serialize(target_address)
-    // for i in 0..target_address_serialized.len() {
-    //    serialized_args[serialized_args_index] = target_address_serialized[i];
-    //    serialized_args_index += 1;
-    // }
-    // serialized_args[serialized_args_index] = fee_juice_limit_per_tx as Field
-    // serialized_args_index += 1;
-    // ```
-    let serialized_args_array_construction = fn_parameters.fold(
-        quote {
-            let mut $SERIALIZED_ARGS_NAME = [0; $params_num_fields];
-            let mut $serialized_args_index_name: u32 = 0;
-        },
-        |args, param: (Quoted, Type)| {
-            let (name, typ) = param;
-            let arg_to_append =
-                add_to_field_array(SERIALIZED_ARGS_NAME, serialized_args_index_name, name, typ);
-            quote {
-                $args
-                $arg_to_append
-            }
-        },
-    );
+
+    let (serialized_args_array_construction, _, serialized_args_array_name) =
+        derive_serialization_quotes(fn_parameters, false);
 
     let (fn_name_str, _) = fn_name.as_str_quote();
     let fn_name_len: u32 = unquote!(quote { $fn_name_str.as_bytes().len()});
     let fn_selector: Field = compute_fn_selector(f);
 
     (
-        fn_name, fn_parameters_list, serialized_args_array_construction, fn_name_str, fn_name_len,
-        fn_selector,
+        fn_name, fn_parameters_list, serialized_args_array_construction, serialized_args_array_name,
+        fn_name_str, fn_name_len, fn_selector,
     )
 }
 
 comptime fn create_private_stub(f: FunctionDefinition) -> Quoted {
-    let (fn_name, fn_parameters_list, serialized_args_array_construction, fn_name_str, fn_name_len, fn_selector) =
+    let (fn_name, fn_parameters_list, serialized_args_array_construction, serialized_args_array_name, fn_name_str, fn_name_len, fn_selector) =
         create_stub_base(f);
     let fn_return_type = f.return_type();
 
@@ -119,15 +89,15 @@ comptime fn create_private_stub(f: FunctionDefinition) -> Quoted {
                 self.target_contract,
                 selector,
                 $fn_name_str,
-                $SERIALIZED_ARGS_NAME,
+                $serialized_args_array_name,
                 false
             )
         }
     }
 }
 
 comptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {
-    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =
+    let (fn_name, fn_parameters_list, serialized_args_slice_construction, serialized_args_array_name, fn_name_str, fn_name_len, fn_selector) =
         create_stub_base(f);
     let fn_return_type = f.return_type();
 
@@ -139,14 +109,14 @@ comptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {
                 self.target_contract,
                 selector,
                 $fn_name_str,
-                $SERIALIZED_ARGS_NAME,
+                $serialized_args_array_name,
             )
         }
     }
 }
 
 comptime fn create_public_stub(f: FunctionDefinition) -> Quoted {
-    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =
+    let (fn_name, fn_parameters_list, serialized_args_slice_construction, serialized_args_array_name, fn_name_str, fn_name_len, fn_selector) =
         create_stub_base(f);
     let fn_return_type = f.return_type();
 
@@ -158,15 +128,15 @@ comptime fn create_public_stub(f: FunctionDefinition) -> Quoted {
                 self.target_contract,
                 selector,
                 $fn_name_str,
-                $SERIALIZED_ARGS_NAME,
+                $serialized_args_array_name,
                 false
             )
         }
     }
 }
 
 comptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {
-    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =
+    let (fn_name, fn_parameters_list, serialized_args_slice_construction, serialized_args_array_name, fn_name_str, fn_name_len, fn_selector) =
         create_stub_base(f);
     let fn_return_type = f.return_type();
 
@@ -178,14 +148,14 @@ comptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {
                 self.target_contract,
                 selector,
                 $fn_name_str,
-                $SERIALIZED_ARGS_NAME,
+                $serialized_args_array_name,
             )
         }
     }
 }
 
 comptime fn create_utility_stub(f: FunctionDefinition) -> Quoted {
-    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =
+    let (fn_name, fn_parameters_list, serialized_args_slice_construction, serialized_args_array_name, fn_name_str, fn_name_len, fn_selector) =
         create_stub_base(f);
     let fn_return_type = f.return_type();
 
@@ -197,7 +167,7 @@ comptime fn create_utility_stub(f: FunctionDefinition) -> Quoted {
                 self.target_contract,
                 selector,
                 $fn_name_str,
-                $SERIALIZED_ARGS_NAME,
+                $serialized_args_array_name,
             )
         }
     }

noir-projects/aztec-nr/aztec/src/macros/utils.nr

@@ -72,63 +72,6 @@ pub(crate) comptime fn modify_fn_body(body: [Expr], prepend: Quoted, append: Quo
     body_expr.expect(f"Body is not an expression: {body_quote}")
 }
 
-/// Adds a value to a field array. Structs and values inside arrays are required to implement the Serialize trait.
-///
-/// The function takes the name of the array, the index in the array where the value should be added, the name of the
-/// variable to be added, and the type of the variable. It returns a quoted expression that can be used in a function body.
-///
-/// The returned quoted expression will increment the `index_name` variable by the number of fields added to the array,
-/// which is typically 1 for simple types, but can be more for complex types like structs or arrays.
-pub(crate) comptime fn add_to_field_array(
-    array_name: Quoted,
-    index_name: Quoted,
-    name: Quoted,
-    typ: Type,
-) -> Quoted {
-    let serialized_name = f"{name}_serialized".quoted_contents();
-
-    if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {
-        quote { 
-            $array_name[$index_name] = $name as Field;
-            $index_name += 1;
-        }
-    } else if typ.as_data_type().is_some() {
-        // We invoke serialize as a static trait function rather than calling $name.serialize() directly in the quote
-        // to avoid "trait not in scope" compiler warnings.
-        quote { 
-            let $serialized_name = aztec::protocol_types::traits::Serialize::serialize($name);
-            for i in 0..$serialized_name.len() {
-                $array_name[$index_name] = $serialized_name[i];
-                $index_name += 1;
-            }
-        }
-    } else if typ.as_array().is_some() {
-        // We invoke serialize as a static trait function rather than calling x.serialize() directly in the quote
-        // to avoid "trait not in scope" compiler warnings.
-        quote {
-            for i in 0..$name.len() {
-                let $serialized_name = aztec::protocol_types::traits::Serialize::serialize($name[i]);
-                for i in 0..$serialized_name.len() {
-                    $array_name[$index_name] = $serialized_name[i];
-                    $index_name += 1;
-                }
-            }
-        }
-    } else if typ.as_str().is_some() {
-        quote {
-            let $serialized_name = $name.as_bytes();
-            for i in 0..$serialized_name.len() {
-                $array_name[$index_name] = $serialized_name[i] as Field;
-                $index_name += 1;
-            }
-        }
-    } else {
-        panic(
-            f"Cannot add to slice: unsupported type {typ} variable {name}",
-        )
-    }
-}
-
 /// Adds a value to a hash::ArgsHasher. Structs and values inside arrays are required to implement the Serialize trait.
 pub(crate) comptime fn add_to_hasher(hasher_name: Quoted, name: Quoted, typ: Type) -> Quoted {
     if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {
@@ -336,79 +279,6 @@ pub(crate) comptime fn get_trait_impl_method(
         .as_typed_expr()
 }
 
-pub comptime fn size_in_fields(typ: Type) -> u32 {
-    array_size_in_fields(typ)
-        .or_else(|| bool_size_in_fields(typ))
-        .or_else(|| constant_size_in_fields(typ))
-        .or_else(|| field_size_in_fields(typ))
-        .or_else(|| int_size_in_fields(typ))
-        .or_else(|| str_size_in_fields(typ))
-        .or_else(|| struct_size_in_fields(typ))
-        .or_else(|| tuple_size_in_fields(typ))
-        .expect(f"Can't determine size in fields of {typ}")
-}
-
-comptime fn array_size_in_fields(typ: Type) -> Option<u32> {
-    typ.as_array().and_then(|typ: (Type, Type)| {
-        let (typ, element_size) = typ;
-        element_size.as_constant().map(|x: u32| x * size_in_fields(typ))
-    })
-}
-
-comptime fn bool_size_in_fields(typ: Type) -> Option<u32> {
-    if typ.is_bool() {
-        Option::some(1)
-    } else {
-        Option::none()
-    }
-}
-
-comptime fn field_size_in_fields(typ: Type) -> Option<u32> {
-    if typ.is_field() {
-        Option::some(1)
-    } else {
-        Option::none()
-    }
-}
-
-comptime fn int_size_in_fields(typ: Type) -> Option<u32> {
-    if typ.as_integer().is_some() {
-        Option::some(1)
-    } else {
-        Option::none()
-    }
-}
-
-comptime fn constant_size_in_fields(typ: Type) -> Option<u32> {
-    typ.as_constant()
-}
-
-comptime fn str_size_in_fields(typ: Type) -> Option<u32> {
-    typ.as_str().map(|typ| size_in_fields(typ))
-}
-
-comptime fn struct_size_in_fields(typ: Type) -> Option<u32> {
-    typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {
-        let struct_type = typ.0;
-        let generics = typ.1;
-        let mut size = 0;
-        for field in struct_type.fields(generics) {
-            size += size_in_fields(field.1);
-        }
-        size
-    })
-}
-
-comptime fn tuple_size_in_fields(typ: Type) -> Option<u32> {
-    typ.as_tuple().map(|types: [Type]| {
-        let mut size = 0;
-        for typ in types {
-            size += size_in_fields(typ);
-        }
-        size
-    })
-}
-
 /// Generates a quote that implements `Serialize` for a given struct `s`.
 /// If the struct already implements `Serialize`, we return an empty quote.
 pub comptime fn derive_serialize_if_not_implemented(s: TypeDefinition) -> Quoted {