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

compiler/noirc_frontend/src/elaborator/expressions.rs

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

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -571,7 +571,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
@@ -875,7 +875,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);
@@ -885,12 +892,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 {
@@ -1025,6 +1026,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;
@@ -1081,6 +1083,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 error about a
+                        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

@@ -513,7 +513,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.trait_constraints.push((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

@@ -399,6 +399,7 @@ impl<'context> Elaborator<'context> {
                         generic.type_var.clone()
                     })),
                     trait_id,
+                    span: path.span(),
                 };
 
                 return Some((method, constraint, false));
@@ -433,6 +434,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

@@ -178,6 +178,7 @@
             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);
@@ -518,7 +519,7 @@
                         }
                     }
                     TraitItem::Type { name } => {
                         // TODO(nickysn or alexvitkov): implement context.def_interner.push_empty_type_alias and get an id, instead of using TypeAliasId::dummy_id()
                         if let Err((first_def, second_def)) = self.def_collector.def_map.modules
                             [trait_id.0.local_id.0]
                             .declare_type_alias(name.clone(), TypeAliasId::dummy_id())

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

@@ -68,6 +68,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.
@@ -239,6 +247,19 @@ 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 constraint_name = &constraint_name.0.contents;
+                // let bound_name = bound_name;
+
+                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_note(message)
+                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

@@ -180,6 +180,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

@@ -163,6 +163,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

@@ -7,7 +7,7 @@
 use iter_extended::vecmap;
 use noirc_arena::{Arena, Index};
 use noirc_errors::{Location, Span, Spanned};
 use petgraph::algo::tarjan_scc;
 use petgraph::prelude::DiGraph;
 use petgraph::prelude::NodeIndex as PetGraphIndex;
 
@@ -1277,8 +1277,14 @@
         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 {