PojoCodec improvents for sub-classes

Pojo Codec fixes with sub-classes and bson creator

This commit tries to fix a few issues:

1. It was not possible to overload a getter in a sub-class and make the
type more specific (covariant overload). For example, attempting to
serialize Bar would fail:

```
  // Assume there are setters here as well...
  class Foo {
    public Number getNumber() { /*...*/ }
  }

  class Bar extends Foo {
    @OverRide
    public Long getNumber() { /*...*/ }
  }
```

This was due to bridge methods not getting picked up, so even though
Method#getDeclaredMethods is documented to return methods only from the
super class, the Java compiler inserts a bridge method in the sub-class
(Bar in this case) for these covariant overrides for legacy interop.

2.a. It was not possible to use a more specific type in a getter, but a
more general type in the setter/constructor/static factory method. For example:

```
class Foo {
  public ImmutableList<String> getNames() { /*...*/ }
  // Mutable class
  public void setNames(List<String> names) { /*...*/ }
  // or immutable class (both didn't work)
  @BsonCreator
  public Foo(@BsonProperty("names") List<String> names) { /*...*/ }
}
```

The first issue was that strict type equality was enforced. This is a
pretty common pattern that should be allowed though - it's typically a
bad idea to accept such a specific class in your constructor/setter.
In my case, I'm creating my domain models with Immutables, so the
generated immutable class will override my getter that returns
`List<T>` to return `ImmutableList<T>`.

The second issue was that various collections were boxed to specific
implementations like ArrayList/HashMap/HashSet. Doing this in TypeData
caused quite a few problems. The main being it was no longer possible to
understand the type hierarchy (ImmutableList does not extend ArrayList,
but it safely implements List). The ArrayList/HashMap/etc selection
happens in collection codec as an implementation detail. I think this is
a bit cleaner.

3. It was not possible to use immutable collections like Guava's
ImmutableList. By fixing the above issues, it works now. Note that we
still can't use ImmutableList as an argument that's accepted, but that's
a case where it's reasonable to provide a custom codec implementation
since there's no way we can do that automatically.

4. @BsonCreator annotations were only searched for in the target class,
but not any super classes. It's relatively common to have an abstract
base class host all of the static factory methods for the concrete
subtypes, so this allows for that pattern. I do the above, but in
addition, some of my domain models are generated through Immutables
where I don't have the ability to inject annotated static factory
methods.

-----

I moved code around a bit for better locality and some re-usability. In
particular with PropertyReflectionUtils, and TypeData having a few
methods of extracting the types out of methods/fields/etc.

I tried to add test cases for all of the above things - they all failed
prior to these modifications. All other existing bson tests pass.

JAVA-2612

Author: jflorencio

bson/src/main/org/bson/codecs/pojo/ConventionAnnotationImpl.java

@@ -27,6 +27,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -111,33 +112,43 @@ private <T> void processCreatorAnnotation(final ClassModelBuilder<T> classModelB
             }
         }
 
-        for (Method method : clazz.getDeclaredMethods()) {
-            if (isStatic(method.getModifiers())) {
-                for (Annotation annotation : method.getDeclaredAnnotations()) {
-                    if (annotation.annotationType().equals(BsonCreator.class)) {
-                        if (creatorExecutable != null) {
-                            throw new CodecConfigurationException("Found multiple constructors / methods annotated with @BsonCreator");
-                        } else if (!clazz.isAssignableFrom(method.getReturnType())) {
-                            throw new CodecConfigurationException(
-                                    format("Invalid method annotated with @BsonCreator. Returns '%s', expected %s", method.getReturnType(),
-                                            clazz));
+        Class<?> bsonCreatorClass = clazz;
+        boolean foundStaticBsonCreatorMethod = false;
+        while (bsonCreatorClass != null && !foundStaticBsonCreatorMethod) {
+            for (Method method : bsonCreatorClass.getDeclaredMethods()) {
+                if (isStatic(method.getModifiers())) {
+                    for (Annotation annotation : method.getDeclaredAnnotations()) {
+                        if (annotation.annotationType().equals(BsonCreator.class)) {
+                            if (creatorExecutable != null) {
+                                throw new CodecConfigurationException("Found multiple constructors / methods annotated with @BsonCreator");
+                            } else if (!bsonCreatorClass.isAssignableFrom(method.getReturnType())) {
+                                throw new CodecConfigurationException(
+                                        format("Invalid method annotated with @BsonCreator. Returns '%s', expected %s",
+                                                method.getReturnType(), bsonCreatorClass));
+                            }
+                            creatorExecutable = new CreatorExecutable<T>(clazz, method);
+                            foundStaticBsonCreatorMethod = true;
+                            break;
                         }
-                        creatorExecutable = new CreatorExecutable<T>(clazz, method);
-                        break;
                     }
                 }
             }
+
+            bsonCreatorClass = bsonCreatorClass.getSuperclass();
         }
 
         if (creatorExecutable != null) {
             List<BsonProperty> properties = creatorExecutable.getProperties();
             List<Class<?>> parameterTypes = creatorExecutable.getParameterTypes();
+            List<Type> parameterGenericTypes = creatorExecutable.getParameterGenericTypes();
+
             if (properties.size() != parameterTypes.size()) {
                 throw creatorExecutable.getError(clazz, "All parameters must be annotated with a @BsonProperty in %s");
             }
             for (int i = 0; i < properties.size(); i++) {
                 boolean isIdProperty = creatorExecutable.getIdPropertyIndex() != null && creatorExecutable.getIdPropertyIndex().equals(i);
                 Class<?> parameterType = parameterTypes.get(i);
+                Type genericType = parameterGenericTypes.get(i);
                 PropertyModelBuilder<?> propertyModelBuilder = null;
 
                 if (isIdProperty) {
@@ -168,6 +179,7 @@ private <T> void processCreatorAnnotation(final ClassModelBuilder<T> classModelB
                     } else {
                         // An existing property is found, set its write name
                         propertyModelBuilder.writeName(bsonProperty.value());
+                        tryToExpandToGenericType(parameterType, propertyModelBuilder, genericType);
                     }
                 }
 
@@ -180,6 +192,17 @@ private <T> void processCreatorAnnotation(final ClassModelBuilder<T> classModelB
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private static <T> void tryToExpandToGenericType(final Class<?> parameterType, final PropertyModelBuilder<T> propertyModelBuilder,
+                                                     final Type genericType) {
+        if (parameterType.isAssignableFrom(propertyModelBuilder.getTypeData().getType())) {
+            // The existing getter for this field returns a more specific type than what the constructor accepts
+            // This is typical when the getter returns a specific subtype, but the constructor accepts a more
+            // general one (e.g.: getter returns ImmutableList<T>, while constructor just accepts List<T>)
+            propertyModelBuilder.typeData(TypeData.newInstance(genericType, (Class<T>) parameterType));
+        }
+    }
+
     private <T, S> PropertyModelBuilder<S> addCreatorPropertyToClassModelBuilder(final ClassModelBuilder<T> classModelBuilder,
                                                                                  final String name,
                                                                                  final Class<S> clazz) {

bson/src/main/org/bson/codecs/pojo/CreatorExecutable.java

@@ -23,6 +23,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -36,6 +37,7 @@ final class CreatorExecutable<T> {
     private final List<BsonProperty> properties = new ArrayList<BsonProperty>();
     private final Integer idPropertyIndex;
     private final List<Class<?>> parameterTypes = new ArrayList<Class<?>>();
+    private final List<Type> parameterGenericTypes = new ArrayList<Type>();
 
     CreatorExecutable(final Class<T> clazz, final Constructor<T> constructor) {
         this(clazz, constructor, null);
@@ -52,7 +54,10 @@ private CreatorExecutable(final Class<T> clazz, final Constructor<T> constructor
         Integer idPropertyIndex = null;
 
         if (constructor != null || method != null) {
-            parameterTypes.addAll(asList(constructor != null ? constructor.getParameterTypes() : method.getParameterTypes()));
+            Class<?>[] paramTypes = constructor != null ? constructor.getParameterTypes() : method.getParameterTypes();
+            Type[] genericParamTypes = constructor != null ? constructor.getGenericParameterTypes() : method.getGenericParameterTypes();
+            parameterTypes.addAll(asList(paramTypes));
+            parameterGenericTypes.addAll(asList(genericParamTypes));
             Annotation[][] parameterAnnotations = constructor != null ? constructor.getParameterAnnotations()
                     : method.getParameterAnnotations();
 
@@ -93,6 +98,10 @@ List<Class<?>> getParameterTypes() {
         return parameterTypes;
     }
 
+    List<Type> getParameterGenericTypes() {
+        return parameterGenericTypes;
+    }
+
     @SuppressWarnings("unchecked")
     T getInstance() {
         checkHasAnExecutable();