feat: don't eagerly error on cast expressions

compiler/noirc_driver/src/abi_gen.rs

@@ -13,7 +13,7 @@ use noirc_frontend::{
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
 };
-use noirc_frontend::{TypeBinding, TypeVariableKind};
+use noirc_frontend::{PolymorphicKind, TypeBinding, TypeVariableKind};
 
 /// Arranges a function signature and a generated circuit's return witnesses into a
 /// `noirc_abi::Abi`.
@@ -68,13 +68,18 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
 
             AbiType::Integer { sign, width: (*bit_width).into() }
         }
-        Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
-        | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
-            TypeBinding::Bound(typ) => abi_type_from_hir_type(context, typ),
-            TypeBinding::Unbound(_) => {
-                abi_type_from_hir_type(context, &Type::default_int_or_field_type())
+        Type::TypeVariable(
+            binding,
+            TypeVariableKind::Polymorphic(PolymorphicKind::IntegerOrField),
+        )
+        | Type::TypeVariable(binding, TypeVariableKind::Polymorphic(PolymorphicKind::Integer)) => {
+            match &*binding.borrow() {
+                TypeBinding::Bound(typ) => abi_type_from_hir_type(context, typ),
+                TypeBinding::Unbound(_) => {
+                    abi_type_from_hir_type(context, &Type::default_int_or_field_type())
+                }
             }
-        },
+        }
         Type::Bool => AbiType::Boolean,
         Type::String(size) => {
             let size = size

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -553,7 +553,7 @@ impl<'context> Elaborator<'context> {
     fn elaborate_cast(&mut self, cast: CastExpression, span: Span) -> (HirExpression, Type) {
         let (lhs, lhs_type) = self.elaborate_expression(cast.lhs);
         let r#type = self.resolve_type(cast.r#type);
-        let result = self.check_cast(lhs_type, &r#type, span);
+        let result = self.check_cast(&lhs_type, &r#type, span);
         let expr = HirExpression::Cast(HirCastExpression { lhs, r#type });
         (expr, result)
     }

compiler/noirc_frontend/src/elaborator/types.rs

@@ -779,17 +779,22 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub(super) fn check_cast(&mut self, from: Type, to: &Type, span: Span) -> Type {
+    pub(super) fn check_cast(&mut self, from: &Type, to: &Type, span: Span) -> Type {
         match from.follow_bindings() {
             Type::Integer(..)
             | Type::FieldElement
-            | Type::TypeVariable(_, TypeVariableKind::IntegerOrField)
-            | Type::TypeVariable(_, TypeVariableKind::Integer)
+            | Type::TypeVariable(_, TypeVariableKind::Polymorphic(..))
             | Type::Bool => (),
 
-            Type::TypeVariable(_, _) => {
-                self.push_err(TypeCheckError::TypeAnnotationsNeeded { span });
-                return Type::Error;
+            Type::TypeVariable(binding, TypeVariableKind::Normal) => {
+                if let TypeBinding::Bound(typ) = &*binding.borrow() {
+                    return self.check_cast(from, typ, span);
+                }
+                let expected = &&Type::polymorphic_integer_or_field_or_bool(self.interner);
+                self.unify(from, expected, || TypeCheckError::InvalidCast {
+                    from: from.clone(),
+                    span,
+                });
             }
             Type::Error => return Type::Error,
             from => {

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -18,7 +18,6 @@
     undo_instantiation_bindings,
 };
 use crate::token::Tokens;
-use crate::TypeVariable;
 use crate::{
     hir_def::{
         expr::{
@@ -36,6 +35,7 @@
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
     Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
 };
+use crate::{PolymorphicKind, TypeVariable};
 
 use super::errors::{IResult, InterpreterError};
 use super::value::{unwrap_rc, Value};
@@ -208,7 +208,7 @@
             }
         } else {
             let name = self.elaborator.interner.function_name(&function);
             unreachable!("Non-builtin, lowlevel or oracle builtin fn '{name}'")
         }
     }
 
@@ -661,9 +661,17 @@
                     Ok(Value::I64(value))
                 }
             }
-        } else if let Type::TypeVariable(variable, TypeVariableKind::IntegerOrField) = &typ {
+        } else if let Type::TypeVariable(
+            variable,
+            TypeVariableKind::Polymorphic(PolymorphicKind::IntegerOrField),
+        ) = &typ
+        {
             Ok(Value::Field(value))
-        } else if let Type::TypeVariable(variable, TypeVariableKind::Integer) = &typ {
+        } else if let Type::TypeVariable(
+            variable,
+            TypeVariableKind::Polymorphic(PolymorphicKind::Integer),
+        ) = &typ
+        {
             let value: u64 = value
                 .try_to_u64()
                 .ok_or(InterpreterError::IntegerOutOfRangeForType { value, typ, location })?;
@@ -1238,8 +1246,8 @@
                     let expr = result.into_expression(self.elaborator.interner, location)?;
                     let expr = self
                         .elaborator
                         .elaborate_item_from_comptime(self.current_function, |elab| {
                             elab.elaborate_expression(expr).0
                         });
                     result = self.evaluate(expr)?;
                 }