Implemented resolveParamTypes() (but it was not necessary to fix #321) and added more test cases.

Author: harawata

src/main/java/org/apache/ibatis/reflection/ParameterizedTypeImpl.java

@@ -19,93 +19,189 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
 
 public class TypeParameterResolver {
 
-  public static Type resolveReturnType(Method method, Type mapper) {
-    Type returnType = method.getGenericReturnType();
+  public static Type[] resolveParamTypes(Method method, Type mapper) {
+    Type[] paramTypes = method.getGenericParameterTypes();
     Class<?> declaringClass = method.getDeclaringClass();
-    return getReturnType(returnType, mapper, declaringClass);
+    Type[] result = new Type[paramTypes.length];
+    for (int i = 0; i < paramTypes.length; i++) {
+      if (paramTypes[i] instanceof Class) {
+        result[i] = paramTypes[i];
+      } else if (paramTypes[i] instanceof TypeVariable) {
+        result[i] = resolveTypeVar((TypeVariable<?>) paramTypes[i], mapper, declaringClass);
+      } else if (paramTypes[i] instanceof ParameterizedType) {
+        result[i] = resolveParameterizedType((ParameterizedType) paramTypes[i], mapper, declaringClass);
+      } else {
+        // TODO: other types?
+      }
+    }
+    return result;
   }
 
-  private static Type getReturnType(Type returnType, Type mapper, Class<?> declaringClass) {
+  public static Type resolveReturnType(Method method, Type mapper) {
+    Type returnType = method.getGenericReturnType();
+    Class<?> declaringClass = method.getDeclaringClass();
     Type result = null;
-    if (returnType instanceof Class) {
-      result = returnType;
-    } else if (returnType instanceof TypeVariable) {
-      if (mapper instanceof Class) {
-        result = resolveTypeVar((TypeVariable<?>) returnType, mapper, declaringClass);
-      }
+    if (returnType instanceof TypeVariable) {
+      result = resolveTypeVar((TypeVariable<?>) returnType, mapper, declaringClass);
     } else if (returnType instanceof ParameterizedType) {
-      result = scanParameterizedType((ParameterizedType) returnType, mapper, declaringClass);
+      result = resolveParameterizedType((ParameterizedType) returnType, mapper, declaringClass);
+    } else {
+      result = returnType;
     }
-    assert result != null;
     return result;
   }
 
-  private static ParameterizedType scanParameterizedType(ParameterizedType parameterizedType, Type mapper, Class<?> declaringClass) {
+  private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type mapper, Class<?> declaringClass) {
     Class<?> rawType = (Class<?>) parameterizedType.getRawType();
     Type[] typeArgs = parameterizedType.getActualTypeArguments();
     Type[] args = new Type[typeArgs.length];
     for (int i = 0; i < typeArgs.length; i++) {
-      if (typeArgs[i] instanceof Class) {
-        args[i] = typeArgs[i];
-      } else if (typeArgs[i] instanceof TypeVariable) {
+      if (typeArgs[i] instanceof TypeVariable) {
         args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], mapper, declaringClass);
       } else if (typeArgs[i] instanceof ParameterizedType) {
-        args[i] = scanParameterizedType((ParameterizedType) typeArgs[i], mapper, declaringClass);
+        args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], mapper, declaringClass);
+      } else if (typeArgs[i] instanceof WildcardType) {
+        args[i] = resolveWildcardType((WildcardType) typeArgs[i], mapper, declaringClass);
+      } else {
+        args[i] = typeArgs[i];
       }
     }
     return new ParameterizedTypeImpl(rawType, null, args);
   }
 
-  private static Type resolveTypeVar(TypeVariable<?> typeVar, Type mapper, Class<?> declaringClass) {
+  private static Type resolveWildcardType(WildcardType wildcardType, Type mapper, Class<?> declaringClass) {
+    Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), mapper, declaringClass);
+    Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), mapper, declaringClass);
+    return new WildcardTypeImpl(lowerBounds, upperBounds);
+  }
+
+  private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type mapper, Class<?> declaringClass) {
+    Type[] result = new Type[bounds.length];
+    for (int i = 0; i < bounds.length; i++) {
+      if (bounds[i] instanceof TypeVariable) {
+        result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], mapper, declaringClass);
+      } else if (bounds[i] instanceof ParameterizedType) {
+        result[i] = resolveParameterizedType((ParameterizedType) bounds[i], mapper, declaringClass);
+      } else if (bounds[i] instanceof WildcardType) {
+        result[i] = resolveWildcardType((WildcardType) bounds[i], mapper, declaringClass);
+      } else {
+        result[i] = bounds[i];
+      }
+    }
+    return result;
+  }
+
+  private static Type resolveTypeVar(TypeVariable<?> typeVar, Type type, Class<?> declaringClass) {
     Type result = null;
-    Class<?> mapperClass = null;
-    if (mapper instanceof Class) {
-      mapperClass = (Class<?>) mapper;
-    } else if (mapper instanceof ParameterizedType) {
-      ParameterizedType parameterizedType = (ParameterizedType) mapper;
-      mapperClass = (Class<?>) parameterizedType.getRawType();
+    Class<?> clazz = null;
+    if (type instanceof Class) {
+      clazz = (Class<?>) type;
+    } else if (type instanceof ParameterizedType) {
+      ParameterizedType parameterizedType = (ParameterizedType) type;
+      clazz = (Class<?>) parameterizedType.getRawType();
     } else {
-      throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + mapper.getClass());
+      throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + type.getClass());
+    }
+
+    if (clazz == declaringClass) {
+      return typeVar;
     }
 
-    Type[] superInterfaces = mapperClass.getGenericInterfaces();
+    Type[] superInterfaces = clazz.getGenericInterfaces();
     for (Type superInterface : superInterfaces) {
-      Class<?> parentAsClass = null;
       if (superInterface instanceof ParameterizedType) {
         ParameterizedType parentAsType = (ParameterizedType) superInterface;
-        parentAsClass = (Class<?>) parentAsType.getRawType();
-        Type[] typeArgs = parentAsType.getActualTypeArguments();
+        Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
         if (declaringClass == parentAsClass) {
+          Type[] typeArgs = parentAsType.getActualTypeArguments();
           TypeVariable<?>[] declaredTypeVars = declaringClass.getTypeParameters();
           for (int i = 0; i < declaredTypeVars.length; i++) {
             if (declaredTypeVars[i] == typeVar) {
               if (typeArgs[i] instanceof TypeVariable) {
-                TypeVariable<?>[] mapperTypeParams = mapperClass.getTypeParameters();
-                for (int j = 0; j < mapperTypeParams.length; j++) {
-                  if (mapperTypeParams[j] == typeArgs[i]) {
-                    result = ((ParameterizedType) mapper).getActualTypeArguments()[j];
+                TypeVariable<?>[] typeParams = clazz.getTypeParameters();
+                for (int j = 0; j < typeParams.length; j++) {
+                  if (typeParams[j] == typeArgs[i]) {
+                    result = ((ParameterizedType) type).getActualTypeArguments()[j];
+                    break;
                   }
                 }
               } else {
                 result = typeArgs[i];
               }
             }
           }
-        } else {
+        } else if (declaringClass.isAssignableFrom(parentAsClass)) {
           result = resolveTypeVar(typeVar, parentAsType, declaringClass);
         }
       } else if (superInterface instanceof Class) {
-        result = resolveTypeVar(typeVar, superInterface, declaringClass);
+        if (declaringClass.isAssignableFrom((Class<?>) superInterface)) {
+          result = resolveTypeVar(typeVar, superInterface, declaringClass);
+        }
       }
     }
-    assert result != null;
+    if (result == null) {
+      return typeVar;
+    }
     return result;
   }
 
   private TypeParameterResolver() {
     super();
   }
+
+  static class ParameterizedTypeImpl implements ParameterizedType {
+    private Class<?> rawType;
+
+    private Type ownerType;
+
+    private Type[] actualTypeArguments;
+
+    public ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) {
+      super();
+      this.rawType = rawType;
+      this.ownerType = ownerType;
+      this.actualTypeArguments = actualTypeArguments;
+    }
+
+    @Override
+    public Type[] getActualTypeArguments() {
+      return actualTypeArguments;
+    }
+
+    @Override
+    public Type getOwnerType() {
+      return ownerType;
+    }
+
+    @Override
+    public Type getRawType() {
+      return rawType;
+    }
+  }
+
+  static class WildcardTypeImpl implements WildcardType {
+    private Type[] lowerBounds;
+
+    private Type[] upperBounds;
+
+    private WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {
+      super();
+      this.lowerBounds = lowerBounds;
+      this.upperBounds = upperBounds;
+    }
+
+    @Override
+    public Type[] getLowerBounds() {
+      return lowerBounds;
+    }
+
+    @Override
+    public Type[] getUpperBounds() {
+      return upperBounds;
+    }
+  }
 }