feat!: Syncing TypeVariableKind with Kind

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -471,9 +471,9 @@ impl<'context> Elaborator<'context> {
         let context = self.function_context.pop().expect("Imbalanced function_context pushes");
 
         for typ in context.type_variables {
-            if let Type::TypeVariable(variable, kind) = typ.follow_bindings() {
+            if let Type::TypeVariable(variable, type_var_kind) = typ.follow_bindings() {
                 let msg = "TypeChecker should only track defaultable type vars";
-                variable.bind(kind.default_type().expect(msg));
+                variable.bind(type_var_kind.default_type().expect(msg), &type_var_kind.kind());
             }
         }
 

compiler/noirc_frontend/src/elaborator/trait_impls.rs

@@ -153,12 +153,12 @@ impl<'context> Elaborator<'context> {
         let override_meta = self.interner.function_meta(func_id);
         // Substitute each generic on the trait function with the corresponding generic on the impl function
         for (
-            ResolvedGeneric { type_var: trait_fn_generic, .. },
+            ResolvedGeneric { type_var: trait_fn_generic, kind: trait_fn_kind, .. },
             ResolvedGeneric { name, type_var: impl_fn_generic, kind, .. },
         ) in method.direct_generics.iter().zip(&override_meta.direct_generics)
         {
             let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone(), kind.clone());
-            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
+            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), trait_fn_kind.clone(), arg));
         }
 
         let mut substituted_method_ids = HashSet::default();

compiler/noirc_frontend/src/elaborator/traits.rs

@@ -287,12 +287,12 @@ pub(crate) fn check_trait_impl_method_matches_declaration(
 
         // Substitute each generic on the trait function with the corresponding generic on the impl function
         for (
-            ResolvedGeneric { type_var: trait_fn_generic, .. },
+            ResolvedGeneric { type_var: trait_fn_generic, kind: trait_fn_kind, .. },
             ResolvedGeneric { name, type_var: impl_fn_generic, kind, .. },
         ) in trait_fn_meta.direct_generics.iter().zip(&meta.direct_generics)
         {
             let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone(), kind.clone());
-            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
+            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), trait_fn_kind.clone(), arg));
         }
 
         let (declaration_type, _) = trait_fn_meta.typ.instantiate_with_bindings(bindings, interner);

compiler/noirc_frontend/src/elaborator/types.rs

@@ -169,14 +169,12 @@ impl<'context> Elaborator<'context> {
             _ => (),
         }
 
-        if !kind.matches_opt(resolved_type.kind()) {
+        if !kind.unifies(&resolved_type.kind()) {
             let expected_typ_err = CompilationError::TypeError(TypeCheckError::TypeKindMismatch {
                 expected_kind: kind.to_string(),
                 expr_kind: resolved_type
                     .kind()
-                    .as_ref()
-                    .map(Kind::to_string)
-                    .unwrap_or("unknown".to_string()),
+                    .to_string(),
                 expr_span: span,
             });
             self.errors.push((expected_typ_err, self.file));
@@ -452,7 +450,7 @@ impl<'context> Elaborator<'context> {
                             });
                             return Type::Error;
                         }
-                        if let Some(result) = op.function(lhs, rhs) {
+                        if let Some(result) = op.function(lhs, rhs, &lhs_kind) {
                             Type::Constant(result, lhs_kind)
                         } else {
                             self.push_err(ResolverError::OverflowInType { lhs, op, rhs, span });
@@ -470,15 +468,13 @@ impl<'context> Elaborator<'context> {
     }
 
     fn check_kind(&mut self, typ: Type, expected_kind: &Kind, span: Span) -> Type {
-        if let Some(kind) = typ.kind() {
-            if !kind.unifies(expected_kind) {
-                self.push_err(TypeCheckError::TypeKindMismatch {
-                    expected_kind: expected_kind.to_string(),
-                    expr_kind: kind.to_string(),
-                    expr_span: span,
-                });
-                return Type::Error;
-            }
+        if !typ.kind().unifies(expected_kind) {
+            self.push_err(TypeCheckError::TypeKindMismatch {
+                expected_kind: expected_kind.to_string(),
+                expr_kind: typ.kind().to_string(),
+                expr_span: span,
+            });
+            return Type::Error;
         }
         typ
     }
@@ -785,7 +781,7 @@ impl<'context> Elaborator<'context> {
                 let expected =
                     Type::Function(args, Box::new(ret.clone()), Box::new(env_type), false);
 
-                if let Err(error) = binding.try_bind(expected, span) {
+                if let Err(error) = binding.try_bind(expected, &Kind::Normal, span) {
                     self.push_err(error);
                 }
                 ret
@@ -927,13 +923,13 @@ impl<'context> Elaborator<'context> {
             span,
         });
 
-        let use_impl = !lhs_type.is_numeric();
+        let use_impl = !lhs_type.is_numeric_value();
 
         // If this operator isn't valid for fields we have to possibly narrow
         // TypeVariableKind::IntegerOrField to TypeVariableKind::Integer.
         // Doing so also ensures a type error if Field is used.
         // The is_numeric check is to allow impls for custom types to bypass this.
-        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
+        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric_value() {
             let target = Type::polymorphic_integer(self.interner);
 
             use crate::ast::BinaryOpKind::*;
@@ -982,7 +978,7 @@ impl<'context> Elaborator<'context> {
                         &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
                         || TypeCheckError::InvalidShiftSize { span },
                     );
-                    let use_impl = if lhs_type.is_numeric() {
+                    let use_impl = if lhs_type.is_numeric_value() {
                         let integer_type = Type::polymorphic_integer(self.interner);
                         self.bind_type_variables_for_infix(lhs_type, op, &integer_type, span)
                     } else {
@@ -1082,14 +1078,14 @@ impl<'context> Elaborator<'context> {
 
                         // The `!` prefix operator is not valid for Field, so if this is a numeric
                         // type we constrain it to just (non-Field) integer types.
-                        if matches!(op, crate::ast::UnaryOp::Not) && rhs_type.is_numeric() {
+                        if matches!(op, crate::ast::UnaryOp::Not) && rhs_type.is_numeric_value() {
                             let integer_type = Type::polymorphic_integer(self.interner);
                             self.unify(rhs_type, &integer_type, || {
                                 TypeCheckError::InvalidUnaryOp { kind: rhs_type.to_string(), span }
                             });
                         }
 
-                        Ok((rhs_type.clone(), !rhs_type.is_numeric()))
+                        Ok((rhs_type.clone(), !rhs_type.is_numeric_value()))
                     }
                     Integer(sign_x, bit_width_x) => {
                         if *op == UnaryOp::Minus && *sign_x == Signedness::Unsigned {
@@ -1171,7 +1167,7 @@ impl<'context> Elaborator<'context> {
             let object_type = object_type.substitute(&bindings);
             bindings.insert(
                 the_trait.self_type_typevar.id(),
-                (the_trait.self_type_typevar.clone(), object_type.clone()),
+                (the_trait.self_type_typevar.clone(), Kind::Normal, object_type.clone()),
             );
             self.interner.select_impl_for_expression(
                 expr_id,
@@ -1736,7 +1732,7 @@ impl<'context> Elaborator<'context> {
         for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics.ordered) {
             // Avoid binding t = t
             if !arg.occurs(param.type_var.id()) {
-                bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.clone()));
+                bindings.insert(param.type_var.id(), (param.type_var.clone(), param.kind.clone(), arg.clone()));
             }
         }
 
@@ -1755,7 +1751,7 @@ impl<'context> Elaborator<'context> {
 
             // Avoid binding t = t
             if !arg.typ.occurs(param.type_var.id()) {
-                bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.typ.clone()));
+                bindings.insert(param.type_var.id(), (param.type_var.clone(), param.kind.clone(), arg.typ.clone()));
             }
         }
 
@@ -1764,7 +1760,8 @@ impl<'context> Elaborator<'context> {
         // to specify a redundant type annotation.
         if assumed {
             let self_type = the_trait.self_type_typevar.clone();
-            bindings.insert(self_type.id(), (self_type, constraint.typ.clone()));
+            // self_type has Kind::Normal
+            bindings.insert(self_type.id(), (self_type, Kind::Normal, constraint.typ.clone()));
         }
     }
 }

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

@@ -34,6 +34,7 @@ use crate::{
             HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
             HirPattern,
         },
+        types::Kind,
     },
     macros_api::{HirLiteral, HirStatement, NodeInterner},
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
@@ -89,7 +90,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         // To match the monomorphizer, we need to call follow_bindings on each of
         // the instantiation bindings before we unbind the generics from the previous function.
         // This is because the instantiation bindings refer to variables from the call site.
-        for (_, binding) in instantiation_bindings.values_mut() {
+        for (_, _kind, binding) in instantiation_bindings.values_mut() {
             *binding = binding.follow_bindings();
         }
 
@@ -98,7 +99,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         let mut impl_bindings =
             perform_impl_bindings(self.elaborator.interner, trait_method, function, location)?;
 
-        for (_, binding) in impl_bindings.values_mut() {
+        for (_, _kind, binding) in impl_bindings.values_mut() {
             *binding = binding.follow_bindings();
         }
 
@@ -349,7 +350,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
 
         if let Some(bindings) = self.bound_generics.last() {
             for (var, binding) in bindings {
-                var.force_bind(binding.clone());
+                var.force_bind(binding.clone(), &Kind::Normal);
             }
         }
     }
@@ -360,11 +361,11 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             .last_mut()
             .expect("remember_bindings called with no bound_generics on the stack");
 
-        for (var, binding) in main_bindings.values() {
+        for (var, _kind, binding) in main_bindings.values() {
             bound_generics.insert(var.clone(), binding.follow_bindings());
         }
 
-        for (var, binding) in impl_bindings.values() {
+        for (var, _kind, binding) in impl_bindings.values() {
             bound_generics.insert(var.clone(), binding.follow_bindings());
         }
     }