simplification

Author: carterkozak

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

@@ -9,8 +9,7 @@
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.lang.reflect.WildcardType;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.ArrayList;
 import java.util.Objects;
 
 /**
@@ -57,12 +56,13 @@ static TypeResolutionContext narrowMethodTypeParameters(
             return emptyTypeResCtxt;
         }
 
-        // Construct a mapping from the method type variable names to the types requested by requestedType
+        // Construct TypeBindings based on the requested type, and type variables that occur in the generic return type.
         // For example given requestedType: Foo<String, Int>
-        // and method static <T, U> Foo<T, U> func(Object in)
-        // This produces {T=String, U=Int}.
+        // and method static <T, U> Foo<T, U> func(Bar<T, U> in)
+        // Produces TypeBindings{T=String, U=Int}.
         Type[] methodReturnTypeArguments = parameterizedGenericReturnType.getActualTypeArguments();
-        Map<String, JavaType> bindTargetsByName = new HashMap<>(methodReturnTypeArguments.length);
+        ArrayList<String> names = new ArrayList<>(methodTypeParameters.length);
+        ArrayList<JavaType> types = new ArrayList<>(methodTypeParameters.length);
         for (int j = 0; j < methodReturnTypeArguments.length; j++) {
             Type methodReturnTypeArgument = methodReturnTypeArguments[j];
             // Note: This strictly supports only TypeVariables, not wildcards with nested type variables
@@ -72,43 +72,33 @@ static TypeResolutionContext narrowMethodTypeParameters(
                 if (typeParameterName == null) {
                     return emptyTypeResCtxt;
                 }
-                // If the type parameter name is not present in the method type parameters we
-                // fall back to default type handling.
-                if (!containsName(methodTypeParameters, typeParameterName)) {
-                    return emptyTypeResCtxt;
+
+                // Avoid duplicates
+                if (names.contains(typeParameterName)) {
+                    continue;
                 }
+
                 JavaType bindTarget = requestedType.getBindings().getBoundType(j);
                 if (bindTarget == null) {
                     return emptyTypeResCtxt;
                 }
-                bindTargetsByName.put(typeParameterName, bindTarget);
-            }
-        }
-        boolean appliedAtLeastOneBinding = false;
-        JavaType[] bindings = new JavaType[methodTypeParameters.length];
-        for (int j = 0; j < methodTypeParameters.length; j++) {
-            TypeVariable<Method> methodTypeVariable = methodTypeParameters[j];
-            JavaType typeBindingBasedOnRequest = bindTargetsByName.get(methodTypeVariable.getName());
-            Type[] bounds = methodTypeVariable.getBounds();
-            // Use the propagated type information if it exists, otherwise fall back to bounds provided by the method.
-            if (typeBindingBasedOnRequest == null
-                    // The method level bindings are used if they're narrower than the requested type
-                    || !pessimisticallyValidateBounds(emptyTypeResCtxt, typeBindingBasedOnRequest, bounds)) {
-                if (bounds.length == 1) {
-                    typeBindingBasedOnRequest = emptyTypeResCtxt.resolveType(bounds[0]);
-                } else {
+                // If the type parameter name is not present in the method type parameters we
+                // fall back to default type handling.
+                TypeVariable<?> methodTypeVariable = findByName(methodTypeParameters, typeParameterName);
+                if (methodTypeVariable == null) {
                     return emptyTypeResCtxt;
                 }
-            } else {
-                appliedAtLeastOneBinding = true;
+                if (pessimisticallyValidateBounds(emptyTypeResCtxt, bindTarget, methodTypeVariable.getBounds())) {
+                    names.add(methodTypeVariable.getName());
+                    types.add(bindTarget);
+                }
             }
-            bindings[j] = typeBindingBasedOnRequest;
         }
         // Fall back to default handling if no specific types from the requestedType are used
-        if (!appliedAtLeastOneBinding) {
+        if (names.isEmpty()) {
             return emptyTypeResCtxt;
         }
-        TypeBindings newTypeBindings = TypeBindings.create(candidate, bindings);
+        TypeBindings newTypeBindings = TypeBindings.create(names, types);
         return new TypeResolutionContext.Basic(typeFactory, newTypeBindings);
     }
 
@@ -185,16 +175,16 @@ private static boolean pessimisticallyValidateBound(
         return true;
     }
 
-    private static boolean containsName(TypeVariable<?>[] typeVariables, String name) {
+    private static TypeVariable<?> findByName(TypeVariable<?>[] typeVariables, String name) {
         if (typeVariables == null || name == null) {
-            return false;
+            return null;
         }
         for (TypeVariable<?> typeVariable : typeVariables) {
             if (name.equals(typeVariable.getName())) {
-                return true;
+                return typeVariable;
             }
         }
-        return false;
+        return null;
     }
 
     private MethodGenericTypeResolver() {

src/main/java/com/fasterxml/jackson/databind/type/TypeBindings.java

@@ -142,28 +142,14 @@ public static TypeBindings create(Class<?> erasedType, JavaType typeArg1, JavaTy
     }
 
     /**
-     * Factory method for constructing bindings for given method using specified type parameters.
+     * Factory method for constructing bindings given names and associated types.
      */
-    public static TypeBindings create(Method method, JavaType[] types)
+    public static TypeBindings create(List<String> names, List<JavaType> types)
     {
-        TypeVariable<?>[] vars = method.getTypeParameters();
-        String[] names;
-        if (vars == null || vars.length == 0) {
-            names = NO_STRINGS;
-        } else {
-            int len = vars.length;
-            names = new String[len];
-            for (int i = 0; i < len; ++i) {
-                names[i] = vars[i].getName();
-            }
-        }
-        // Check here to provide a better error message
-        if (names.length != types.length) {
-            throw new IllegalArgumentException("Cannot create TypeBindings for method "
-                    + method.getName() + " with " + types.length + " type parameter"
-                    + ((types.length == 1) ? "" : "s") + ": method expects " + names.length);
+        if (names == null || names.isEmpty() || types == null || types.isEmpty()) {
+            return EMPTY;
         }
-        return new TypeBindings(names, types, null);
+        return new TypeBindings(names.toArray(NO_STRINGS), types.toArray(NO_TYPES), null);
     }
 
     /**