chore: resolve immutable array merge differences

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/Cargo.toml

@@ -16,6 +16,7 @@ iter-extended.workspace = true
 thiserror.workspace = true
 num-bigint = "0.4"
 num-traits = "0.2.8"
+im = "15.1"
 
 [dev-dependencies]
 rand="0.8.5"

crates/noirc_evaluator/src/brillig/binary.rs

@@ -96,7 +96,7 @@ pub(crate) fn type_of_binary_operation(lhs_type: Type, rhs_type: Type) -> Type {
             );
             Type::Numeric(lhs_type)
         }
-        _ => {
+        (lhs_type, rhs_type) => {
             unreachable!(
                 "ICE: Binary operation between types {:?} and {:?} is not allowed",
                 lhs_type, rhs_type

crates/noirc_evaluator/src/brillig/brillig_gen.rs

@@ -160,10 +160,10 @@ impl BrilligGen {
                 let result_register = self.get_or_create_register(result_ids[0]);
                 self.convert_ssa_binary(binary, dfg, result_register);
             }
-            Instruction::Allocate { size } => {
+            Instruction::Allocate => {
                 let pointer_register =
                     self.get_or_create_register(dfg.instruction_results(instruction_id)[0]);
-                self.allocate_array(pointer_register, *size);
+                self.allocate_array(pointer_register, 1);
             }
             Instruction::Store { address, value } => {
                 let address_register = self.convert_ssa_value(*address, dfg);

crates/noirc_evaluator/src/ssa_refactor.rs

@@ -29,7 +29,6 @@ pub mod ssa_gen;
 /// form and performing optimizations there. When finished,
 /// convert the final SSA into ACIR and return it.
 pub(crate) fn optimize_into_acir(program: Program, allow_log_ops: bool) -> GeneratedAcir {
-    let func_signature = program.main_function_signature.clone();
     let ssa = ssa_gen::generate_ssa(program).print("Initial SSA:");
     let brillig = ssa.to_brillig();
     ssa.inline_functions()
@@ -44,7 +43,7 @@ pub(crate) fn optimize_into_acir(program: Program, allow_log_ops: bool) -> Gener
         .print("After Mem2Reg:")
         .fold_constants()
         .print("After Constant Folding:")
-        .into_acir(func_signature, brillig, allow_log_ops)
+        .into_acir(brillig, allow_log_ops)
 }
 
 /// Compiles the Program into ACIR and applies optimizations to the arithmetic gates

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

@@ -2,92 +2,7 @@ use std::collections::BTreeMap;
 
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
-use noirc_abi::{Abi, AbiParameter, AbiType, FunctionSignature};
-
-/// Traverses the parameters to the program to infer the lengths of any arrays that occur.
-///
-/// This is needed for the acir_gen pass, because while the SSA representation of the program
-/// knows the positions at which any arrays occur in the parameters to main, it does not know the
-/// lengths of said arrays.
-///
-/// This function returns the lengths ordered such as to correspond to the ordering used by the
-/// SSA representation. This allows the lengths to be consumed as array params are encountered in
-/// the SSA.
-pub(crate) fn collate_array_info(abi_params: &[AbiParameter]) -> Vec<(usize, AbiType)> {
-    let mut acc = Vec::new();
-    for abi_param in abi_params {
-        collate_array_info_recursive(&mut acc, &abi_param.typ);
-    }
-    acc
-}
-
-/// The underlying recursive implementation of `collate_array_info`
-///
-/// This does a depth-first traversal of the abi until an array (or string) is encountered, at
-/// which point arrays are handled differently depending on the element type:
-/// - arrays of fields, integers or booleans produce an array of the specified length
-/// - arrays of structs produce an array of the specified length for each field of the flatten
-///   struct (which reflects a simplification made during monomorphization)
-fn collate_array_info_recursive(acc: &mut Vec<(usize, AbiType)>, abi_type: &AbiType) {
-    match abi_type {
-        AbiType::Array { length, typ: elem_type } => {
-            let elem_type = elem_type.as_ref();
-            match elem_type {
-                AbiType::Array { .. } => {
-                    unreachable!("2D arrays are not supported");
-                }
-                AbiType::Struct { .. } => {
-                    // monomorphization converts arrays of structs into an array per flattened
-                    // struct field.
-                    let mut destructured_array_types = Vec::new();
-                    flatten_abi_type_recursive(&mut destructured_array_types, elem_type);
-                    for abi_type in destructured_array_types {
-                        acc.push((*length as usize, abi_type));
-                    }
-                }
-                AbiType::String { .. } => {
-                    unreachable!("Arrays of strings are not supported");
-                }
-                AbiType::Boolean | AbiType::Field | AbiType::Integer { .. } => {
-                    // Simple 1D array
-                    acc.push((*length as usize, elem_type.clone()));
-                }
-            }
-        }
-        AbiType::Struct { fields } => {
-            for (_, field_type) in fields {
-                collate_array_info_recursive(acc, field_type);
-            }
-        }
-        AbiType::String { length } => {
-            // Strings are implemented as u8 arrays
-            let element_type = AbiType::Integer { sign: noirc_abi::Sign::Unsigned, width: 8 };
-            acc.push((*length as usize, element_type));
-        }
-        AbiType::Boolean | AbiType::Field | AbiType::Integer { .. } => {
-            // Do not produce arrays
-        }
-    }
-}
-
-/// Used for flattening a struct into its ordered constituent field types. This is needed for
-/// informing knowing the bit widths of any array sets that were destructured from an array of
-/// structs. For this reason, any array encountered within this function are considered to be
-/// nested within a struct and are therefore disallowed. This is acceptable because this function
-/// will only be applied to structs which have been found in an array.
-fn flatten_abi_type_recursive(acc: &mut Vec<AbiType>, abi_type: &AbiType) {
-    match abi_type {
-        AbiType::Array { .. } | AbiType::String { .. } => {
-            unreachable!("2D arrays are unsupported")
-        }
-        AbiType::Boolean | AbiType::Integer { .. } | AbiType::Field => acc.push(abi_type.clone()),
-        AbiType::Struct { fields } => {
-            for (_, field_type) in fields {
-                flatten_abi_type_recursive(acc, field_type);
-            }
-        }
-    }
-}
+use noirc_abi::{Abi, AbiParameter, FunctionSignature};
 
 /// Arranges a function signature and a generated circuit's return witnesses into a
 /// `noirc_abi::Abi`.

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

@@ -1,4 +1,3 @@
 pub(crate) mod acir_variable;
 pub(crate) mod errors;
 pub(crate) mod generated_acir;
-pub(crate) mod memory;