fix(frontend): Ban type vars bound to a reference from passing the unconstrained boundary

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1099,13 +1099,19 @@
             | Type::Unit
             | Type::Constant(_)
             | Type::Slice(_)
-            | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _, _)
             | Type::Function(_, _, _, _)
             | Type::FmtString(_, _)
             | Type::InfixExpr(..)
             | Type::Error => true,
 
+            Type::TypeVariable(type_var, _) | Type::NamedGeneric(type_var, _, _) => {
+                if let TypeBinding::Bound(typ) = &*type_var.borrow() {
+                    typ.is_valid_for_unconstrained_boundary()
+                } else {
+                    true
+                }
+            }
+
             // Quoted objects only exist at compile-time where the only execution
             // environment is the interpreter. In this environment, they are valid.
             Type::Quoted(_) => true,
@@ -1959,7 +1965,7 @@
         }
 
         let recur_on_binding = |id, replacement: &Type| {
             // Prevent recuring forever if there's a `T := T` binding
             if replacement.type_variable_id() == Some(id) {
                 replacement.clone()
             } else {
@@ -2030,7 +2036,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()));
@@ -2197,7 +2203,7 @@
 
     /// Replace any `Type::NamedGeneric` in this type with a `Type::TypeVariable`
     /// using to the same inner `TypeVariable`. This is used during monomorphization
     /// to bind to named generics since they are unbindable during type checking.
     pub fn replace_named_generics_with_type_variables(&mut self) {
         match self {
             Type::FieldElement
@@ -2576,7 +2582,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::Struct(def, args) => {
                 def.hash(state);
                 args.hash(state);
@@ -2669,7 +2675,7 @@
             // Special case: we consider unbound named generics and type variables to be equal to each
             // other if their type variable ids match. This is important for some corner cases in
             // monomorphization where we call `replace_named_generics_with_type_variables` but
             // still want them to be equal for canonicalization checks in arithmetic generics.
             // Without this we'd fail the `serialize` test.
             (
                 NamedGeneric(lhs_var, _, _) | TypeVariable(lhs_var, _),

compiler/noirc_frontend/src/tests.rs

@@ -2335,7 +2335,7 @@
 }
 
 #[test]
 fn underflowing_u8() {
     let src = r#"
         fn main() {
             let _: u8 = -1;
@@ -2373,7 +2373,7 @@
 }
 
 #[test]
 fn underflowing_i8() {
     let src = r#"
         fn main() {
             let _: i8 = -129;
@@ -3366,7 +3366,7 @@
 }
 
 #[test]
 fn unoquted_integer_as_integer_token() {
     let src = r#"
     trait Serialize<let N: u32> {
         fn serialize() {}
@@ -3377,7 +3377,7 @@
 
     fn attr(_f: FunctionDefinition) -> Quoted {
         let serialized_len = 1;
         // We are testing that when we unoqute $serialized_len, it's unquoted
         // as the token `1` and not as something else that later won't be parsed correctly
         // in the context of a generic argument.
         quote {
@@ -3424,3 +3424,32 @@
     assert_eq!(ident.to_string(), "foo");
     assert_eq!(*item_type, "function");
 }
+
+#[test]
+fn constrained_reference_to_unconstrained() {
+    let src = r#"
+    fn main(mut x: u32, y: pub u32) {
+        let x_ref = &mut x;
+        if x == 5  {
+            unsafe {
+                mut_ref_input(x_ref, y);        
+            }
+        }
+
+        assert(x == 10);
+    }
+
+    unconstrained fn mut_ref_input(x: &mut u32, y: u32) {
+        *x = y;
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::ConstrainedReferenceToUnconstrained { .. }) =
+        &errors[0].0
+    else {
+        panic!("Expected an error about passing a constrained reference to unconstrained");
+    };
+}