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 @@
         }
     }
 
-    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) => {
@@ -1408,7 +1408,7 @@
             Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => {
                 substitute_binding(binding)
             }
             // Do not substitute_helper fields, it ca, substitute_bound_typevarsn lead to infinite recursion
             // and we should not match fields when type checking anyway.
             Type::Struct(fields, args) => {
                 let args = vecmap(args, |arg| {
@@ -1423,7 +1423,7 @@
                 Type::Tuple(fields)
             }
             Type::Forall(typevars, typ) => {
                 // Trying to substitute_helper a variable de, substitute_bound_typevarsfined within a nested Forall
                 // is usually impossible and indicative of an error in the type checker somewhere.
                 for var in typevars {
                     assert!(!type_bindings.contains_key(&var.id()));