fixes #1260 When scanning super types, replace type variables with actual types.

As a side effect, it now returns more accurate result when involving type bounds. See the change in the existing test case.

Author: harawata

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2009-2016 the original author or authors.
+ *    Copyright 2009-2018 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -170,39 +170,48 @@ private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<
   }
 
   private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) {
-    Type result = null;
     if (superclass instanceof ParameterizedType) {
       ParameterizedType parentAsType = (ParameterizedType) superclass;
       Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
+      TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters();
+      if (srcType instanceof ParameterizedType) {
+        parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);
+      }
       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<?>[] typeParams = clazz.getTypeParameters();
-              for (int j = 0; j < typeParams.length; j++) {
-                if (typeParams[j] == typeArgs[i]) {
-                  if (srcType instanceof ParameterizedType) {
-                    result = ((ParameterizedType) srcType).getActualTypeArguments()[j];
-                  }
-                  break;
-                }
-              }
-            } else {
-              result = typeArgs[i];
-            }
+        for (int i = 0; i < parentTypeVars.length; i++) {
+          if (typeVar == parentTypeVars[i]) {
+            return parentAsType.getActualTypeArguments()[i];
           }
         }
-      } else if (declaringClass.isAssignableFrom(parentAsClass)) {
-        result = resolveTypeVar(typeVar, parentAsType, declaringClass);
       }
-    } else if (superclass instanceof Class) {
-      if (declaringClass.isAssignableFrom((Class<?>) superclass)) {
-        result = resolveTypeVar(typeVar, superclass, declaringClass);
+      if (declaringClass.isAssignableFrom(parentAsClass)) {
+        return resolveTypeVar(typeVar, parentAsType, declaringClass);
       }
+    } else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) {
+      return resolveTypeVar(typeVar, superclass, declaringClass);
     }
-    return result;
+    return null;
+  }
+
+  private static ParameterizedType translateParentTypeVars(ParameterizedType srcType, Class<?> srcClass, ParameterizedType parentType) {
+    Type[] parentTypeArgs = parentType.getActualTypeArguments();
+    Type[] srcTypeArgs = srcType.getActualTypeArguments();
+    TypeVariable<?>[] srcTypeVars = srcClass.getTypeParameters();
+    Type[] newParentArgs = new Type[parentTypeArgs.length];
+    boolean noChange = true;
+    for (int i = 0; i < parentTypeArgs.length; i++) {
+      if (parentTypeArgs[i] instanceof TypeVariable) {
+        for (int j = 0; j < srcTypeVars.length; j++) {
+          if (srcTypeVars[j] == parentTypeArgs[i]) {
+            noChange = false;
+            newParentArgs[i] = srcTypeArgs[j];
+          }
+        }
+      } else {
+        newParentArgs[i] = parentTypeArgs[i];
+      }
+    }
+    return noChange ? parentType : new ParameterizedTypeImpl((Class<?>)parentType.getRawType(), null, newParentArgs);
   }
 
   private TypeParameterResolver() {

src/test/java/org/apache/ibatis/reflection/TypeParameterResolverTest.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2009-2016 the original author or authors.
+ *    Copyright 2009-2018 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -135,7 +135,11 @@ public void testReturn_SimpleTypeVar() throws Exception {
     Class<?> clazz = Level1Mapper.class;
     Method method = clazz.getMethod("simpleSelectTypeVar");
     Type result = TypeParameterResolver.resolveReturnType(method, clazz);
-    assertEquals(Object.class, result);
+    assertTrue(result instanceof ParameterizedType);
+    ParameterizedType paramType = (ParameterizedType) result;
+    assertEquals(Calculator.class, paramType.getRawType());
+    assertEquals(1, paramType.getActualTypeArguments().length);
+    assertTrue(paramType.getActualTypeArguments()[0] instanceof WildcardType);
   }
 
   @Test
@@ -402,4 +406,22 @@ public void setKey2(T key2) {
     Method setter2 = clazz.getMethod("setKey2", Key.class);
     assertEquals(Key.class, TypeParameterResolver.resolveParamTypes(setter2, clazz)[0]);
   }
+
+  @Test
+  public void testDeepHierarchy() throws Exception {
+    @SuppressWarnings("unused")
+    abstract class A<S> {
+      protected S id;
+      public S getId() { return this.id;}
+      public void setId(S id) {this.id = id;}
+    }
+    abstract class B<T> extends A<T> {}
+    abstract class C<U> extends B<U> {}
+    class D extends C<Integer> {}
+    Class<?> clazz = D.class;
+    Method method = clazz.getMethod("getId");
+    assertEquals(Integer.class, TypeParameterResolver.resolveReturnType(method, clazz));
+    Field field = A.class.getDeclaredField("id");
+    assertEquals(Integer.class, TypeParameterResolver.resolveFieldType(field, clazz));
+  }
 }