test coverage and unlikely edges

Author: carterkozak

src/main/java/com/fasterxml/jackson/databind/introspect/MethodGenericTypeResolver.java

@@ -88,11 +88,6 @@ static TypeBindings bindMethodTypeParameters(
                     return null;
                 }
 
-                // Avoid duplicates
-                if (names.contains(typeParameterName)) {
-                    continue;
-                }
-
                 JavaType bindTarget = requestedType.getBindings().getBoundType(i);
                 if (bindTarget == null) {
                     return null;
@@ -104,8 +99,27 @@ static TypeBindings bindMethodTypeParameters(
                     return null;
                 }
                 if (pessimisticallyValidateBounds(emptyTypeResCtxt, bindTarget, methodTypeVariable.getBounds())) {
-                    names.add(methodTypeVariable.getName());
-                    types.add(bindTarget);
+                    // Avoid duplicate entries for the same type variable, e.g. '<T> Map<T, T> foo(Class<T> in)'
+                    int existingIndex = names.indexOf(typeParameterName);
+                    if (existingIndex != -1) {
+                        JavaType existingBindTarget = types.get(existingIndex);
+                        if (bindTarget.equals(existingBindTarget)) {
+                            continue;
+                        }
+                        boolean existingIsSubtype = existingBindTarget.isTypeOrSubTypeOf(bindTarget.getRawClass());
+                        boolean newIsSubtype = bindTarget.isTypeOrSubTypeOf(existingBindTarget.getRawClass());
+                        if (!existingIsSubtype && !newIsSubtype) {
+                            // No way to satisfy the requested type.
+                            return null;
+                        }
+                        if (existingIsSubtype ^ newIsSubtype && newIsSubtype) {
+                            // If the new type is more specific than the existing type, the new type replaces the old.
+                            types.set(existingIndex, bindTarget);
+                        }
+                    } else {
+                        names.add(typeParameterName);
+                        types.add(bindTarget);
+                    }
                 }
             }
         }

src/test/java/com/fasterxml/jackson/databind/introspect/MethodGenericTypeResolverTest.java

@@ -1,5 +1,6 @@
 package com.fasterxml.jackson.databind.introspect;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.type.TypeBindings;
@@ -46,6 +47,26 @@ public static <A, B> Map<A, B> multipleTypeVariables(Map<A, B> input) {
         throw new UnsupportedOperationException();
     }
 
+    public static class StubA {
+        private final String value;
+
+        @JsonCreator
+        private StubA(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    public static class StubB extends StubA {
+        @JsonCreator
+        public StubB(String value) {
+            super(value);
+        }
+    }
+
     @Test
     public void testWithoutGenerics() {
         TypeBindings bindings = MethodGenericTypeResolver.bindMethodTypeParameters(
@@ -84,6 +105,21 @@ public void testWithRepeatedGenericInReturn() {
         assertThat(asMap(bindings)).isEqualTo(asMap("T", type(String.class)));
     }
 
+    @Test
+    public void testWithRepeatedGenericInReturnWithIncreasingSpecificity() {
+        Method method = method("mapWithSameKeysAndValues");
+        TypeBindings bindingsAb = MethodGenericTypeResolver.bindMethodTypeParameters(
+                method, type(new TypeReference<Map<StubA, StubB>>() {
+                }), EMPTY_CONTEXT);
+        TypeBindings bindingsBa = MethodGenericTypeResolver.bindMethodTypeParameters(
+                method, type(new TypeReference<Map<StubB, StubA>>() {
+                }), EMPTY_CONTEXT);
+        assertThat(asMap(bindingsAb))
+                .as("Order of parameters shouldn't impact the result")
+                .isEqualTo(asMap(bindingsBa))
+                .isEqualTo(asMap("T", type(StubB.class)));
+    }
+
     @Test
     public void testMultipleTypeVariables() {
         TypeBindings bindings = MethodGenericTypeResolver.bindMethodTypeParameters(