wip: add bool:prevent_numeric to Generics type, debugging failing tes…

…ts, add assertion that prevent_numeric is retained for different copies of generic with same name

compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs

@@ -501,7 +501,7 @@ pub(crate) fn check_methods_signatures(
     }
 
     // We also need to bind the traits generics to the trait's generics on the impl
-    for (generic, binding) in the_trait.generics.iter().zip(trait_generics) {
+    for ((generic, _prevent_numeric), binding) in the_trait.generics.iter().zip(trait_generics) {
         generic.bind(binding);
     }
 
@@ -609,7 +609,7 @@ pub(crate) fn check_methods_signatures(
     the_trait.set_methods(trait_methods);
     the_trait.self_type_typevar.unbind(the_trait.self_type_typevar_id);
 
-    for generic in &the_trait.generics {
+    for (generic, _prevent_numeric) in &the_trait.generics {
         generic.unbind(generic.id());
     }
 }

compiler/noirc_frontend/src/hir/resolution/resolver.rs

@@ -684,12 +684,12 @@ impl<'a> Resolver<'a> {
             None => {
                 let id = self.interner.next_type_variable_id();
                 let typevar = TypeVariable::unbound(id);
-                new_variables.push(typevar.clone());
+                let prevent_numeric = true;
+                new_variables.push((typevar.clone(), prevent_numeric));
 
                 // 'Named'Generic is a bit of a misnomer here, we want a type variable that
                 // wont be bound over but this one has no name since we do not currently
                 // require users to explicitly be generic over array lengths.
-                let prevent_numeric = true;
                 Type::NamedGeneric(typevar, Rc::new("".into()), prevent_numeric)
             }
             Some(length) => self.convert_expression_type(length),
@@ -820,7 +820,7 @@ impl<'a> Resolver<'a> {
                 self.generics.push((name, typevar.clone(), span, prevent_numeric));
             }
 
-            typevar
+            (typevar, prevent_numeric)
         })
     }
 
@@ -830,7 +830,8 @@ impl<'a> Resolver<'a> {
     pub fn add_existing_generics(&mut self, names: &UnresolvedGenerics, generics: &Generics) {
         assert_eq!(names.len(), generics.len());
 
-        for (name, typevar) in names.iter().zip(generics) {
+        for (name, (typevar, prevent_numeric)) in names.iter().zip(generics) {
+            assert!(*prevent_numeric == name.prevent_numeric);
             self.add_existing_generic(
                 &name.ident.0.contents,
                 name.ident.0.span(),
@@ -913,7 +914,7 @@ impl<'a> Resolver<'a> {
 
         let attributes = func.attributes().clone();
 
-        let mut generics = vecmap(&self.generics, |(_, typevar, _, _)| typevar.clone());
+        let mut generics = vecmap(&self.generics, |(_, typevar, _, prevent_numeric)| (typevar.clone(), *prevent_numeric));
         let mut parameters = vec![];
         let mut parameter_types = vec![];
 

compiler/noirc_frontend/src/hir/resolution/traits.rs

@@ -41,8 +41,8 @@ pub(crate) fn resolve_traits(
     let mut all_errors = Vec::new();
 
     for (trait_id, unresolved_trait) in traits {
-        let generics = vecmap(&unresolved_trait.trait_def.generics, |_| {
-            TypeVariable::unbound(context.def_interner.next_type_variable_id())
+        let generics = vecmap(&unresolved_trait.trait_def.generics, |generic_ident| {
+            (TypeVariable::unbound(context.def_interner.next_type_variable_id()), generic_ident.prevent_numeric)
         });
 
         // Resolve order
@@ -142,7 +142,7 @@ fn resolve_trait_methods(
             let arguments = vecmap(parameters, |param| resolver.resolve_type(param.1.clone()));
             let return_type = resolver.resolve_type(return_type.get_type().into_owned());
 
-            let generics = vecmap(resolver.get_generics(), |(_, type_var, _, _)| type_var.clone());
+            let generics = vecmap(resolver.get_generics(), |(_, type_var, _, prevent_numeric)| (type_var.clone(), *prevent_numeric));
 
             let default_impl_list: Vec<_> = unresolved_trait
                 .fns_with_default_impl
@@ -455,7 +455,7 @@ pub(crate) fn resolve_trait_impls(
                 methods: vecmap(&impl_methods, |(_, func_id)| *func_id),
             });
 
-            let impl_generics = vecmap(impl_generics, |(_, type_variable, _, _)| type_variable);
+            let impl_generics = vecmap(impl_generics, |(_, type_variable, _, prevent_numeric)| (type_variable, prevent_numeric));
 
             if let Err((prev_span, prev_file)) = interner.add_trait_implementation(
                 self_type.clone(),

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

@@ -325,7 +325,7 @@ impl<'interner> TypeChecker<'interner> {
             let the_trait = self.interner.get_trait(constraint.trait_id);
             assert_eq!(the_trait.generics.len(), constraint.trait_generics.len());
 
-            for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
+            for ((param, _prevent_numeric), arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
                 bindings.insert(param.id(), (param.clone(), arg.clone()));
             }
         }

compiler/noirc_frontend/src/hir_def/traits.rs

@@ -147,7 +147,7 @@ impl TraitFunction {
         }
     }
 
-    pub fn generics(&self) -> &[TypeVariable] {
+    pub fn generics(&self) -> &[(TypeVariable, bool)] {
         match &self.typ {
             Type::Function(..) => &[],
             Type::Forall(generics, _) => generics,