This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new eddb661cf3 fix: report origins for duplicate @Named bindings in map 
injection (#13770)
eddb661cf3 is described below

commit eddb661cf3cc6201448fc604df18c915690b95b4
Author: Abhinav <[email protected]>
AuthorDate: Wed Nov 4 14:13:03 2026 +0530

    fix: report origins for duplicate @Named bindings in map injection (#13770)
    
    Fixes #13752.
    
    Map injection collected bindings with Collectors.toMap without a merge
    function, so duplicate @Named qualifiers surfaced as the JDK's raw
    "Duplicate key" error showing lambda identities. Collect the bindings
    first and throw a DIException that names the duplicate key and both
    binding origins.
    
    Add a regression test covering duplicate @Named bindings for a
    Map<String, T> injection point.
---
 .../org/apache/maven/di/impl/InjectorImpl.java     | 29 ++++++++++++++++------
 .../org/apache/maven/di/impl/InjectorImplTest.java | 29 ++++++++++++++++++++++
 2 files changed, 51 insertions(+), 7 deletions(-)

diff --git 
a/impl/maven-di/src/main/java/org/apache/maven/di/impl/InjectorImpl.java 
b/impl/maven-di/src/main/java/org/apache/maven/di/impl/InjectorImpl.java
index fce1c24120..c53183642e 100644
--- a/impl/maven-di/src/main/java/org/apache/maven/di/impl/InjectorImpl.java
+++ b/impl/maven-di/src/main/java/org/apache/maven/di/impl/InjectorImpl.java
@@ -291,16 +291,15 @@ public <Q> Supplier<Q> doGetCompiledBinding(Dependency<Q> 
dep) {
             Key<Object> v = key.getTypeParameter(1);
             Set<Binding<Object>> res2 = getBindings(v);
             if (k.getRawType() == String.class && res2 != null) {
-                Map<String, Supplier<Object>> map = res2.stream()
+                Map<String, Binding<Object>> namedBindings = res2.stream()
                         .filter(b -> b.getOriginalKey() == null
                                 || b.getOriginalKey().getQualifier() == null
                                 || b.getOriginalKey().getQualifier() 
instanceof String)
-                        .collect(Collectors.toMap(
-                                b -> (String)
-                                        (b.getOriginalKey() != null
-                                                ? 
b.getOriginalKey().getQualifier()
-                                                : null),
-                                this::compile));
+                        .collect(Collectors.toMap(InjectorImpl::bindingName, b 
-> b, (first, second) -> {
+                            throw duplicateBindings(v, first, second);
+                        }));
+                Map<String, Supplier<Object>> map = 
namedBindings.entrySet().stream()
+                        .collect(Collectors.toMap(Map.Entry::getKey, e -> 
compile(e.getValue())));
                 //noinspection unchecked
                 return () -> (Q) map(map, Supplier::get);
             }
@@ -324,6 +323,22 @@ private static boolean isDefaultBinding(Binding<?> 
binding) {
         return qualifier == null || "".equals(qualifier);
     }
 
+    private static String bindingName(Binding<?> binding) {
+        return binding.getOriginalKey() != null
+                ? (String) binding.getOriginalKey().getQualifier()
+                : null;
+    }
+
+    private static DIException duplicateBindings(Key<?> valueKey, Binding<?> 
first, Binding<?> second) {
+        Object qualifier =
+                first.getOriginalKey() != null ? 
first.getOriginalKey().getQualifier() : null;
+        Key<?> duplicateKey = qualifier != null ? 
Key.ofType(valueKey.getType(), qualifier) : valueKey;
+        return new DIException("Duplicate bindings for key " + 
duplicateKey.getDisplayString() + ":\n"
+                + " - " + first
+                + "\n - " + second
+                + "\nRemove one of the conflicting bindings or use distinct 
@Named qualifiers.");
+    }
+
     @SuppressWarnings("unchecked")
     protected <Q> Supplier<Q> compile(Binding<Q> binding) {
         Supplier<Q> compiled = binding.compile(this::getCompiledBinding);
diff --git 
a/impl/maven-di/src/test/java/org/apache/maven/di/impl/InjectorImplTest.java 
b/impl/maven-di/src/test/java/org/apache/maven/di/impl/InjectorImplTest.java
index 91ff4d8127..bc4dc5c2b6 100644
--- a/impl/maven-di/src/test/java/org/apache/maven/di/impl/InjectorImplTest.java
+++ b/impl/maven-di/src/test/java/org/apache/maven/di/impl/InjectorImplTest.java
@@ -347,6 +347,35 @@ static class MyMojo {
         }
     }
 
+    @Test
+    void duplicateNamedBindingsInMapReportBothOrigins() {
+        Injector injector = Injector.create()
+                .bindImplicit(DuplicateNamedBindings.FirstDispatcher.class)
+                .bindImplicit(DuplicateNamedBindings.SecondDispatcher.class);
+
+        DIException exception = assertThrows(
+                DIException.class,
+                () -> injector.getInstance(new Key<Map<String, 
DuplicateNamedBindings.Dispatcher>>() {}));
+
+        String message = exception.getMessage();
+        assertTrue(message.contains("@Named(\"legacy\")"), message);
+        assertTrue(message.contains("FirstDispatcher"), message);
+        assertTrue(message.contains("SecondDispatcher"), message);
+        assertTrue(message.contains("FirstDispatcher()"), message);
+        assertTrue(message.contains("SecondDispatcher()"), message);
+    }
+
+    static class DuplicateNamedBindings {
+
+        interface Dispatcher {}
+
+        @Named("legacy")
+        static class FirstDispatcher implements Dispatcher {}
+
+        @Named("legacy")
+        static class SecondDispatcher implements Dispatcher {}
+    }
+
     @Test
     void testSingleton() {
         Injector injector = Injector.create()

Reply via email to