feat(ssa_refactor)!: Add Slices

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

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

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

@@ -0,0 +1,2 @@
+x = "5"
+y = "10"

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

@@ -0,0 +1,21 @@
+use dep::std::slice;
+
+fn main(x : Field, y : pub Field) {
+
+    let mut slice: [Field] = [0; 2];
+
+    assert(slice[0] == 0);
+    assert(slice[0] != 1);
+
+    let slice_plus_10 = slice.push_back(10);
+    assert(slice_plus_10[2] == 10);
+    assert(slice_plus_10[2] != 8);
+    assert(slice_plus_10.len() == 3);
+
+    let mut new_slice: [Field] = [];
+    for i in 0..5 {
+        new_slice = new_slice.push_back(0);
+    }
+    assert(new_slice.len() == 5);
+}
+

crates/noirc_evaluator/src/ssa/context.rs

@@ -1211,6 +1211,7 @@ impl SsaContext {
             Type::Function(..) => ObjectType::Function,
             Type::Tuple(_) => todo!("Conversion to ObjectType is unimplemented for tuples"),
             Type::String(_) => todo!("Conversion to ObjectType is unimplemented for strings"),
+            Type::Slice(_) => todo!("Conversion to ObjectType is unimplemented for slices"),
             Type::Vec(_) => todo!("Conversion to ObjectType is unimplemented for Vecs"),
         }
     }

crates/noirc_evaluator/src/ssa/value.rs

@@ -96,6 +96,7 @@ impl Value {
             Type::Unit
             | Type::Function(..)
             | Type::Array(..)
+            | Type::Slice(..)
             | Type::Vec(..)
             | Type::String(..)
             | Type::Integer(..)

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

@@ -343,6 +343,11 @@ impl Context {
                 let elements = array.iter().map(|element| self.convert_value(*element, dfg));
                 AcirValue::Array(elements.collect())
             }
+            Value::Slice { array: initial_array, .. } => {
+                let elements =
+                    initial_array.iter().map(|element| self.convert_value(*element, dfg));
+                AcirValue::Array(elements.collect())
+            }
             Value::Intrinsic(..) => todo!(),
             Value::Function(..) => unreachable!("ICE: All functions should have been inlined"),
             Value::Instruction { .. } | Value::Param { .. } => {
@@ -581,6 +586,16 @@ impl Context {
                 }
                 Vec::new()
             }
+            // Intrinsic::SlicePushBack => {
+            //     let mut slice = self.convert_array_value(arguments[0], dfg);
+            //     let elem = self.convert_value(arguments[1], dfg);
+
+            //     dbg!(slice.clone());
+            //     dbg!(elem.clone());
+            //     dbg!(self.convert_value(result_ids[0], dfg));
+            //     slice.push_back(elem);
+            //     vec![AcirValue::Array(slice)]
+            // }
             _ => todo!("expected a black box function"),
         }
     }

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

@@ -195,6 +195,17 @@ impl DataFlowGraph {
         self.make_value(Value::Array { array, element_type })
     }
 
+    /// Create a new slice value from the given elements
+    /// This is the initial slice for which the length will change
+    /// during program execution
+    pub(crate) fn make_slice(
+        &mut self,
+        array: im::Vector<ValueId>,
+        element_type: Rc<CompositeType>,
+    ) -> ValueId {
+        self.make_value(Value::Slice { array, element_type })
+    }
+
     /// Gets or creates a ValueId for the given FunctionId.
     pub(crate) fn import_function(&mut self, function: FunctionId) -> ValueId {
         if let Some(existing) = self.functions.get(&function) {
@@ -205,10 +216,16 @@ impl DataFlowGraph {
 
     /// Gets or creates a ValueId for the given Intrinsic.
     pub(crate) fn import_intrinsic(&mut self, intrinsic: Intrinsic) -> ValueId {
-        if let Some(existing) = self.intrinsics.get(&intrinsic) {
+        if let Some(existing) = self.get_intrinsic(intrinsic) {
             return *existing;
         }
-        self.values.insert(Value::Intrinsic(intrinsic))
+        let intrinsic_value_id = self.values.insert(Value::Intrinsic(intrinsic));
+        self.intrinsics.insert(intrinsic, intrinsic_value_id);
+        intrinsic_value_id
+    }
+
+    pub(crate) fn get_intrinsic(&mut self, intrinsic: Intrinsic) -> Option<&ValueId> {
+        self.intrinsics.get(&intrinsic)
     }
 
     /// Attaches results to the instruction, clearing any previous results.
@@ -322,7 +339,10 @@ impl DataFlowGraph {
     ) -> Option<(im::Vector<ValueId>, Rc<CompositeType>)> {
         match &self.values[self.resolve(value)] {
             // Vectors are shared, so cloning them is cheap
-            Value::Array { array, element_type } => Some((array.clone(), element_type.clone())),
+            Value::Array { array, element_type } | Value::Slice { array, element_type } => {
+                Some((array.clone(), element_type.clone()))
+            }
+            // Value::Array { array, element_type } => Some((array.clone(), element_type.clone())),
             _ => None,
         }
     }

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

@@ -8,7 +8,7 @@ use super::{
     basic_block::BasicBlockId,
     dfg::DataFlowGraph,
     map::Id,
-    types::Type,
+    types::{NumericType, Type},
     value::{Value, ValueId},
 };
 
@@ -30,6 +30,8 @@ pub(crate) type InstructionId = Id<Instruction>;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Intrinsic {
     Sort,
+    ArrayLen,
+    SlicePushBack,
     Println,
     ToBits(Endian),
     ToRadix(Endian),
@@ -41,6 +43,8 @@ impl std::fmt::Display for Intrinsic {
         match self {
             Intrinsic::Println => write!(f, "println"),
             Intrinsic::Sort => write!(f, "arraysort"),
+            Intrinsic::ArrayLen => write!(f, "array_len"),
+            Intrinsic::SlicePushBack => write!(f, "slice_push_back"),
             Intrinsic::ToBits(Endian::Big) => write!(f, "to_be_bits"),
             Intrinsic::ToBits(Endian::Little) => write!(f, "to_le_bits"),
             Intrinsic::ToRadix(Endian::Big) => write!(f, "to_be_radix"),
@@ -57,6 +61,8 @@ impl Intrinsic {
         match name {
             "println" => Some(Intrinsic::Println),
             "arraysort" => Some(Intrinsic::Sort),
+            "array_len" => Some(Intrinsic::ArrayLen),
+            "slice_push_back" => Some(Intrinsic::SlicePushBack),
             "to_le_radix" => Some(Intrinsic::ToRadix(Endian::Little)),
             "to_be_radix" => Some(Intrinsic::ToRadix(Endian::Big)),
             "to_le_bits" => Some(Intrinsic::ToBits(Endian::Little)),
@@ -297,7 +303,6 @@ impl Instruction {
             Instruction::ArrayGet { array, index } => {
                 let array = dfg.get_array_constant(*array);
                 let index = dfg.get_numeric_constant(*index);
-
                 if let (Some((array, _)), Some(index)) = (array, index) {
                     let index =
                         index.try_to_u64().expect("Expected array index to fit in u64") as usize;
@@ -310,7 +315,6 @@ impl Instruction {
             Instruction::ArraySet { array, index, value } => {
                 let array = dfg.get_array_constant(*array);
                 let index = dfg.get_numeric_constant(*index);
-
                 if let (Some((array, element_type)), Some(index)) = (array, index) {
                     let index =
                         index.try_to_u64().expect("Expected array index to fit in u64") as usize;
@@ -329,7 +333,36 @@ impl Instruction {
                     None
                 }
             }
-            Instruction::Call { .. } => None,
+            Instruction::Call { func, arguments } => {
+                let mut simplify_result = None;
+                if let Some(intrinsic) = Intrinsic::lookup("slice_push_back") {
+                    if let Some(intrinsic) = dfg.get_intrinsic(intrinsic) {
+                        if func == intrinsic {
+                            let slice = dfg.get_array_constant(arguments[0]);
+                            if let (Some((mut slice, element_type)), elem) = (slice, arguments[1]) {
+                                slice.push_back(elem);
+                                let new_slice = dfg.make_slice(slice, element_type);
+                                simplify_result = SimplifiedTo(new_slice);
+                            }
+                        }
+                    }
+                }
+                if let Some(intrinsic) = Intrinsic::lookup("array_len") {
+                    if let Some(intrinsic) = dfg.get_intrinsic(intrinsic) {
+                        if func == intrinsic {
+                            let slice = dfg.get_array_constant(arguments[0]);
+                            if let Some((slice, _)) = slice {
+                                let slice_len = dfg.make_constant(
+                                    FieldElement::from(slice.len() as u128),
+                                    Type::Numeric(NumericType::NativeField),
+                                );
+                                simplify_result = SimplifiedTo(slice_len);
+                            }
+                        }
+                    }
+                };
+                simplify_result
+            }
             Instruction::Allocate { .. } => None,
             Instruction::Load { .. } => None,
             Instruction::Store { .. } => None,
@@ -696,6 +729,7 @@ impl std::fmt::Display for BinaryOp {
 
 /// Contains the result to Instruction::simplify, specifying how the instruction
 /// should be simplified.
+#[derive(Debug, Clone)]
 pub(crate) enum SimplifyResult {
     /// Replace this function's result with the given value
     SimplifiedTo(ValueId),

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

@@ -72,6 +72,10 @@ fn value(function: &Function, id: ValueId) -> String {
             let elements = vecmap(array, |element| value(function, *element));
             format!("[{}]", elements.join(", "))
         }
+        Value::Slice { element_type, .. } => {
+            let elements = vecmap(element_type.as_slice(), ToString::to_string);
+            format!("{:?}", elements)
+        }
         Value::Param { .. } | Value::Instruction { .. } => id.to_string(),
     }
 }

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

@@ -40,6 +40,9 @@ pub(crate) enum Value {
     /// Represents a constant array value
     Array { array: im::Vector<ValueId>, element_type: Rc<CompositeType> },
 
+    /// Represents a compile-time array
+    Slice { array: im::Vector<ValueId>, element_type: Rc<CompositeType> },
+
     /// This Value refers to a function in the IR.
     /// Functions always have the type Type::Function.
     /// If the argument or return types are needed, users should retrieve
@@ -60,6 +63,7 @@ impl Value {
             Value::Param { typ, .. } => typ.clone(),
             Value::NumericConstant { typ, .. } => typ.clone(),
             Value::Array { element_type, array } => Type::Array(element_type.clone(), array.len()),
+            Value::Slice { .. } => Type::Reference,
             Value::Function { .. } => Type::Function,
             Value::Intrinsic { .. } => Type::Function,
         }

crates/noirc_evaluator/src/ssa_refactor/opt/inlining.rs

@@ -211,6 +211,11 @@ impl<'function> PerFunctionContext<'function> {
                 let elements = array.iter().map(|value| self.translate_value(*value)).collect();
                 self.context.builder.array_constant(elements, element_type.clone())
             }
+            Value::Slice { array: initial_array, element_type } => {
+                let elements =
+                    initial_array.iter().map(|value| self.translate_value(*value)).collect();
+                self.context.builder.slice(elements, element_type.clone())
+            }
         };
 
         self.values.insert(id, new_value);

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

@@ -116,6 +116,14 @@ impl FunctionBuilder {
         self.current_function.dfg.make_array(elements, element_types)
     }
 
+    pub(crate) fn slice(
+        &mut self,
+        elements: im::Vector<ValueId>,
+        element_types: Rc<CompositeType>,
+    ) -> ValueId {
+        self.current_function.dfg.make_slice(elements, element_types)
+    }
+
     /// Returns the type of the given value.
     pub(crate) fn type_of_value(&self, value: ValueId) -> Type {
         self.current_function.dfg.type_of_value(value)

crates/noirc_evaluator/src/ssa_refactor/ssa_gen/context.rs

@@ -201,6 +201,7 @@ impl<'a> FunctionContext<'a> {
             ast::Type::Unit => panic!("convert_non_tuple_type called on a unit type"),
             ast::Type::Tuple(_) => panic!("convert_non_tuple_type called on a tuple: {typ}"),
             ast::Type::Function(_, _) => Type::Function,
+            ast::Type::Slice(_) => Type::Reference,
 
             // How should we represent Vecs?
             // Are they a struct of array + length + capacity?

crates/noirc_frontend/src/ast/mod.rs

@@ -30,7 +30,8 @@ use iter_extended::vecmap;
 pub enum UnresolvedType {
     FieldElement(CompTime),
     Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>), // [4]Witness = Array(4, Witness)
-    Integer(CompTime, Signedness, u32),                           // u32 = Integer(unsigned, 32)
+    Slice(Box<UnresolvedType>),
+    Integer(CompTime, Signedness, u32), // u32 = Integer(unsigned, 32)
     Bool(CompTime),
     Expression(UnresolvedTypeExpression),
     String(Option<UnresolvedTypeExpression>),
@@ -86,6 +87,7 @@ impl std::fmt::Display for UnresolvedType {
                 None => write!(f, "[{typ}]"),
                 Some(len) => write!(f, "[{typ}; {len}]"),
             },
+            Slice(typ) => write!(f, "[{typ}]"),
             Integer(is_const, sign, num_bits) => match sign {
                 Signedness::Signed => write!(f, "{is_const}i{num_bits}"),
                 Signedness::Unsigned => write!(f, "{is_const}u{num_bits}"),

crates/noirc_frontend/src/hir/resolution/resolver.rs

@@ -330,6 +330,9 @@ impl<'a> Resolver<'a> {
                 let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
                 Type::Array(Box::new(resolved_size), elem)
             }
+            UnresolvedType::Slice(elem) => {
+                Type::Slice(Box::new(self.resolve_type_inner(*elem, new_variables)))
+            }
             UnresolvedType::Expression(expr) => self.convert_expression_type(expr),
             UnresolvedType::Integer(comp_time, sign, bits) => Type::Integer(comp_time, sign, bits),
             UnresolvedType::Bool(comp_time) => Type::Bool(comp_time),
@@ -759,6 +762,10 @@ impl<'a> Resolver<'a> {
                 }
             }
 
+            Type::Slice(typ) => {
+                Self::find_numeric_generics_in_type(typ, found);
+            }
+
             Type::Tuple(fields) => {
                 for field in fields {
                     Self::find_numeric_generics_in_type(field, found);

crates/noirc_frontend/src/hir/type_check/expr.rs

@@ -273,6 +273,7 @@ impl<'interner> TypeChecker<'interner> {
             // XXX: We can check the array bounds here also, but it may be better to constant fold first
             // and have ConstId instead of ExprId for constants
             Type::Array(_, base_type) => *base_type,
+            Type::Slice(base_type) => *base_type,
             Type::Error => Type::Error,
             typ => {
                 let span = self.interner.expr_span(&index_expr.collection);

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

@@ -171,6 +171,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 let typ = match result {
                     Type::Array(_, elem_type) => *elem_type,
+                    Type::Slice(elem_type) => *elem_type,
                     Type::Error => Type::Error,
                     other => {
                         // TODO: Need a better span here