Improve error message

Author: asterite

compiler/noirc_frontend/src/elaborator/path_resolution.rs

@@ -946,18 +946,46 @@ impl Elaborator<'_> {
                 Some(Ok(PathResolutionItem::TraitConstant(type_id, *trait_id, *def_id)))
             }
             _ => {
-                // Multiple matching constants - ambiguous. Multiple impls of the same
-                // generic trait can produce duplicate trait names here, so dedupe.
-                let mut traits = vecmap(&in_scope, |(_, trait_id, _)| {
-                    let trait_ = self.interner.get_trait(*trait_id);
-                    self.fully_qualified_trait_path(trait_)
-                });
-                traits.sort();
-                traits.dedup();
-                Some(Err(PathResolutionError::MultipleTraitsInScope {
-                    ident: ident.clone(),
-                    traits,
-                }))
+                // Multiple matching constants - ambiguous. If all candidates are from the
+                // same trait, this is multiple impls of one trait — report it with the
+                // specific impl signatures so the user can see what to disambiguate.
+                let first_trait_id = in_scope[0].1;
+                let same_trait =
+                    in_scope.iter().all(|(_, trait_id, _)| *trait_id == first_trait_id);
+                if same_trait {
+                    let trait_name =
+                        self.fully_qualified_trait_path(self.interner.get_trait(first_trait_id));
+                    let type_name = self_type.to_string();
+                    let impls = vecmap(&in_scope, |(_, _, impl_id)| {
+                        let ordered = &self.interner.get_trait_generics_for_impl(*impl_id).ordered;
+                        let signature = if ordered.is_empty() {
+                            trait_name.clone()
+                        } else {
+                            let args = vecmap(ordered, |t| t.to_string()).join(", ");
+                            format!("{trait_name}<{args}>")
+                        };
+                        let location =
+                            self.interner.get_trait_implementation(*impl_id).borrow().location;
+                        (signature, location)
+                    });
+                    Some(Err(PathResolutionError::MultipleApplicableImpls {
+                        ident: ident.clone(),
+                        trait_name,
+                        type_name,
+                        impls,
+                    }))
+                } else {
+                    let mut traits = vecmap(&in_scope, |(_, trait_id, _)| {
+                        let trait_ = self.interner.get_trait(*trait_id);
+                        self.fully_qualified_trait_path(trait_)
+                    });
+                    traits.sort();
+                    traits.dedup();
+                    Some(Err(PathResolutionError::MultipleTraitsInScope {
+                        ident: ident.clone(),
+                        traits,
+                    }))
+                }
             }
         }
     }

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

@@ -61,6 +61,13 @@ pub enum PathResolutionError {
     UnresolvedWithPossibleTraitsToImport { ident: Ident, traits: Vec<String> },
     #[error("Multiple applicable items in scope")]
     MultipleTraitsInScope { ident: Ident, traits: Vec<String> },
+    #[error("Multiple `impl`s of `{trait_name}` apply to `{type_name}`")]
+    MultipleApplicableImpls {
+        ident: Ident,
+        trait_name: String,
+        type_name: String,
+        impls: Vec<(String, Location)>,
+    },
     #[error("No function named '{ident}' found for '{typ}' in the current scope")]
     UnresolvedMethodForType { typ: String, ident: Ident, available_impls: Vec<String> },
 }
@@ -75,6 +82,7 @@ impl PathResolutionError {
             | PathResolutionError::NotAModule { ident, .. }
             | PathResolutionError::TraitMethodNotInScope { ident, .. }
             | PathResolutionError::MultipleTraitsInScope { ident, .. }
+            | PathResolutionError::MultipleApplicableImpls { ident, .. }
             | PathResolutionError::UnresolvedWithPossibleTraitsToImport { ident, .. }
             | PathResolutionError::UnresolvedMethodForType { ident, .. } => ident.location(),
         }
@@ -142,6 +150,17 @@ impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
                     ident.location(),
                 )
             }
+            PathResolutionError::MultipleApplicableImpls { ident, impls, .. } => {
+                let mut diag = CustomDiagnostic::simple_error(
+                    error.to_string(),
+                    String::new(),
+                    ident.location(),
+                );
+                for (signature, location) in impls {
+                    diag.add_secondary(format!("candidate `{signature}` defined here"), *location);
+                }
+                diag
+            }
             PathResolutionError::UnresolvedMethodForType { typ: _, ident, available_impls } => {
                 let secondary = if available_impls.is_empty() {
                     String::new()

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

@@ -2172,17 +2172,18 @@ fn associated_constant_shorthand_on_generic_trait_is_ambiguous_with_multiple_imp
     pub struct Bar {}
 
     impl Foo<u8> for Bar {
+                     ~~~ candidate `Foo<u8>` defined here
         let CONST: u32 = 8;
     }
 
     impl Foo<u16> for Bar {
+                      ~~~ candidate `Foo<u16>` defined here
         let CONST: u32 = 16;
     }
 
     fn main() {
         let _: u32 = Bar::CONST;
-                          ^^^^^ Multiple applicable items in scope
-                          ~~~~~ Multiple traits which provide `CONST` are implemented and in scope: `Foo`
+                          ^^^^^ Multiple `impl`s of `Foo` apply to `Bar`
     }
     "#;
     check_errors(src);