feat(frontend): Where clause on impl (#5320)

# Description

## Problem\*

Resolves #4508 

## Summary\*

This enables the simple functionality of being able to declare a where
clause directly on a struct implementation such as below:
```rust
impl<T> MyStruct<T> where T: MyEq {
    fn my_eq(self, other: Self) -> bool {
        (self.a == other.a) & self.b.my_eq(other.b)
    }
}
```
The code above is essentially syntactic sugar where we now every method
in the struct impl a where clause. As the logic for resolving trait
constraints already exists this PR really just updates the parser to
accept `where` clauses and during definition collection attaches them to
each method in an impl.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>

aztec_macros/src/transforms/events.rs

@@ -83,6 +83,7 @@ pub fn generate_selector_impl(structure: &mut NoirStruct) -> TypeImpl {
         type_span: structure.span,
         generics: vec![],
         methods: vec![(NoirFunction::normal(selector_fn_def), Span::default())],
+        where_clause: vec![],
     }
 }
 

aztec_macros/src/transforms/note_interface.rs

@@ -69,6 +69,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 type_span: note_struct.name.span(),
                 generics: vec![],
                 methods: vec![],
+                where_clause: vec![],
             };
             module.impls.push(default_impl.clone());
             module.impls.last_mut().unwrap()

aztec_macros/src/transforms/storage.rs

@@ -246,6 +246,8 @@ pub fn generate_storage_implementation(
         generics: vec![generic_context_ident],
 
         methods: vec![(init, Span::default())],
+
+        where_clause: vec![],
     };
     module.impls.push(storage_impl);
 

compiler/noirc_frontend/src/ast/traits.rs

@@ -49,6 +49,7 @@ pub struct TypeImpl {
     pub object_type: UnresolvedType,
     pub type_span: Span,
     pub generics: UnresolvedGenerics,
+    pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub methods: Vec<(NoirFunction, Span)>,
 }
 

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

@@ -149,8 +149,9 @@ impl<'a> ModCollector<'a> {
                 self_type: None,
             };
 
-            for (method, _) in r#impl.methods {
+            for (mut method, _) in r#impl.methods {
                 let func_id = context.def_interner.push_empty_fn();
+                method.def.where_clause.extend(r#impl.where_clause.clone());
                 let location = Location::new(method.span(), self.file_id);
                 context.def_interner.push_function(func_id, &method.def, module_id, location);
                 unresolved_functions.push_fn(self.module_id, func_id, method);

compiler/noirc_frontend/src/parser/parser.rs

@@ -225,11 +225,20 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
     keyword(Keyword::Impl)
         .ignore_then(function::generics())
         .then(parse_type().map_with_span(|typ, span| (typ, span)))
+        .then(where_clause())
         .then_ignore(just(Token::LeftBrace))
         .then(spanned(function::function_definition(true)).repeated())
         .then_ignore(just(Token::RightBrace))
-        .map(|((generics, (object_type, type_span)), methods)| {
-            TopLevelStatement::Impl(TypeImpl { generics, object_type, type_span, methods })
+        .map(|args| {
+            let ((other_args, where_clause), methods) = args;
+            let (generics, (object_type, type_span)) = other_args;
+            TopLevelStatement::Impl(TypeImpl {
+                generics,
+                object_type,
+                type_span,
+                where_clause,
+                methods,
+            })
         })
 }
 

docs/docs/noir/concepts/traits.md

@@ -147,7 +147,7 @@ fn main() {
 
 ### Generic Trait Implementations With Where Clauses
 
-Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
 For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
 will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
 For example, here is the implementation for array equality:
@@ -169,6 +169,22 @@ impl<T, N> Eq for [T; N] where T: Eq {
 }
 ```
 
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
 ## Generic Traits
 
 Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in

test_programs/compile_success_empty/impl_where_clause/Nargo.toml

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

test_programs/compile_success_empty/impl_where_clause/src/main.nr

@@ -0,0 +1,34 @@
+struct MyStruct<T> {
+    a: u32,
+    b: T,
+}
+
+struct InnerStruct {
+    a: Field,
+    b: Field,
+}
+
+trait MyEq {
+    fn my_eq(self, other: Self) -> bool;
+}
+
+impl MyEq for InnerStruct {
+    fn my_eq(self, other: InnerStruct) -> bool {
+        (self.a == other.a) & (self.b == other.b)
+    }
+}
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}
+
+fn main() {
+    let inner = InnerStruct { a: 1, b: 2 };
+    let my_struct = MyStruct { a: 5, b: inner };
+    assert(my_struct.my_eq(my_struct));
+
+    let mut my_struct_new = MyStruct { a: 5, b: InnerStruct { a: 10, b: 15 } };
+    assert(my_struct_new.my_eq(my_struct_new));
+}

test_programs/compile_success_empty/impl_with_where_clause/Nargo.toml → test_programs/compile_success_empty/trait_impl_with_where_clause/Nargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "impl_with_where_clause"
+name = "trait_impl_with_where_clause"
 type = "bin"
 authors = [""]
 

tooling/nargo_fmt/src/visitor/item.rs

@@ -188,8 +188,8 @@ impl super::FmtVisitor<'_> {
                         continue;
                     }
 
-                    let slice =
-                        self.slice(self.last_position..impl_.object_type.span.unwrap().end());
+                    let before_brace = self.span_before(span, Token::LeftBrace).start();
+                    let slice = self.slice(self.last_position..before_brace).trim();
                     let after_brace = self.span_after(span, Token::LeftBrace).start();
                     self.last_position = after_brace;
 

tooling/nargo_fmt/tests/expected/impl.nr

@@ -19,3 +19,9 @@ impl MyType {
 impl MyType {
     fn method(self) {}
 }
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}

tooling/nargo_fmt/tests/input/impl.nr

@@ -19,3 +19,9 @@ fn method(self) {}
 impl MyType {
             fn method(self) {}
 }
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}