fix(ssa): Fix slice intrinsic handling in the capacity tracker

compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs

@@ -73,6 +73,7 @@ impl<'a> SliceCapacityTracker<'a> {
                         Intrinsic::SlicePopFront => (Some(1), results.len() - 1),
                         // The slice capacity of these intrinsics is not determined by the arguments of the function.
                         Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => (None, 1),
+                        Intrinsic::AsSlice => (Some(0), 1),
                         _ => return,
                     };
                     let result_slice = results[result_index];
@@ -90,6 +91,7 @@ impl<'a> SliceCapacityTracker<'a> {
                                     self.compute_slice_capacity(*arg, slice_sizes);
                                 }
                             }
+
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity + 1;
                                 slice_sizes.insert(result_slice, new_capacity);
@@ -102,9 +104,6 @@ impl<'a> SliceCapacityTracker<'a> {
                                 .expect("ICE: Should have an argument index for slice intrinsics");
                             let slice_contents = arguments[argument_index];
 
-                            // We do not decrement the size on intrinsics that could remove values from a slice.
-                            // This is because we could potentially go back to the smaller slice and not fill in dummies.
-                            // This pass should be tracking the potential max that a slice ***could be***
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity - 1;
                                 slice_sizes.insert(result_slice, new_capacity);
@@ -121,6 +120,15 @@ impl<'a> SliceCapacityTracker<'a> {
                             slice_sizes
                                 .insert(result_slice, FieldElement::max_num_bytes() as usize);
                         }
+                        Intrinsic::AsSlice => {
+                            let argument_index = argument_index
+                                .expect("ICE: Should have an argument index for AsSlice builtin");
+                            let array_size = self
+                                .dfg
+                                .try_get_array_length(arguments[argument_index])
+                                .expect("ICE: Should be have an array length for AsSlice input");
+                            slice_sizes.insert(result_slice, array_size);
+                        }
                         _ => {}
                     }
                 }

test_programs/execution_success/regression_capacity_tracker/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "regression_capacity_tracker"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]

test_programs/execution_success/regression_capacity_tracker/Prover.toml

@@ -0,0 +1,3 @@
+expected = "10"
+first = "10"
+input = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

test_programs/execution_success/regression_capacity_tracker/src/main.nr

@@ -0,0 +1,19 @@
+// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631
+// for context. 
+// We were not accurately accounting for situations where the slice capacity tracker
+// was expecting a capacity from slice intrinsic results.
+fn main(expected: pub Field, first: Field, input: [Field; 20]) {
+    let mut hasher_slice = input.as_slice();
+    hasher_slice = hasher_slice.push_front(first);
+    assert(hasher_slice[0] == expected);
+    // We need a conditional based upon witnesses 
+    // to force a store of the slice. 
+    // If this successfully compiles it means we have stored 
+    // the results of the slice intrinsics used above.
+    if expected as u32 > 10 {
+        hasher_slice[expected - 10] = 100;
+    } else {
+        hasher_slice[expected] = 100;
+    }
+    assert(hasher_slice[0] == expected);
+}