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

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


The following commit(s) were added to refs/heads/maven-4.0.x by this push:
     new 8bf8465c50 fix: report origins for duplicate @Named bindings in map 
injection (#13770) (#13825)
8bf8465c50 is described below

commit 8bf8465c50d236e23d6a6d54fd6d6d2ab4eb270f
Author: Guillaume Nodet <[email protected]>
AuthorDate: Wed Nov 4 15:29:54 2026 +0100

    fix: report origins for duplicate @Named bindings in map injection (#13770) 
(#13825)
    
    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.
    
    Co-authored-by: Abhinav <[email protected]>
---
 .../org/apache/maven/di/impl/InjectorImpl.java     | 29 ++++++++++++++++-----
 .../org/apache/maven/di/impl/InjectorImplTest.java | 30 ++++++++++++++++++++++
 2 files changed, 52 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 b71e3f4e9e..fd4a01866b 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 cef4bf586e..fa28763e70 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,36 @@ 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();
+        assertThat(message)
+                .contains("@Named(\"legacy\")")
+                .contains("FirstDispatcher")
+                .contains("SecondDispatcher")
+                .contains("FirstDispatcher()")
+                .contains("SecondDispatcher()");
+    }
+
+    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