Parameterized generic validation

Author: carterkozak

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

@@ -132,18 +132,59 @@ private static TypeVariable<?> maybeGetTypeVariable(Type type) {
         return null;
     }
 
-    private static boolean pessimisticallyValidateBounds(TypeResolutionContext context, JavaType boundType, Type[] upperBound) {
+    /* Returns the TypeVariable if it can be extracted, otherwise null. */
+    private static ParameterizedType maybeGetParameterizedType(Type type) {
+        if (type instanceof ParameterizedType) {
+            return (ParameterizedType) type;
+        }
+        // Extract simple type variables from wildcards matching '? extends T'
+        if (type instanceof WildcardType) {
+            WildcardType wildcardType = (WildcardType) type;
+            // Exclude any form of '? super T'
+            if (wildcardType.getLowerBounds().length != 0) {
+                return null;
+            }
+            Type[] upperBounds = wildcardType.getUpperBounds();
+            if (upperBounds.length == 1) {
+                return maybeGetParameterizedType(upperBounds[0]);
+            }
+        }
+        return null;
+    }
+
+    private static boolean pessimisticallyValidateBounds(
+            TypeResolutionContext context, JavaType boundType, Type[] upperBound) {
         for (Type type : upperBound) {
-            // TODO: Additional validation would be helpful here, List<Object> is currently allowed given List<String> bounds.
-            // Ideally we would narrow the requested bound type based on the _primaryType taking the upperBounds of the
-            // method into account.
-            if (!boundType.isTypeOrSubTypeOf(context.resolveType(type).getRawClass())) {
+            if (!pessimisticallyValidateBound(context, boundType, type)) {
                 return false;
             }
         }
         return true;
     }
 
+    private static boolean pessimisticallyValidateBound(
+            TypeResolutionContext context, JavaType boundType, Type type) {
+        if (!boundType.isTypeOrSubTypeOf(context.resolveType(type).getRawClass())) {
+            return false;
+        }
+        ParameterizedType parameterized = maybeGetParameterizedType(type);
+        if (parameterized != null) {
+            Type[] typeArguments = parameterized.getActualTypeArguments();
+            TypeBindings bindings = boundType.getBindings();
+            if (bindings.size() != typeArguments.length) {
+                return false;
+            }
+            for (int i = 0; i < bindings.size(); i++) {
+                JavaType boundTypeBound = bindings.getBoundType(i);
+                Type typeArg = typeArguments[i];
+                if (!pessimisticallyValidateBound(context, boundTypeBound, typeArg)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
     private static boolean containsName(TypeVariable<?>[] typeVariables, String name) {
         if (typeVariables == null || name == null) {
             return false;

src/test/java/com/fasterxml/jackson/databind/ser/GenericTypeSerializationTest.java

@@ -236,12 +236,12 @@ public DD second() {
         }
     }
 
-    public static final class GenericSpecificityWrapperImpl<E, EE> {
+    public static final class GenericSpecificityWrapper0<E, EE> {
 
         private final E first;
         private final EE second;
 
-        GenericSpecificityWrapperImpl(E first, EE second) {
+        GenericSpecificityWrapper0(E first, EE second) {
             this.first = first;
             this.second = second;
         }
@@ -255,8 +255,94 @@ public EE second() {
         }
 
         @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
-        public static <F> GenericSpecificityWrapperImpl<?, F> fromJson(JsonGenericWrapper<Long, F> val) {
-            return new GenericSpecificityWrapperImpl<>(val.first(), val.second());
+        public static <F> GenericSpecificityWrapper0<?, F> fromJson(JsonGenericWrapper<Long, F> val) {
+            return new GenericSpecificityWrapper0<>(val.first(), val.second());
+        }
+    }
+
+    public static final class GenericSpecificityWrapper1<E, EE> {
+
+        private final E first;
+        private final EE second;
+
+        GenericSpecificityWrapper1(E first, EE second) {
+            this.first = first;
+            this.second = second;
+        }
+
+        public E first() {
+            return first;
+        }
+
+        public EE second() {
+            return second;
+        }
+
+        @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+        public static <F extends StringStubSubclass, FF> GenericSpecificityWrapper1<F, FF> fromJson(JsonGenericWrapper<F, FF> val) {
+            return new GenericSpecificityWrapper1<>(val.first(), val.second());
+        }
+    }
+
+    public static class StringStub {
+        private final String value;
+
+        private StringStub(String value) {
+            this.value = value;
+        }
+
+        @JsonCreator
+        public static StringStub valueOf(String value) {
+            return new StringStub(value);
+        }
+    }
+
+    public static class StringStubSubclass extends StringStub {
+
+        private StringStubSubclass(String value) {
+            super(value);
+        }
+
+        @JsonCreator
+        public static StringStubSubclass valueOf(String value) {
+            return new StringStubSubclass(value);
+        }
+    }
+
+    public static final class GenericSpecificityWrapper2<E, EE> {
+
+        private final E first;
+        private final EE second;
+
+        GenericSpecificityWrapper2(E first, EE second) {
+            this.first = first;
+            this.second = second;
+        }
+
+        public E first() {
+            return first;
+        }
+
+        public EE second() {
+            return second;
+        }
+
+        @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+        public static <F extends Stub<StringStubSubclass>, FF> GenericSpecificityWrapper2<F, FF> fromJson(JsonGenericWrapper<F, FF> val) {
+            return new GenericSpecificityWrapper2<>(val.first(), val.second());
+        }
+    }
+
+    public static class Stub<T> {
+        private final T value;
+
+        private Stub(T value) {
+            this.value = value;
+        }
+
+        @JsonCreator
+        public static <T> Stub<T> valueOf(T value) {
+            return new Stub<>(value);
         }
     }
 
@@ -391,17 +477,40 @@ public void testStaticDelegateDeserialization() throws Exception
         assertEquals("str", second);
     }
 
-    public void testStaticDelegateDeserialization_factoryProvidesSpecificity() throws Exception
+    public void testStaticDelegateDeserialization_factoryProvidesSpecificity0() throws Exception
     {
-        GenericSpecificityWrapperImpl<Object, Account> wrapper = MAPPER.readValue(
+        GenericSpecificityWrapper0<Object, Account> wrapper = MAPPER.readValue(
                 "{\"first\":\"1\",\"second\":{\"id\":1,\"name\":\"name\"}}",
-                new TypeReference<GenericSpecificityWrapperImpl<Object, Account>>() {});
+                new TypeReference<GenericSpecificityWrapper0<Object, Account>>() {});
         Object first = wrapper.first();
         assertEquals(Long.valueOf(1L), first);
         Account second = wrapper.second();
         assertEquals(new Account("name", 1L), second);
     }
 
+    public void testStaticDelegateDeserialization_factoryProvidesSpecificity1() throws Exception
+    {
+        GenericSpecificityWrapper1<StringStub, Account> wrapper = MAPPER.readValue(
+                "{\"first\":\"1\",\"second\":{\"id\":1,\"name\":\"name\"}}",
+                new TypeReference<GenericSpecificityWrapper1<StringStub, Account>>() {});
+        StringStub first = wrapper.first();
+        assertEquals("1", first.value);
+        Account second = wrapper.second();
+        assertEquals(new Account("name", 1L), second);
+    }
+
+    public void testStaticDelegateDeserialization_factoryProvidesSpecificity2() throws Exception
+    {
+        GenericSpecificityWrapper2<Stub<Object>, Account> wrapper = MAPPER.readValue(
+                "{\"first\":\"1\",\"second\":{\"id\":1,\"name\":\"name\"}}",
+                new TypeReference<GenericSpecificityWrapper2<Stub<Object>, Account>>() {});
+        Stub<Object> first = wrapper.first();
+        StringStub stringStub = (StringStub) first.value;
+        assertEquals("1", stringStub.value);
+        Account second = wrapper.second();
+        assertEquals(new Account("name", 1L), second);
+    }
+
     public void testStaticDelegateDeserialization_wildcardInResult() throws Exception
     {
         WildcardWrapperImpl<Account, Account> wrapper = MAPPER.readValue(