feat: Make generic impls callable

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

@@ -92,6 +92,7 @@
     pub trait_path: Path,
     pub object_type: UnresolvedType,
     pub methods: UnresolvedFunctions,
+    pub generics: UnresolvedGenerics,
 }
 
 #[derive(Clone)]
@@ -529,6 +530,7 @@
         let path_resolver = StandardPathResolver::new(module);
         let file = def_maps[&crate_id].file_id(trait_impl.module_id);
         let mut resolver = Resolver::new(interner, &path_resolver, def_maps, file);
+        resolver.add_generics(&trait_impl.generics);
         let typ = resolver.resolve_type(unresolved_type);
         errors.extend(take_errors(trait_impl.file_id, resolver));
 
@@ -964,24 +966,23 @@
 
         let self_type_span = unresolved_type.span;
 
-        let self_type = {
-            let mut resolver =
-                Resolver::new(interner, &path_resolver, &context.def_maps, trait_impl.file_id);
-            resolver.resolve_type(unresolved_type.clone())
-        };
-
-        let maybe_trait_id = trait_impl.trait_id;
+        let mut resolver =
+            Resolver::new(interner, &path_resolver, &context.def_maps, trait_impl.file_id);
+        resolver.add_generics(&trait_impl.generics);
+        let self_type = resolver.resolve_type(unresolved_type.clone());
+        let generics = resolver.get_generics().to_vec();
 
         let mut impl_methods = resolve_function_set(
             interner,
             crate_id,
             &context.def_maps,
             trait_impl.methods.clone(),
             Some(self_type.clone()),
-            vec![], // TODO
+            generics,
             errors,
         );
 
+        let maybe_trait_id = trait_impl.trait_id;
         if let Some(trait_id) = maybe_trait_id {
             for (_, func) in &impl_methods {
                 interner.set_function_trait(*func, self_type.clone(), trait_id);
@@ -1026,7 +1027,7 @@
     methods
 }
 
 // TODO(vitkov): Move this out of here and into type_check
 fn check_methods_signatures(
     resolver: &mut Resolver,
     impl_methods: &Vec<(FileId, FuncId)>,

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

@@ -160,6 +160,7 @@
                 trait_path: trait_name,
                 methods: unresolved_functions,
                 object_type: trait_impl.object_type,
+                generics: trait_impl.impl_generics,
                 trait_id: None, // will be filled later
             };
 
@@ -381,7 +382,7 @@
                         let modifiers = FunctionModifiers {
                             name: name.to_string(),
                             visibility: crate::FunctionVisibility::Public,
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
                             contract_function_type: None,
@@ -437,7 +438,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
                             [id.0.local_id.0]
                             .declare_type_alias(name.clone(), TypeAliasId::dummy_id())

tooling/nargo_cli/tests/compile_success_empty/trait_generics/src/main.nr

@@ -24,4 +24,22 @@ fn main() {
     // Types matching multiple impls will currently choose 
     // the first matching one instead of erroring
     assert(z.foo() == 32);
+
+    // Ensure we can call a generic impl
+    let x: u8 = 7;
+    let y: i8 = 8;
+    let s2_u8 = S2 { x };
+    let s2_i8 = S2 { x: y };
+    assert(s2_u8.t2().x == 7);
+    assert(s2_i8.t2().x == 8);
+}
+
+trait T2 {
+    fn t2(self) -> Self;
+}
+
+struct S2<T> { x: T }
+
+impl<T> T2 for S2<T> {
+    fn t2(self) -> Self { self }
 }