feat: dynamic arrays for experimental-ssa

Cargo.toml

@@ -24,7 +24,7 @@ edition = "2021"
 rust-version = "1.66"
 
 [workspace.dependencies]
-acvm = "0.19.1"
+acvm = "0.20.0"
 arena = { path = "crates/arena" }
 fm = { path = "crates/fm" }
 iter-extended = { path = "crates/iter-extended" }

crates/nargo_cli/Cargo.toml

@@ -48,7 +48,7 @@ color-eyre = "0.6.2"
 tokio = { version = "1.0", features = ["io-std"] }
 
 # Backends
-acvm-backend-barretenberg = { version = "0.9.0", default-features = false }
+acvm-backend-barretenberg = { version = "0.9.1", default-features = false }
 
 [dev-dependencies]
 tempdir = "0.3.7"
@@ -62,3 +62,4 @@ default = ["plonk_bn254"]
 plonk_bn254 = ["acvm-backend-barretenberg/native"]
 plonk_bn254_wasm = ["acvm-backend-barretenberg/wasm"]
 flat_witness = ["acvm-backend-barretenberg/native"]
+

crates/nargo_cli/tests/test_data_ssa_refactor/array_dynamic/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/array_dynamic/Prover.toml

@@ -0,0 +1,9 @@
+x = [104, 101, 108, 108, 111]
+z = "59"
+t = "10"
+index = [0,1,2,3,4]
+index2 =  [0,1,2,3,4]
+offset = 1
+sublen = 2
+
+

crates/nargo_cli/tests/test_data_ssa_refactor/array_dynamic/src/main.nr

@@ -0,0 +1,32 @@
+
+fn main(x: [u32; 5], mut z: u32, t: u32, index: [Field;5], index2: [Field;5], offset: Field, sublen: Field) {
+    let idx = (z - 5*t - 5) as Field;
+    //dynamic array test
+    dyn_array(x, idx, idx - 3); 
+
+    //regression for issue 1283
+    let mut s = 0;
+    let x3 = [246,159,32,176,8];
+    for i in 0..5 {
+      s += x3[index[i]];
+    }
+    assert(s!=0);
+
+    if 3 < (sublen as u32) {
+      assert(index[offset + 3] == index2[3]);
+    }
+}
+
+fn dyn_array(mut x: [u32; 5], y: Field, z: Field) {
+    assert(x[y] == 111);
+    assert(x[z] == 101);
+    x[z] = 0;
+   assert(x[y] == 111);
+    assert(x[1] == 0);
+    if y as u32 < 10 {
+      x[y] = x[y] - 2;
+    } else {
+      x[y] = 0;
+    }
+    assert(x[4] == 109);
+}

crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/acir_variable.rs

@@ -1,8 +1,10 @@
 use super::{errors::AcirGenError, generated_acir::GeneratedAcir};
 use crate::brillig::brillig_gen::brillig_directive;
-use crate::ssa_refactor::acir_gen::AcirValue;
+use crate::ssa_refactor::acir_gen::{AcirArray, AcirValue};
 use crate::ssa_refactor::ir::types::Type as SsaType;
 use crate::ssa_refactor::ir::{instruction::Endian, types::NumericType};
+use acvm::acir::circuit::opcodes::{BlockId, MemOp};
+use acvm::acir::circuit::Opcode;
 use acvm::acir::{
     brillig::Opcode as BrilligOpcode,
     circuit::brillig::{BrilligInputs, BrilligOutputs},
@@ -210,7 +212,9 @@ impl AcirContext {
         assert_eq!(results.len(), 1);
         match results[0] {
             AcirValue::Var(var, _) => var,
-            AcirValue::Array(_) => unreachable!("ICE - expected a variable"),
+            AcirValue::DynamicArray(_) | AcirValue::Array(_) => {
+                unreachable!("ICE - expected a variable")
+            }
         }
     }
 
@@ -789,6 +793,7 @@ impl AcirContext {
                     Self::flatten_value(acir_vars, value);
                 }
             }
+            AcirValue::DynamicArray(_) => unreachable!("Cannot flatten a dynamic array"),
         }
     }
 
@@ -826,6 +831,11 @@ impl AcirContext {
                 }
                 BrilligInputs::Array(var_expressions)
             }
+            AcirValue::DynamicArray(_) => {
+                let mut var_expressions = Vec::new();
+                self.brillig_array_input(&mut var_expressions, i);
+                BrilligInputs::Array(var_expressions)
+            }
         });
 
         let mut b_outputs = Vec::new();
@@ -857,7 +867,7 @@ impl AcirContext {
         outputs_var
     }
 
-    fn brillig_array_input(&self, var_expressions: &mut Vec<Expression>, input: AcirValue) {
+    fn brillig_array_input(&mut self, var_expressions: &mut Vec<Expression>, input: AcirValue) {
         match input {
             AcirValue::Var(var, _) => {
                 var_expressions.push(self.vars[&var].to_expression().into_owned());
@@ -867,6 +877,24 @@ impl AcirContext {
                     self.brillig_array_input(var_expressions, var);
                 }
             }
+            AcirValue::DynamicArray(AcirArray { block_id, len }) => {
+                for i in 0..len {
+                    // We generate witnesses corresponding to the array values
+                    let index = AcirValue::Var(
+                        self.add_constant(FieldElement::from(i as u128)),
+                        AcirType::NumericType(NumericType::NativeField),
+                    );
+                    let index_var = index.into_var();
+
+                    let value_read_var = self.read_from_memory(block_id, &index_var);
+                    let value_read = AcirValue::Var(
+                        value_read_var,
+                        AcirType::NumericType(NumericType::NativeField),
+                    );
+
+                    self.brillig_array_input(var_expressions, value_read);
+                }
+            }
         }
     }
 
@@ -913,6 +941,93 @@ impl AcirContext {
         let lhs_less_than_rhs = self.more_than_eq_var(rhs, lhs, bit_size, predicate)?;
         self.maybe_eq_predicate(lhs_less_than_rhs, predicate)
     }
+
+    /// Returns a Variable that is constrained to be the result of reading
+    /// from the memory `block_id` at the given `index`.
+    pub(crate) fn read_from_memory(&mut self, block_id: BlockId, index: &AcirVar) -> AcirVar {
+        // Fetch the witness corresponding to the index
+        //
+        // TODO: We can have a helper method which converts AcirVar to Witness
+        let index_var_data = self.vars.get(index).expect("ICE: undeclared AcirVar");
+        let index_witness = self.acir_ir.get_or_create_witness(&index_var_data.to_expression());
+
+        // Create a Variable to hold the result of the read and extract the corresponding Witness
+        let value_read_var = self.add_variable();
+        let value_read_var_data = self.vars.get(&value_read_var).expect("ICE: undeclared AcirVar");
+        let value_read_witness = value_read_var_data.to_expression().into_owned();
+
+        // Add the memory read operation to the list of opcodes
+        let read_op = Expression::zero();
+        let op =
+            MemOp { operation: read_op, index: index_witness.into(), value: value_read_witness };
+        self.acir_ir.opcodes.push(Opcode::MemoryOp { block_id, op });
+
+        value_read_var
+    }
+
+    /// Constrains the Variable `value` to be the new value located at `index` in the memory `block_id`.
+    pub(crate) fn write_to_memory(&mut self, block_id: BlockId, index: &AcirVar, value: &AcirVar) {
+        // Fetch the witness corresponding to the index
+        //
+        // See read_memory for TODO on creating a helper
+        let index_var_data = self.vars.get(index).expect("ICE: undeclared AcirVar");
+        let index_witness = self.acir_ir.get_or_create_witness(&index_var_data.to_expression());
+
+        // Fetch the witness corresponding to the value to be written
+        let value_write_var_data = self.vars.get(value).expect("ICE: undeclared AcirVar");
+        let value_write_witness =
+            self.acir_ir.get_or_create_witness(&value_write_var_data.to_expression());
+
+        // Add the memory write operation to the list of opcodes
+        let write_op = Expression::one();
+        let op = MemOp {
+            operation: write_op,
+            index: index_witness.into(),
+            value: value_write_witness.into(),
+        };
+        self.acir_ir.opcodes.push(Opcode::MemoryOp { block_id, op });
+    }
+
+    /// Initializes an array in memory with the given values `optional_values`.
+    /// If `optional_values` is empty, then the array is initialized with zeros.
+    ///
+    /// TODO: Can we make `optional_values` Option<&[AcirValue]> ?
+    pub(crate) fn initialize_array(
+        &mut self,
+        block_id: BlockId,
+        len: usize,
+        optional_values: &[AcirValue],
+    ) {
+        // We can either supply all of the optional values or none of them
+        assert!(
+            optional_values.is_empty() || optional_values.len() == len,
+            "invalid optional values"
+        );
+
+        // If the optional values are supplied, then we fill the initialized
+        // array with those values. If not, then we fill it with zeros.
+        let initialized_values = match optional_values.is_empty() {
+            true => {
+                // TODO: See comment in read_memory, regarding a method to convert Var to Witness
+                let zero = self.add_constant(FieldElement::zero());
+                let zero_expr = self.vars[&zero].to_expression();
+                let zero_witness = self.acir_ir.get_or_create_witness(&zero_expr);
+                vec![zero_witness; len]
+            }
+            // TODO: See comment in read_memory, regarding a method to convert Var to Witness
+            false => vecmap(optional_values, |value| {
+                let expr = self
+                    .vars
+                    .get(&value.clone().into_var())
+                    .expect("invalid value")
+                    .to_expression()
+                    .into_owned();
+                self.acir_ir.get_or_create_witness(&expr)
+            }),
+        };
+
+        self.acir_ir.opcodes.push(Opcode::MemoryInit { block_id, init: initialized_values });
+    }
 }
 
 /// Enum representing the possible values that a