fix(ACIR): correct brillig parameter slice length for dynamic arrays

compiler/noirc_evaluator/src/acir/call/mod.rs

@@ -188,8 +188,19 @@
                         .get(&value_id)
                         .expect("ICE: Unknown slice input to brillig")
                     {
-                        AcirValue::DynamicArray(AcirDynamicArray { len, .. }) => *len,
-                        AcirValue::Array(array) => array.len(),
+                        AcirValue::DynamicArray(AcirDynamicArray { len, .. }) => {
+                            // len holds the flattened length of all elements in the slice,
+                            // so to get the no-flattened length we need to divide by the flattened
+                            // length of a single slice entry
+                            let sum: u32 = item_types.iter().map(|typ| typ.flattened_size()).sum();
+                            if sum == 0 { 0 } else { *len / sum as usize }
+                        }
+                        AcirValue::Array(array) => {
+                            // len holds the non-flattened length of all elements in the slice,
+                            // so here we need to divide by the non-flattened length of a single
+                            // slice entry
+                            if item_types.len() == 0 { 0 } else { array.len() / item_types.len() }
+                        }
                         _ => unreachable!("ICE: Slice value is not an array"),
                     };
 
@@ -198,7 +209,7 @@
                             .iter()
                             .map(BrilligFunctionContext::ssa_type_to_parameter)
                             .collect(),
-                        len / item_types.len(),
+                        len,
                     )
                 } else {
                     BrilligFunctionContext::ssa_type_to_parameter(&typ)

compiler/noirc_evaluator/src/acir/types.rs

@@ -87,7 +87,7 @@ pub(super) struct AcirDynamicArray {
     /// Identification for the Acir dynamic array
     /// This is essentially a ACIR pointer to the array
     pub(super) block_id: BlockId,
-    /// Length of the array
+    /// Flattened length of the elements in the array
     pub(super) len: usize,
     /// An ACIR dynamic array is a flat structure, so we use
     /// the inner structure of an `AcirType::NumericType` directly.

compiler/noirc_evaluator/src/ssa/parser/mod.rs

@@ -928,8 +928,13 @@ impl<'a> Parser<'a> {
 
     fn parse_types(&mut self) -> ParseResult<Vec<Type>> {
         if self.eat(Token::LeftParen)? {
-            let types = self.parse_comma_separated_types()?;
-            self.eat_or_error(Token::RightParen)?;
+            let types = if self.eat(Token::RightParen)? {
+                Vec::new()
+            } else {
+                let types = self.parse_comma_separated_types()?;
+                self.eat_or_error(Token::RightParen)?;
+                types
+            };
             Ok(types)
         } else {
             Ok(vec![self.parse_type()?])

compiler/noirc_evaluator/src/ssa/parser/tests.rs

@@ -113,6 +113,18 @@ fn test_make_composite_slice() {
     assert_ssa_roundtrip(src);
 }
 
+#[test]
+fn test_make_empty_composite_array() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = make_array [] : [(); 1]
+            return v0
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
 #[test]
 fn test_make_byte_array_with_string_literal() {
     let src = "

compiler/noirc_evaluator/src/ssa/validation/mod.rs

@@ -220,7 +220,14 @@
                         composite_type
                     }
                     Type::Slice(composite_type) => {
-                        if elements.len() % composite_type.len() != 0 {
+                        if composite_type.is_empty() {
+                            if !elements.is_empty() {
+                                panic!(
+                                    "MakeArray slice has non-zero {} elements but composite type is empty",
+                                    elements.len(),
+                                );
+                            }
+                        } else if elements.len() % composite_type.len() != 0 {
                             panic!(
                                 "MakeArray slice has {} elements but composite type has {} types which don't divide the number of elements",
                                 elements.len(),
@@ -673,19 +680,19 @@
                 //     message_hash: [u8; N],
                 //     predicate: bool,
                 // ) -> bool
                 assert_arguments_length(arguments, 5, "ecdsa_secp_256");
 
                 let public_key_x = arguments[0];
                 let public_key_x_type = dfg.type_of_value(public_key_x);
                 let public_key_x_length =
                     assert_u8_array(&public_key_x_type, "ecdsa_secp256 public_key_x");
                 assert_array_length(public_key_x_length, 32, "ecdsa_secp256 public_key_x");
 
                 let public_key_y = arguments[1];
                 let public_key_y_type = dfg.type_of_value(public_key_y);
                 let public_key_y_length =
                     assert_u8_array(&public_key_y_type, "ecdsa_secp256 public_key_y");
                 assert_array_length(public_key_y_length, 32, "ecdsa_secp256 public_key_y");
 
                 let signature = arguments[2];
                 let signature_type = dfg.type_of_value(signature);
@@ -1543,6 +1550,18 @@
         let _ = Ssa::from_str(src).unwrap();
     }
 
+    #[test]
+    fn make_array_slice_empty_composite_type() {
+        let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = make_array [] : [()]
+            return v0
+        }
+        ";
+        let _ = Ssa::from_str(src).unwrap();
+    }
+
     #[test]
     #[should_panic(
         expected = "MakeArray has incorrect element type at index 1: expected u8, got Field"

test_programs/execution_success/regression_10197/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_10197"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/regression_10197/Prover.toml

@@ -0,0 +1 @@
+index = 1

test_programs/execution_success/regression_10197/src/main.nr

@@ -0,0 +1,5 @@
+fn main(index: u32) {
+    let mut slice = &[(0, [1, 2]), (3, [4, 5])];
+    slice[index] = (6, [7, 8]);
+    println(slice);
+}

test_programs/execution_success/regression_10198/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_10198"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/regression_10198/Prover.toml

@@ -0,0 +1 @@
+index = 1

test_programs/execution_success/regression_10198/src/main.nr

@@ -0,0 +1,8 @@
+fn main(index: u32) {
+    let slice: [()] = &[(), (), ()];
+    println(slice);
+
+    let mut slice: [()] = &[(), (), ()];
+    slice[index] = ();
+    println(slice);
+}