chore(ssa refactor): Switch to immutable arrays

crates/nargo_cli/src/cli/prove_cmd.rs

@@ -44,7 +44,7 @@ pub(crate) struct ProveCommand {
     verifier_name: String,
 
     /// Verify proof after proving
-    #[arg(short, long)]
+    #[arg(long)]
     verify: bool,
 
     #[clap(flatten)]

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

@@ -554,10 +554,8 @@ impl AcirContext {
         let constants = match name {
             BlackBoxFunc::Pedersen => {
                 // The last argument of pedersen is the domain separator, which must be a constant
-                let domain_var = inputs
-                    .pop()
-                    .expect("ICE: Pedersen call requires domain separator")
-                    .into_var();
+                let domain_var =
+                    inputs.pop().expect("ICE: Pedersen call requires domain separator").into_var();
 
                 let domain_constant = self.vars[domain_var]
                     .as_constant()
@@ -579,9 +577,7 @@ impl AcirContext {
         //
         // We do not apply range information on the output of the black box function.
         // See issue #1439
-        Ok(vecmap(&outputs, |witness_index| {
-            self.add_data(AcirVarData::Witness(*witness_index))
-        }))
+        Ok(vecmap(&outputs, |witness_index| self.add_data(AcirVarData::Witness(*witness_index))))
     }
 
     /// Black box function calls expect their inputs to be in a specific data structure (FunctionInput).
@@ -635,11 +631,10 @@ impl AcirContext {
 
         let limbs = self.acir_ir.radix_le_decompose(input_expr, radix, limb_count)?;
 
-        let mut limb_vars =
-            vecmap(limbs, |witness| {
-                let witness = self.add_data(AcirVarData::Witness(witness));
-                AcirValue::Var(witness, result_element_type)
-            });
+        let mut limb_vars = vecmap(limbs, |witness| {
+            let witness = self.add_data(AcirVarData::Witness(witness));
+            AcirValue::Var(witness, result_element_type)
+        });
 
         if endian == Endian::Big {
             limb_vars.reverse();

crates/noirc_evaluator/src/ssa_refactor/acir_gen/mod.rs

@@ -485,17 +485,18 @@ impl Context {
         arguments: &[ValueId],
         dfg: &DataFlowGraph,
         allow_log_ops: bool,
-        result_ids: &[ValueId]
+        result_ids: &[ValueId],
     ) -> Vec<AcirValue> {
         match intrinsic {
             Intrinsic::BlackBox(black_box) => {
                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
 
-                let vars = self.acir_context
+                let vars = self
+                    .acir_context
                     .black_box_function(black_box, inputs)
                     .expect("add Result types to all methods so errors bubble up");
 
-                self.convert_vars_to_values(vars, dfg, result_ids)
+                Self::convert_vars_to_values(vars, dfg, result_ids)
             }
             Intrinsic::ToRadix(endian) => {
                 let field = self.convert_value(arguments[0], dfg).into_var();
@@ -550,8 +551,48 @@ impl Context {
         }
     }
 
-    fn convert_vars_to_values(&self, vars: Vec<AcirVar>, dfg: &DataFlowGraph, result_ids: &[ValueId]) -> Vec<AcirValue> {
+    /// Convert a Vec<AcirVar> into a Vec<AcirValue> using the given result ids.
+    /// If the type of a result id is an array, several acirvars are collected into
+    /// a single AcirValue::Array of the same length.
+    fn convert_vars_to_values(
+        vars: Vec<AcirVar>,
+        dfg: &DataFlowGraph,
+        result_ids: &[ValueId],
+    ) -> Vec<AcirValue> {
         let mut values = vec![];
+        let mut vars = vars.into_iter();
+
+        for result in result_ids {
+            Self::convert_var_type_to_values(
+                dfg,
+                &dfg.type_of_value(*result),
+                &mut values,
+                &mut vars,
+            );
+        }
+
+        values
+    }
+
+    fn convert_var_type_to_values(
+        dfg: &DataFlowGraph,
+        result_type: &Type,
+        values: &mut Vec<AcirValue>,
+        vars: &mut impl Iterator<Item = AcirVar>,
+    ) {
+        match result_type {
+            Type::Array(elements, size) => {
+                for _ in 0..*size {
+                    for element_type in elements.iter() {
+                        Self::convert_var_type_to_values(dfg, element_type, values, vars);
+                    }
+                }
+            }
+            typ => {
+                let var = vars.next().unwrap();
+                values.push(AcirValue::Var(var, typ.into()));
+            }
+        }
     }
 }
 

crates/noirc_evaluator/src/ssa_refactor/ir/types.rs

@@ -52,9 +52,9 @@ impl Type {
         Type::unsigned(1)
     }
 
-    /// Creates the char type, represented as just a field to avoid extra range constraints.
+    /// Creates the char type, represented as u8.
     pub(crate) fn char() -> Type {
-        Type::field()
+        Type::unsigned(8)
     }
 
     /// Creates the native field type.