feat: Sync from noir (AztecProtocol/aztec-packages#5416)

Automated pull of development from the
[noir](https://github.com/noir-lang/noir) programming language, a
dependency of Aztec.
BEGIN_COMMIT_OVERRIDE
chore(github): Improve PR template "document later" checkbox description
(#4625)
chore: Update integers.md to note support for Fields using
`from_integer` (#4536)
chore: update docs with function names to match version 0.25.0
specifications (#4466)
feat: add specific error for attempting `string[x] = ".."`
(#4611)
fix(ssa): Use accurate type during SSA AsSlice simplficiation
(#4610)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>

.aztec-sync-commit

@@ -1 +1 @@
-208abbb63af4c9a3f25d723fe1c49e82aa461061
+13a12d5255e788be94d575c726da141e652f14e3

.github/pull_request_template.md

@@ -17,7 +17,7 @@ Resolves <!-- Link to GitHub Issue -->
 Check one:
 - [ ] No documentation needed.
 - [ ] Documentation included in this PR.
-- [ ] **[Exceptional Case]** Documentation to be submitted in a separate PR.
+- [ ] **[For Experimental Features]** Documentation to be submitted in a separate PR.
 
 # PR Checklist\*
 

aztec_macros/src/transforms/functions.rs

@@ -232,62 +232,62 @@ fn create_assert_initializer() -> Statement {
 /// ```noir
 /// #[aztec(private)]
 /// fn foo(structInput: SomeStruct, arrayInput: [u8; 10], fieldInput: Field) -> Field {
-///     // Create the hasher object
-///     let mut hasher = Hasher::new();
+///     // Create the bounded vec object
+///     let mut serialized_args = BoundedVec::new();
 ///
 ///     // struct inputs call serialize on them to add an array of fields
-///     hasher.add_multiple(structInput.serialize());
+///     serialized_args.extend_from_array(structInput.serialize());
 ///
-///     // Array inputs are iterated over and each element is added to the hasher (as a field)
+///     // Array inputs are iterated over and each element is added to the bounded vec (as a field)
 ///     for i in 0..arrayInput.len() {
-///         hasher.add(arrayInput[i] as Field);
+///         serialized_args.push(arrayInput[i] as Field);
 ///     }
-///     // Field inputs are added to the hasher
-///     hasher.add({ident});
+///     // Field inputs are added to the bounded vec
+///     serialized_args.push({ident});
 ///
 ///     // Create the context
 ///     // The inputs (injected by this `create_inputs`) and completed hash object are passed to the context
-///     let mut context = PrivateContext::new(inputs, hasher.hash());
+///     let mut context = PrivateContext::new(inputs, hash_args(serialized_args));
 /// }
 /// ```
 fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
     let mut injected_expressions: Vec<Statement> = vec![];
 
-    // `let mut hasher = Hasher::new();`
-    let let_hasher = mutable_assignment(
-        "hasher", // Assigned to
+    // `let mut serialized_args = BoundedVec::new();`
+    let let_serialized_args = mutable_assignment(
+        "serialized_args", // Assigned to
         call(
-            variable_path(chained_dep!("aztec", "hasher", "Hasher", "new")), // Path
-            vec![],                                                          // args
+            variable_path(chained_dep!("std", "collections", "bounded_vec", "BoundedVec", "new")), // Path
+            vec![], // args
         ),
     );
 
-    // Completes: `let mut hasher = Hasher::new();`
-    injected_expressions.push(let_hasher);
+    // Completes: `let mut serialized_args = BoundedVec::new();`
+    injected_expressions.push(let_serialized_args);
 
-    // Iterate over each of the function parameters, adding to them to the hasher
+    // Iterate over each of the function parameters, adding to them to the bounded vec
     for Param { pattern, typ, span, .. } in params {
         match pattern {
             Pattern::Identifier(identifier) => {
                 // Match the type to determine the padding to do
                 let unresolved_type = &typ.typ;
                 let expression = match unresolved_type {
-                    // `hasher.add_multiple({ident}.serialize())`
-                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier),
+                    // `serialized_args.extend_from_array({ident}.serialize())`
+                    UnresolvedTypeData::Named(..) => add_struct_to_serialized_args(identifier),
                     UnresolvedTypeData::Array(_, arr_type) => {
-                        add_array_to_hasher(identifier, arr_type)
+                        add_array_to_serialized_args(identifier, arr_type)
                     }
-                    // `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)`
+                    // `serialized_args.push({ident})`
+                    UnresolvedTypeData::FieldElement => add_field_to_serialized_args(identifier),
+                    // Add the integer to the serialized args, casted to a field
+                    // `serialized_args.push({ident} as Field)`
                     UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
-                        add_cast_to_hasher(identifier)
+                        add_cast_to_serialized_args(identifier)
                     }
                     UnresolvedTypeData::String(..) => {
                         let (var_bytes, id) = str_to_bytes(identifier);
                         injected_expressions.push(var_bytes);
-                        add_array_to_hasher(
+                        add_array_to_serialized_args(
                             &id,
                             &UnresolvedType {
                                 typ: UnresolvedTypeData::Integer(
@@ -313,11 +313,10 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
 
     // Create the inputs to the context
     let inputs_expression = variable("inputs");
-    // `hasher.hash()`
-    let hash_call = method_call(
-        variable("hasher"), // variable
-        "hash",             // method name
-        vec![],             // args
+    // `hash_args(serialized_args)`
+    let hash_call = call(
+        variable_path(chained_dep!("aztec", "hash", "hash_args")), // variable
+        vec![variable("serialized_args")],                         // args
     );
 
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
@@ -598,21 +597,21 @@ fn create_context_finish() -> Statement {
 }
 
 //
-//                 Methods to create hasher inputs
+//                 Methods to create hash_args inputs
 //
 
-fn add_struct_to_hasher(identifier: &Ident) -> Statement {
-    // If this is a struct, we call serialize and add the array to the hasher
+fn add_struct_to_serialized_args(identifier: &Ident) -> Statement {
+    // If this is a struct, we call serialize and add the array to the serialized args
     let serialized_call = method_call(
         variable_path(path(identifier.clone())), // variable
         "serialize",                             // method name
         vec![],                                  // args
     );
 
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),    // variable
-        "add_multiple",        // method name
-        vec![serialized_call], // args
+        variable("serialized_args"), // variable
+        "extend_from_array",         // method name
+        vec![serialized_call],       // args
     )))
 }
 
@@ -632,7 +631,7 @@ fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
 }
 
 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
+    // If this is an array of primitive types (integers / fields) we can add them each to the serialized args
     // casted to a field
     let span = var.span;
 
@@ -644,7 +643,7 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     );
 
     // What will be looped over
-    // - `hasher.add({ident}[i] as Field)`
+    // - `serialized_args.push({ident}[i] as Field)`
     let for_loop_block = expression(ExpressionKind::Block(BlockExpression(loop_body)));
 
     // `for i in 0..{ident}.len()`
@@ -662,66 +661,66 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     }))
 }
 
-fn add_array_to_hasher(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
+fn add_array_to_serialized_args(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
+    // If this is an array of primitive types (integers / fields) we can add them each to the serialized_args
     // casted to a field
 
     // Wrap in the semi thing - does that mean ended with semi colon?
-    // `hasher.add({ident}[i] as Field)`
+    // `serialized_args.push({ident}[i] as Field)`
 
     let arr_index = index_array(identifier.clone(), "i");
-    let (add_expression, hasher_method_name) = match arr_type.typ {
+    let (add_expression, vec_method_name) = match arr_type.typ {
         UnresolvedTypeData::Named(..) => {
-            let hasher_method_name = "add_multiple".to_owned();
+            let vec_method_name = "extend_from_array".to_owned();
             let call = method_call(
                 // All serialize on each element
                 arr_index,   // variable
                 "serialize", // method name
                 vec![],      // args
             );
-            (call, hasher_method_name)
+            (call, vec_method_name)
         }
         _ => {
-            let hasher_method_name = "add".to_owned();
+            let vec_method_name = "push".to_owned();
             let call = cast(
                 arr_index,                        // lhs - `ident[i]`
                 UnresolvedTypeData::FieldElement, // cast to - `as Field`
             );
-            (call, hasher_method_name)
+            (call, vec_method_name)
         }
     };
 
     let block_statement = make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),  // variable
-        &hasher_method_name, // method name
+        variable("serialized_args"), // variable
+        &vec_method_name,            // method name
         vec![add_expression],
     )));
 
     create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
 }
 
-fn add_field_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident})`
+fn add_field_to_serialized_args(identifier: &Ident) -> Statement {
+    // `serialized_args.push({ident})`
     let ident = variable_path(path(identifier.clone()));
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"), // variable
-        "add",              // method name
-        vec![ident],        // args
+        variable("serialized_args"), // variable
+        "push",                      // method name
+        vec![ident],                 // args
     )))
 }
 
-fn add_cast_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident} as Field)`
+fn add_cast_to_serialized_args(identifier: &Ident) -> Statement {
+    // `serialized_args.push({ident} as Field)`
     // `{ident} as Field`
     let cast_operation = cast(
         variable_path(path(identifier.clone())), // lhs
         UnresolvedTypeData::FieldElement,        // rhs
     );
 
-    // `hasher.add({ident} as Field)`
+    // `serialized_args.push({ident} as Field)`
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),   // variable
-        "add",                // method name
-        vec![cast_operation], // args
+        variable("serialized_args"), // variable
+        "push",                      // method name
+        vec![cast_operation],        // args
     )))
 }

compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs

@@ -85,10 +85,11 @@ pub(super) fn simplify_call(
             }
         }
         Intrinsic::AsSlice => {
-            let slice = dfg.get_array_constant(arguments[0]);
-            if let Some((slice, element_type)) = slice {
-                let slice_length = dfg.make_constant(slice.len().into(), Type::length_type());
-                let new_slice = dfg.make_array(slice, element_type);
+            let array = dfg.get_array_constant(arguments[0]);
+            if let Some((array, array_type)) = array {
+                let slice_length = dfg.make_constant(array.len().into(), Type::length_type());
+                let inner_element_types = array_type.element_types();
+                let new_slice = dfg.make_array(array, Type::Slice(inner_element_types));
                 SimplifyResult::SimplifiedToMultiple(vec![slice_length, new_slice])
             } else {
                 SimplifyResult::None

compiler/noirc_evaluator/src/ssa/ir/types.rs

@@ -159,6 +159,13 @@ impl Type {
             Type::Reference(element) => element.contains_an_array(),
         }
     }
+
+    pub(crate) fn element_types(self) -> Rc<Vec<Type>> {
+        match self {
+            Type::Array(element_types, _) | Type::Slice(element_types) => element_types,
+            other => panic!("element_types: Expected array or slice, found {other}"),
+        }
+    }
 }
 
 /// Composite Types are essentially flattened struct or tuple types.

compiler/noirc_frontend/src/hir/type_check/errors.rs

@@ -140,6 +140,8 @@ pub enum TypeCheckError {
         method_name: String,
         span: Span,
     },
+    #[error("Strings do not support indexed assignment")]
+    StringIndexAssign { span: Span },
 }
 
 impl TypeCheckError {
@@ -237,7 +239,8 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
-            | TypeCheckError::NonConstantSliceLength { span } => {
+            | TypeCheckError::NonConstantSliceLength { span }
+            | TypeCheckError::StringIndexAssign { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(

compiler/noirc_frontend/src/hir/type_check/stmt.rs

@@ -258,6 +258,11 @@ impl<'interner> TypeChecker<'interner> {
                     Type::Array(_, elem_type) => *elem_type,
                     Type::Slice(elem_type) => *elem_type,
                     Type::Error => Type::Error,
+                    Type::String(_) => {
+                        let (_lvalue_name, lvalue_span) = self.get_lvalue_name_and_span(&lvalue);
+                        self.errors.push(TypeCheckError::StringIndexAssign { span: lvalue_span });
+                        Type::Error
+                    }
                     other => {
                         // TODO: Need a better span here
                         self.errors.push(TypeCheckError::TypeMismatch {

docs/docs/how_to/how-to-oracles.md

@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.

docs/docs/noir/concepts/data_types/integers.md

@@ -51,7 +51,7 @@ The built-in structure `U128` allows you to use 128-bit unsigned integers almost
 - You cannot cast between a native integer and `U128`
 - There is a higher performance cost when using `U128`, compared to a native type.
 
-Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions.
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
 
 ```rust
 fn main() {

docs/docs/tutorials/noirjs_app.md

@@ -243,7 +243,7 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateFinalProof(input);
+const proof = await noir.generateProof(input);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
@@ -264,7 +264,7 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyFinalProof(proof);
+const verification = await noir.verifyProof(proof);
 if (verification) display('logs', 'Verifying proof... ✅');
 ```
 

docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md

@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.

docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md

@@ -243,7 +243,7 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateFinalProof(input);
+const proof = await noir.generateProof(input);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
@@ -264,7 +264,7 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyFinalProof(proof);
+const verification = await noir.verifyProof(proof);
 if (verification) display('logs', 'Verifying proof... ✅');
 ```
 

docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md

@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.