fix: Clean error when attemping to return a slice from Brillig to ACIR

compiler/noirc_evaluator/src/errors.rs

@@ -46,6 +46,8 @@ pub enum RuntimeError {
     NestedSlice { call_stack: CallStack },
     #[error("Big Integer modulus do no match")]
     BigIntModulus { call_stack: CallStack },
+    #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
+    UnconstrainedSliceReturnToConstrained { call_stack: CallStack },
 }
 
 // We avoid showing the actual lhs and rhs since most of the time they are just 0
@@ -135,7 +137,8 @@ impl RuntimeError {
             | RuntimeError::IntegerOutOfBounds { call_stack, .. }
             | RuntimeError::UnsupportedIntegerSize { call_stack, .. }
             | RuntimeError::NestedSlice { call_stack, .. }
-            | RuntimeError::BigIntModulus { call_stack, .. } => call_stack,
+            | RuntimeError::BigIntModulus { call_stack, .. }
+            | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack } => call_stack,
         }
     }
 }
@@ -171,6 +174,17 @@ impl RuntimeError {
                     location.span,
                 )
             }
+            RuntimeError::UnconstrainedSliceReturnToConstrained { .. } => {
+                let primary_message = self.to_string();
+                let location =
+                    self.call_stack().back().expect("Expected RuntimeError to have a location");
+
+                Diagnostic::simple_error(
+                    primary_message,
+                    "If attempting to return a `Vec` type, `Vec` contains a slice internally.".to_string(),
+                    location.span,
+                )
+            }
             _ => {
                 let message = self.to_string();
                 let location =

compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs

@@ -509,6 +509,14 @@ impl Context {
                                 "expected an intrinsic/brillig call, but found {func:?}. All ACIR methods should be inlined"
                             ),
                             RuntimeType::Brillig => {
+                                // Check that we are not attempting to return a slice from 
+                                // an unconstrained runtime to a constrained runtime
+                                for result_id in result_ids {
+                                    if dfg.type_of_value(*result_id).contains_slice_element() {
+                                        return Err(RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack: self.acir_context.get_call_stack() })
+                                    }
+                                }
+
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
 
                                 let code = self.gen_brillig_for(func, brillig)?;

test_programs/compile_failure/brillig_slice_to_acir/Nargo.toml

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

test_programs/compile_failure/brillig_slice_to_acir/src/main.nr

@@ -0,0 +1,14 @@
+global DEPTH: Field = 40000;
+
+fn main(x: [u32; DEPTH], y: u32) {
+    let mut new_x = [];
+    new_x = clear(x, y);
+}
+
+unconstrained fn clear(x: [u32; DEPTH], y: u32) -> [u32] {
+    let mut a = [];
+    for i in 0..y {
+        a = a.push_back(x[i]);
+    }
+    a
+}

test_programs/compile_failure/brillig_vec_to_acir/Nargo.toml

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

test_programs/compile_failure/brillig_vec_to_acir/src/main.nr

@@ -0,0 +1,14 @@
+global DEPTH: Field = 40000;
+
+fn main(x: [u32; DEPTH], y: u32) {
+    let mut new_x = Vec::new();
+    new_x = clear(x, y);
+}
+
+unconstrained fn clear(x: [u32; DEPTH], y: u32) -> Vec<u32> {
+    let mut a = Vec::new();
+    for i in 0..y {
+        a.push(x[i]);
+    }
+    a
+}