fix(frontend): Error for when impl is stricter than trait

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -552,6 +552,7 @@ impl<'context> Elaborator<'context> {
                         typ: lhs_type.clone(),
                         trait_id: trait_id.trait_id,
                         trait_generics: Vec::new(),
+                        span,
                     };
                     self.push_trait_constraint(constraint, expr_id);
                     self.type_check_operator_method(expr_id, trait_id, &lhs_type, span);

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -597,7 +597,7 @@ impl<'context> Elaborator<'context> {
             });
         }
 
-        Some(TraitConstraint { typ, trait_id, trait_generics })
+        Some(TraitConstraint { typ, trait_id, trait_generics, span })
     }
 
     /// Extract metadata from a NoirFunction
@@ -898,7 +898,14 @@ impl<'context> Elaborator<'context> {
 
         if let Some(trait_id) = trait_impl.trait_id {
             self.generics = trait_impl.resolved_generics.clone();
-            self.collect_trait_impl_methods(trait_id, trait_impl);
+
+            let where_clause = trait_impl
+                .where_clause
+                .iter()
+                .flat_map(|item| self.resolve_trait_constraint(item))
+                .collect::<Vec<_>>();
+
+            self.collect_trait_impl_methods(trait_id, trait_impl, &where_clause);
 
             let span = trait_impl.object_type.span.expect("All trait self types should have spans");
             self.declare_methods_on_struct(true, &mut trait_impl.methods, span);
@@ -908,12 +915,6 @@ impl<'context> Elaborator<'context> {
                 self.interner.set_function_trait(*func_id, self_type.clone(), trait_id);
             }
 
-            let where_clause = trait_impl
-                .where_clause
-                .iter()
-                .flat_map(|item| self.resolve_trait_constraint(item))
-                .collect();
-
             let trait_generics = trait_impl.resolved_trait_generics.clone();
 
             let resolved_trait_impl = Shared::new(TraitImpl {
@@ -1048,6 +1049,7 @@ impl<'context> Elaborator<'context> {
         &mut self,
         trait_id: TraitId,
         trait_impl: &mut UnresolvedTraitImpl,
+        trait_impl_where_clause: &[TraitConstraint],
     ) {
         self.local_module = trait_impl.module_id;
         self.file = trait_impl.file_id;
@@ -1104,6 +1106,34 @@ impl<'context> Elaborator<'context> {
                 }
             } else {
                 for (_, func_id, _) in &overrides {
+                    let func_meta = self.interner.function_meta(func_id);
+                    for override_trait_constraint in func_meta.trait_constraints.clone() {
+                        // We allow where clauses on impls but during definition collection they are included as part of the where
+                        // clause of each function. This check is necessary so we do not unnecessarily error on trait impl where clauses.
+                        let override_constraint_is_from_impl =
+                            trait_impl_where_clause.iter().any(|impl_constraint| {
+                                impl_constraint.trait_id == override_trait_constraint.trait_id
+                            });
+                        if override_constraint_is_from_impl {
+                            continue;
+                        }
+
+                        let override_constraint_is_on_trait_method =
+                            method.trait_constraints.iter().any(|method_constraint| {
+                                method_constraint.trait_id == override_trait_constraint.trait_id
+                            });
+                        if !override_constraint_is_on_trait_method {
+                            let the_trait =
+                                self.interner.get_trait(override_trait_constraint.trait_id);
+                            self.push_err(DefCollectorErrorKind::ImplIsStricterThanTrait {
+                                constraint_typ: override_trait_constraint.typ,
+                                constraint_name: the_trait.name.0.contents.clone(),
+                                constraint_span: override_trait_constraint.span,
+                                trait_method_name: method.name.0.contents.clone(),
+                                trait_method_span: method.location.span,
+                            });
+                        }
+                    }
                     func_ids_in_trait.insert(*func_id);
                 }
 

compiler/noirc_frontend/src/elaborator/patterns.rs

@@ -546,7 +546,6 @@ impl<'context> Elaborator<'context> {
         if let Some(definition) = self.interner.try_definition(ident.id) {
             if let DefinitionKind::Function(function) = definition.kind {
                 let function = self.interner.function_meta(&function);
-
                 for mut constraint in function.trait_constraints.clone() {
                     constraint.apply_bindings(&bindings);
                     self.push_trait_constraint(constraint, expr_id);

compiler/noirc_frontend/src/elaborator/traits.rs

@@ -145,6 +145,7 @@ impl<'context> Elaborator<'context> {
                         location: Location::new(name.span(), unresolved_trait.file_id),
                         default_impl,
                         default_impl_module_id: unresolved_trait.module_id,
+                        trait_constraints: func_meta.trait_constraints.clone(),
                     });
                 });
             }

compiler/noirc_frontend/src/elaborator/types.rs

@@ -432,6 +432,7 @@ impl<'context> Elaborator<'context> {
                         generic.type_var.clone()
                     })),
                     trait_id,
+                    span: path.span(),
                 };
 
                 return Some((method, constraint, false));
@@ -466,6 +467,7 @@ impl<'context> Elaborator<'context> {
                     generic.type_var.clone()
                 })),
                 trait_id,
+                span: path.span(),
             };
             return Some((method, constraint, false));
         }

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

@@ -171,6 +171,7 @@ impl<'a> ModCollector<'a> {
             let module = ModuleId { krate, local_id: self.module_id };
 
             for (_, func_id, noir_function) in &mut unresolved_functions.functions {
+                // Attach any trait constraints on the impl to the function
                 noir_function.def.where_clause.append(&mut trait_impl.where_clause.clone());
                 let location = Location::new(noir_function.def.span, self.file_id);
                 context.def_interner.push_function(*func_id, &noir_function.def, module, location);

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

@@ -70,6 +70,14 @@ pub enum DefCollectorErrorKind {
     MacroError(MacroError),
     #[error("The only supported types of numeric generics are integers, fields, and booleans")]
     UnsupportedNumericGenericType { ident: Ident, typ: UnresolvedTypeData },
+    #[error("impl has stricter requirements than trait")]
+    ImplIsStricterThanTrait {
+        constraint_typ: crate::Type,
+        constraint_name: String,
+        constraint_span: Span,
+        trait_method_name: String,
+        trait_method_span: Span,
+    },
 }
 
 /// An error struct that macro processors can return.
@@ -251,6 +259,15 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
                     ident.0.span(),
                 )
             }
+            DefCollectorErrorKind::ImplIsStricterThanTrait { constraint_typ, constraint_name: constraint, constraint_span, trait_method_name, trait_method_span } => {
+                let mut diag = Diagnostic::simple_error(
+                    "impl has stricter requirements than trait".to_string(),
+                    format!("impl has extra requirement `{constraint_typ}: {constraint}`"),
+                    *constraint_span,
+                );
+                diag.add_secondary(format!("definition of `{trait_method_name}` from trait"), *trait_method_span);
+                diag
+            }
         }
     }
 }

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

@@ -544,7 +544,7 @@ impl<'a> Resolver<'a> {
             });
         }
 
-        Some(TraitConstraint { typ, trait_id, trait_generics })
+        Some(TraitConstraint { typ, trait_id, trait_generics, span })
     }
 
     /// Translates an UnresolvedType into a Type and appends any
@@ -1923,6 +1923,7 @@ impl<'a> Resolver<'a> {
                         generic.type_var.clone()
                     })),
                     trait_id,
+                    span: path.span(),
                 };
                 return Some((method, constraint, false));
             }
@@ -1940,6 +1941,7 @@ impl<'a> Resolver<'a> {
 
             let mut trait_path = path.clone();
             trait_path.pop();
+            let span = trait_path.span();
             let trait_id = self.lookup(trait_path).ok()?;
             let the_trait = self.interner.get_trait(trait_id);
 
@@ -1953,6 +1955,7 @@ impl<'a> Resolver<'a> {
                     generic.type_var.clone()
                 })),
                 trait_id,
+                span,
             };
             return Some((method, constraint, false));
         }
@@ -1994,6 +1997,7 @@ impl<'a> Resolver<'a> {
                             trait_generics: vecmap(trait_bound.trait_generics, |typ| {
                                 self.resolve_type(typ)
                             }),
+                            span: trait_bound.trait_path.span(),
                         };
                         return Some((method, constraint, true));
                     }

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

@@ -178,6 +178,8 @@ fn resolve_trait_methods(
                 location: Location::new(name.span(), unresolved_trait.file_id),
                 default_impl,
                 default_impl_module_id: unresolved_trait.module_id,
+                // This field is only used by the elaborator
+                trait_constraints: vec![],
             });
 
             let errors = resolver.take_errors().into_iter();

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

@@ -164,6 +164,8 @@ impl<'interner> TypeChecker<'interner> {
                                 typ: lhs_type.clone(),
                                 trait_id: id.trait_id,
                                 trait_generics: Vec::new(),
+                                // This field is used by the elaborator
+                                span: Span::default(),
                             };
                             self.trait_constraints.push((constraint, *expr_id));
                             self.typecheck_operator_method(*expr_id, id, &lhs_type, span);

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -227,6 +227,7 @@ impl HirMethodCallExpression {
                     typ: object_type,
                     trait_id: method_id.trait_id,
                     trait_generics: generics.clone(),
+                    span: location.span,
                 };
                 (id, ImplKind::TraitMethod(*method_id, constraint, false))
             }

compiler/noirc_frontend/src/hir_def/traits.rs

@@ -16,6 +16,7 @@ pub struct TraitFunction {
     pub location: Location,
     pub default_impl: Option<Box<NoirFunction>>,
     pub default_impl_module_id: crate::hir::def_map::LocalModuleId,
+    pub trait_constraints: Vec<TraitConstraint>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -82,16 +83,17 @@ pub struct TraitImpl {
     pub where_clause: Vec<TraitConstraint>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TraitConstraint {
     pub typ: Type,
     pub trait_id: TraitId,
     pub trait_generics: Vec<Type>,
+    pub span: Span,
 }
 
 impl TraitConstraint {
-    pub fn new(typ: Type, trait_id: TraitId, trait_generics: Vec<Type>) -> Self {
-        Self { typ, trait_id, trait_generics }
+    pub fn new(typ: Type, trait_id: TraitId, trait_generics: Vec<Type>, span: Span) -> Self {
+        Self { typ, trait_id, trait_generics, span }
     }
 
     pub fn apply_bindings(&mut self, type_bindings: &TypeBindings) {

compiler/noirc_frontend/src/node_interner.rs

@@ -1370,8 +1370,14 @@ impl NodeInterner {
         type_bindings: &mut TypeBindings,
         recursion_limit: u32,
     ) -> Result<TraitImplKind, Vec<TraitConstraint>> {
-        let make_constraint =
-            || TraitConstraint::new(object_type.clone(), trait_id, trait_generics.to_vec());
+        let make_constraint = || {
+            TraitConstraint::new(
+                object_type.clone(),
+                trait_id,
+                trait_generics.to_vec(),
+                Span::default(),
+            )
+        };
 
         // Prevent infinite recursion when looking for impls
         if recursion_limit == 0 {

compiler/noirc_frontend/src/tests.rs

@@ -1897,6 +1897,99 @@ fn quote_code_fragments() {
     assert!(matches!(&errors[0].0, CompilationError::InterpreterError(FailingConstraint { .. })));
 }
 
+#[test]
+fn impl_stricter_than_trait() {
+    // This test ensures that the error we get from the where clause on the trait impl method
+    // is a `DefCollectorErrorKind::ImplIsStricterThanTrait` error.
+    let src = r#"
+    trait Serialize<let N: u32> {
+        fn serialize(self) -> [Field; N];
+    }
+
+    trait ToField {
+        fn to_field(self) -> Field;
+    }
+
+    fn process_array<let N: u32>(array: [Field; N]) -> Field {
+        array[0]
+    }
+
+    fn serialize_thing<A, let N: u32>(thing: A) -> [Field; N] where A: Serialize<N> {
+        thing.serialize()
+    }
+
+    struct MyType<T> {
+        a: T,
+        b: T,
+    }
+
+    impl<T> Serialize<2> for MyType<T> {
+        fn serialize(self) -> [Field; 2] where T: ToField {
+            [ self.a.to_field(), self.b.to_field() ]
+        }
+    }
+
+    impl<T> MyType<T> {
+        fn do_thing_with_serialization_with_extra_steps(self) -> Field {
+            process_array(serialize_thing(self))
+        }
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        &errors[0].0,
+        CompilationError::DefinitionError(DefCollectorErrorKind::ImplIsStricterThanTrait { .. })
+    ));
+}
+
+#[test]
+fn impl_not_found_for_inner_impl() {
+    // We want to guarantee that we get a no impl found error
+    let src = r#"
+    trait Serialize<let N: u32> {
+        fn serialize(self) -> [Field; N];
+    }
+
+    trait ToField {
+        fn to_field(self) -> Field;
+    }
+
+    fn process_array<let N: u32>(array: [Field; N]) -> Field {
+        array[0]
+    }
+
+    fn serialize_thing<A, let N: u32>(thing: A) -> [Field; N] where A: Serialize<N> {
+        thing.serialize()
+    }
+
+    struct MyType<T> {
+        a: T,
+        b: T,
+    }
+
+    impl<T> Serialize<2> for MyType<T> where T: ToField {
+        fn serialize(self) -> [Field; 2] {
+            [ self.a.to_field(), self.b.to_field() ]
+        }
+    }
+
+    impl<T> MyType<T> {
+        fn do_thing_with_serialization_with_extra_steps(self) -> Field {
+            process_array(serialize_thing(self))
+        }
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        &errors[0].0,
+        CompilationError::TypeError(TypeCheckError::NoMatchingImplFound { .. })
+    ));
+}
+
 // Regression for #5388
 #[test]
 fn comptime_let() {

test_programs/compile_failure/impl_stricter_than_trait/Nargo.toml

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