chore: Brillig call return type check

compiler/noirc_evaluator/src/errors.rs

@@ -174,17 +174,6 @@ 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_frontend/src/hir/type_check/errors.rs

@@ -119,6 +119,8 @@ pub enum TypeCheckError {
         "Cannot pass a mutable reference from a constrained runtime to an unconstrained runtime"
     )]
     ConstrainedReferenceToUnconstrained { span: Span },
+    #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
+    UnconstrainedSliceReturnToConstrained { span: Span },
 }
 
 impl TypeCheckError {
@@ -207,7 +209,8 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::IntegerAndFieldBinaryOperation { span }
             | TypeCheckError::OverflowingAssignment { span, .. }
             | TypeCheckError::FieldModulo { span }
-            | TypeCheckError::ConstrainedReferenceToUnconstrained { span } => {
+            | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
+            | TypeCheckError::UnconstrainedSliceReturnToConstrained { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(

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

@@ -169,6 +169,7 @@ impl<'interner> TypeChecker<'interner> {
                     (typ, *arg, self.interner.expr_span(arg))
                 });
 
+                // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
                 for (typ, _, _) in args.iter() {
                     if is_current_func_constrained
                         && is_unconstrained_call
@@ -182,7 +183,20 @@ impl<'interner> TypeChecker<'interner> {
                 }
 
                 let span = self.interner.expr_span(expr_id);
-                self.bind_function_type(function, args, span)
+                let return_type = self.bind_function_type(function, args, span);
+
+                // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
+                if is_current_func_constrained
+                    && is_unconstrained_call
+                    && return_type.contains_slice()
+                {
+                    self.errors.push(TypeCheckError::UnconstrainedSliceReturnToConstrained {
+                        span: self.interner.expr_span(expr_id),
+                    });
+                    return Type::Error;
+                }
+
+                return_type
             }
             HirExpression::MethodCall(mut method_call) => {
                 let mut object_type = self.check_expression(&method_call.object).follow_bindings();

compiler/noirc_frontend/src/hir_def/types.rs

@@ -157,7 +157,7 @@ impl Type {
         }
     }
 
-    fn contains_slice(&self) -> bool {
+    pub(crate) fn contains_slice(&self) -> bool {
         match self {
             Type::Array(size, _) => matches!(size.as_ref(), Type::NotConstant),
             Type::Struct(struct_typ, generics) => {