fix: constants unify with implicitly added named generics

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1951,6 +1951,13 @@
                     Err(UnificationError)
                 }
             }
+            (Constant(field, kind), Type::NamedGeneric(types::NamedGeneric { type_var, .. }))
+            | (Type::NamedGeneric(types::NamedGeneric { type_var, .. }), Constant(field, kind)) => {
+                let other = Type::Constant(*field, kind.clone());
+                other.try_unify_to_type_variable(type_var, bindings, |bindings| {
+                    other.try_bind_to(type_var, bindings, kind.clone())
+                })
+            }
 
             (Constant(value, kind), other) | (other, Constant(value, kind)) => {
                 let dummy_location = Location::dummy();
@@ -2397,7 +2404,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 {
@@ -2483,7 +2490,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()));
@@ -2650,7 +2657,7 @@
         }
     }
 
     /// Follow bindings if this is a type variable or generic to the first non-typevariable
     /// type. Unlike `follow_bindings`, this won't recursively follow any bindings on any
     /// fields or arguments of this type.
     pub fn follow_bindings_shallow(&self) -> Cow<Type> {
@@ -2675,7 +2682,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
@@ -3181,7 +3188,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::DataType(def, args) => {
                 def.hash(state);
                 args.hash(state);

test_programs/compile_failure/associated_constant_bound_with_different_types/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "associated_constant_bound_with_different_types"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.33.0"
+
+[dependencies]

test_programs/compile_failure/associated_constant_bound_with_different_types/src/main.nr

@@ -0,0 +1,40 @@
+trait TraitWithAssociatedConstant {
+    let N: u32;
+
+    fn foo(_: Self) -> bool {
+        true
+    }
+
+    fn make_array(self) -> [Field; Self::N];
+}
+
+struct Foo {}
+
+impl TraitWithAssociatedConstant for Foo {
+    let N: u32 = 5;
+
+    fn make_array(self) -> [Field; Self::N] {
+        std::mem::zeroed()
+    }
+}
+
+struct Wrapper<T> {
+    inner: T,
+}
+
+impl<U> std::cmp::Eq for Wrapper<U>
+where
+    U: TraitWithAssociatedConstant,
+{
+
+    fn eq(self, _other: Self) -> bool {
+        let _array1: [Field; 5] = self.inner.make_array();
+        let _array2: [Field; 6] = self.inner.make_array(); // get the same method to return an array of a different size
+        self.inner.foo()
+    }
+}
+
+fn main() {
+    let wrapper = Wrapper { inner: Foo {} };
+    assert_eq(wrapper, wrapper);
+}

test_programs/compile_failure/associated_constant_bound_with_different_types/stderr.txt

@@ -0,0 +1,8 @@
+error: Expected type [Field; 6], found type [Field; 5]
+   ┌─ src/main.nr:32:35
+   │
+32 │         let _array2: [Field; 6] = self.inner.make_array(); // get the same method to return an array of a different size
+   │                                   -----------------------
+   │
+
+Aborting due to 1 previous error

test_programs/compile_success_empty/regression_8252/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_8252"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/compile_success_empty/regression_8252/src/main.nr

@@ -0,0 +1,32 @@
+trait TraitWithAssociatedConstant {
+    let N: u32;
+
+    fn foo(_: Self) -> bool {
+        true
+    }
+}
+
+struct Foo {}
+
+impl TraitWithAssociatedConstant for Foo {
+    let N: u32 = 42;
+}
+
+struct Wrapper<T> {
+    inner: T,
+}
+
+impl<T> std::cmp::Eq for Wrapper<T>
+where
+    T: TraitWithAssociatedConstant,
+{
+
+    fn eq(self, _: Self) -> bool {
+        self.inner.foo()
+    }
+}
+
+fn main() {
+    let wrapper = Wrapper { inner: Foo {} };
+    assert_eq(wrapper, wrapper);
+}

test_programs/compile_success_empty/regression_8252_2/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_8252_2"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/compile_success_empty/regression_8252_2/src/main.nr

@@ -0,0 +1,41 @@
+trait TraitWithAssociatedConstant {
+    let N: u32;
+
+    fn foo(_: Self) -> bool {
+        true
+    }
+}
+
+struct Foo {}
+
+impl TraitWithAssociatedConstant for Foo {
+    let N: u32 = 4;
+}
+
+struct Bar {}
+
+impl TraitWithAssociatedConstant for Bar {
+    let N: u32 = 5;
+}
+
+struct Wrapper<T> {
+    inner: T,
+}
+
+impl<T> std::cmp::Eq for Wrapper<T>
+where
+    T: TraitWithAssociatedConstant,
+{
+
+    fn eq(self, _: Self) -> bool {
+        self.inner.foo()
+    }
+}
+
+fn main() {
+    let wrapper = Wrapper { inner: Foo {} };
+    assert_eq(wrapper, wrapper);
+
+    let wrapper = Wrapper { inner: Bar {} };
+    assert_eq(wrapper, wrapper);
+}