Do not use NamedGeneric

Author: aakoshh

compiler/noirc_frontend/src/elaborator/traits.rs

@@ -616,7 +616,7 @@ impl Elaborator<'_> {
                 }
 
                 let parent_trait_bound =
-                    self.instantiate_parent_trait_bound(object, trait_bound, &parent_trait_bound);
+                    self.instantiate_parent_trait_bound(trait_bound, &parent_trait_bound);
                 self.add_trait_bound_to_scope(
                     location,
                     object,

compiler/noirc_frontend/src/elaborator/types.rs

@@ -2295,7 +2295,6 @@ impl Elaborator<'_> {
                 let the_trait = self.interner.get_trait(trait_id);
                 let constraint = the_trait.as_constraint(the_trait.name.location());
                 let mut matches = self.lookup_methods_in_trait(
-                    object_type,
                     the_trait,
                     method_name,
                     &constraint.trait_bound,
@@ -2332,7 +2331,6 @@ impl Elaborator<'_> {
                     self.interner.try_get_trait(constraint.trait_bound.trait_id)
                 {
                     let trait_matches = self.lookup_methods_in_trait(
-                        object_type,
                         the_trait,
                         method_name,
                         &constraint.trait_bound,
@@ -2394,7 +2392,6 @@ impl Elaborator<'_> {
     /// a child and its parent.
     fn lookup_methods_in_trait(
         &self,
-        object: &Type,
         the_trait: &Trait,
         method_name: &str,
         trait_bound: &ResolvedTraitBound,
@@ -2423,9 +2420,8 @@ impl Elaborator<'_> {
                 }
 
                 let parent_trait_bound =
-                    self.instantiate_parent_trait_bound(object, trait_bound, parent_trait_bound);
+                    self.instantiate_parent_trait_bound(trait_bound, parent_trait_bound);
                 let parent_matches = self.lookup_methods_in_trait(
-                    object,
                     the_trait,
                     method_name,
                     &parent_trait_bound,
@@ -2659,12 +2655,11 @@ impl Elaborator<'_> {
     /// type to whatever type the constraint is defined on.
     pub fn bind_generics_from_trait_constraint(
         &self,
-        object: &Type,
         constraint: &TraitConstraint,
         assumed: bool,
         bindings: &mut TypeBindings,
     ) {
-        self.bind_generics_from_trait_bound(object, &constraint.trait_bound, bindings);
+        self.bind_generics_from_trait_bound(&constraint.trait_bound, bindings);
 
         // If the trait impl is already assumed to exist we should add any type bindings for `Self`.
         // Otherwise `self` will be replaced with a fresh type variable, which will require the user
@@ -2680,35 +2675,24 @@ impl Elaborator<'_> {
     /// Insert the ordered generics and associated types from the trait bound.
     pub fn bind_generics_from_trait_bound(
         &self,
-        object: &Type,
         trait_bound: &ResolvedTraitBound,
         bindings: &mut TypeBindings,
     ) {
         let the_trait = self.interner.get_trait(trait_bound.trait_id);
 
         bind_ordered_generics(&the_trait.generics, &trait_bound.trait_generics.ordered, bindings);
 
-        let associated_types = vecmap(&the_trait.associated_types, |typ| {
-            let is_const = the_trait.associated_constant_ids.contains_key(typ.name.as_str());
-            (typ.clone(), is_const)
-        });
-        bind_named_generics(
-            object,
-            &the_trait.name,
-            associated_types,
-            &trait_bound.trait_generics.named,
-            bindings,
-        );
+        let associated_types = the_trait.associated_types.clone();
+        bind_named_generics(associated_types, &trait_bound.trait_generics.named, bindings);
     }
 
     pub fn instantiate_parent_trait_bound(
         &self,
-        object: &Type,
         trait_bound: &ResolvedTraitBound,
         parent_trait_bound: &ResolvedTraitBound,
     ) -> ResolvedTraitBound {
         let mut bindings = TypeBindings::default();
-        self.bind_generics_from_trait_bound(object, trait_bound, &mut bindings);
+        self.bind_generics_from_trait_bound(trait_bound, &mut bindings);
         ResolvedTraitBound {
             trait_generics: parent_trait_bound.trait_generics.map(|typ| typ.substitute(&bindings)),
             ..*parent_trait_bound
@@ -2795,9 +2779,7 @@ pub(super) fn bind_ordered_generics(
 /// Panics if the number of types exceeds the named generics in the trait.
 /// Any named parameter that does not appear in the arguments is bound to [Type::Error].
 fn bind_named_generics(
-    object: &Type,
-    trait_ident: &Ident,
-    mut params: Vec<(ResolvedGeneric, bool)>,
+    mut params: Vec<ResolvedGeneric>,
     args: &[NamedType],
     bindings: &mut TypeBindings,
 ) {
@@ -2806,34 +2788,19 @@ fn bind_named_generics(
     if params.is_empty() {
         return;
     }
-    let object_name = object.to_string();
-    let trait_name = trait_ident.as_str();
 
     for arg in args {
         let i = params
             .iter()
-            .position(|(typ, _)| *typ.name == arg.name.as_str())
+            .position(|typ| *typ.name == arg.name.as_str())
             .unwrap_or_else(|| unreachable!("Expected to find associated type named {}", arg.name));
 
-        let (param, is_const) = params.swap_remove(i);
+        let param = params.swap_remove(i);
 
-        match &arg.typ {
-            Type::TypeVariable(v) if !is_const && v.borrow().is_unbound() => {
-                // If we allow associated types to bind to a Type::TypeVariable rather than a Type::NamedGeneric,
-                // then they be unified with anything else,
-                // whereas as a NamedGeneric they only unify with the same type variable.
-                let name = Rc::new(arg.name.to_string());
-                let typ = v.clone().into_named_generic(&name, Some((&object_name, trait_name)));
-                bind_generic(&param, &typ, bindings);
-            }
-            _ => {
-                // Other types or associated constants
-                bind_generic(&param, &arg.typ, bindings);
-            }
-        }
+        bind_generic(&param, &arg.typ, bindings);
     }
 
-    for (unbound_param, _) in params {
+    for unbound_param in params {
         bind_generic(&unbound_param, &Type::Error, bindings);
     }
 }

compiler/noirc_frontend/src/elaborator/variable.rs

@@ -576,7 +576,6 @@ impl Elaborator<'_> {
         // the type used in the trait constraint (if it exists). See #4088.
         if let ImplKind::TraitItem(method) = &ident.impl_kind {
             self.bind_generics_from_trait_constraint(
-                &method.constraint.typ,
                 &method.constraint,
                 method.assumed,
                 &mut bindings,

compiler/noirc_frontend/src/tests/traits/trait_inheritance.rs

@@ -213,3 +213,20 @@ fn trait_impl_with_child_constraint() {
     "#;
     assert_no_errors(src);
 }
+
+#[test]
+fn trait_inheritance_with_ambiguous_associated_type() {
+    let src = r#"
+    pub trait Foo {
+        type Bar;
+        fn foo(x: Self::Bar) -> Self::Bar;
+    }
+
+    pub trait Qux: Foo {
+        type Bar;
+        fn qux(x: Self::Bar) -> Self::Bar;
+    }
+    "#;
+    // TODO: Add errors for ambiguous type. But it should work as `<Self as Qux>::Bar`
+    check_errors(src);
+}