remove unnecessary part and add a test for inner class

Author: guanchengang

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

@@ -199,7 +199,7 @@ private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<
         for (int i = 0; i < parentTypeVars.length; i++) {
           if (typeVar.equals(parentTypeVars[i])) {
             Type actualType = parentAsType.getActualTypeArguments()[i];
-            return actualType instanceof TypeVariable<?> ? ((TypeVariable<?>) actualType).getBounds()[0] : actualType;
+            return actualType instanceof TypeVariable<?> ? Object.class : actualType;
           }
         }
       }
@@ -231,37 +231,9 @@ private static ParameterizedType translateParentTypeVars(ParameterizedType srcTy
         newParentArgs[i] = parentTypeArgs[i];
       }
     }
-    if (noChange && !(parentType instanceof ParameterizedTypeImpl))
-      noChange = false;
-    return noChange ? parentType
-        : new ParameterizedTypeImpl((Class<?>) parentType.getRawType(), parentType.getOwnerType(), newParentArgs);
-  }
-
-  private static Type canonicalize(Type type) {
-    if (type instanceof ParameterizedType) {
-      ParameterizedType p = (ParameterizedType) type;
-      return new ParameterizedTypeImpl((Class<?>) p.getRawType(), p.getOwnerType(), p.getActualTypeArguments());
-    } else if (type instanceof GenericArrayType) {
-      GenericArrayType g = (GenericArrayType) type;
-      return new GenericArrayTypeImpl(g.getGenericComponentType());
-    } else if (type instanceof WildcardType) {
-      WildcardType w = (WildcardType) type;
-      return new WildcardTypeImpl(w.getLowerBounds(), w.getUpperBounds());
-    } else {
-      return type;
-    }
-  }
-
-  private static Type[] canonicalizeTypes(Type[] types) {
-    if (types == null || types.length == 0) {
-      return new Type[0];
-    }
-    int length = types.length;
-    Type[] canonicalizedTypes = new Type[length];
-    for (int i = 0; i < length; i++) {
-      canonicalizedTypes[i] = canonicalize(types[i]);
-    }
-    return canonicalizedTypes;
+    return noChange
+      ? parentType
+      : new ParameterizedTypeImpl((Class<?>) parentType.getRawType(), parentType.getOwnerType(), newParentArgs);
   }
 
   private TypeParameterResolver() {
@@ -277,9 +249,9 @@ static class ParameterizedTypeImpl implements ParameterizedType {
 
     ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) {
       super();
-      this.rawType = (Class<?>) canonicalize(rawType);
-      this.ownerType = canonicalize(ownerType);
-      this.actualTypeArguments = canonicalizeTypes(actualTypeArguments);
+      this.rawType = rawType;
+      this.ownerType = ownerType;
+      this.actualTypeArguments = actualTypeArguments;
     }
 
     @Override
@@ -317,23 +289,22 @@ public String toString() {
       StringBuilder s = new StringBuilder();
       if (ownerType != null) {
         s.append(ownerType.getTypeName()).append("$");
-        if (ownerType instanceof ParameterizedTypeImpl) {
-          // remove prefixes that do not contain generic information
-          s.append(rawType.getName().replace(((ParameterizedTypeImpl) ownerType).rawType.getName() + "$", ""));
-        } else {
-          s.append(rawType.getSimpleName());
-        }
+        s.append(rawType.getSimpleName());
       } else {
         s.append(rawType.getName());
       }
-      s.append("<");
-      for (int i = 0; i < actualTypeArguments.length; i++) {
-        if (i > 0) {
-          s.append(", ");
+      int argLength = actualTypeArguments.length;
+      if (argLength > 0) {
+        s.append("<");
+        for (int i = 0; i < argLength; i++) {
+          if (i > 0) {
+            s.append(", ");
+          }
+          s.append(actualTypeArguments[i].getTypeName());
         }
-        s.append(actualTypeArguments[i].getTypeName());
+        s.append(">");
       }
-      return s.append(">").toString();
+      return s.toString();
     }
   }
 
@@ -344,8 +315,8 @@ static class WildcardTypeImpl implements WildcardType {
 
     WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {
       super();
-      this.lowerBounds = canonicalizeTypes(lowerBounds);
-      this.upperBounds = canonicalizeTypes(upperBounds);
+      this.lowerBounds = lowerBounds;
+      this.upperBounds = upperBounds;
     }
 
     @Override
@@ -396,7 +367,7 @@ static class GenericArrayTypeImpl implements GenericArrayType {
 
     GenericArrayTypeImpl(Type genericComponentType) {
       super();
-      this.genericComponentType = canonicalize(genericComponentType);
+      this.genericComponentType = genericComponentType;
     }
 
     @Override

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

@@ -18,7 +18,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
@@ -514,41 +513,6 @@ void shouldResolveInterfaceTypeParamsDeeper() {
     assertEquals(String.class, types[0]);
   }
 
-  @Test
-  void shouldResolveWildcardTypeInClassDefinition() throws Exception {
-    class A<T extends Serializable> {
-      public T foo(T t) {
-        return t;
-      }
-    }
-
-    class B<T extends Number> extends A<T> {
-
-    }
-
-    class C1<T extends Integer> extends B<T> {
-
-    }
-
-    class C2 extends B<Integer> {
-
-    }
-
-    class C3 extends B {
-
-    }
-
-    Method m = A.class.getMethod("foo", Serializable.class);
-
-    assertEquals(Integer.class, TypeParameterResolver.resolveReturnType(m, C1.class));
-    assertEquals(Integer.class, TypeParameterResolver.resolveReturnType(m, C2.class));
-    assertEquals(Number.class, TypeParameterResolver.resolveReturnType(m, C3.class));
-
-    assertEquals(Integer.class, TypeParameterResolver.resolveParamTypes(m, C1.class)[0]);
-    assertEquals(Integer.class, TypeParameterResolver.resolveParamTypes(m, C2.class)[0]);
-    assertEquals(Number.class, TypeParameterResolver.resolveParamTypes(m, C3.class)[0]);
-  }
-
   class AA {
   }
 
@@ -615,4 +579,48 @@ void shouldNestedParamTypeToStringOmitCommonFqn() throws Exception {
     assertEquals("java.util.Map<java.util.Map$Entry<java.lang.String, java.lang.Integer>, java.util.Date>",
         type.toString());
   }
+
+  static class Outer<T> {
+
+    class Inner {
+    }
+
+    public Inner foo() {
+      return null;
+    }
+
+  }
+
+  static class InnerTester {
+
+    public Outer<?>.Inner noTypeOuter() {
+      return null;
+    }
+
+    public Outer<String>.Inner stringTypeOuter() {
+      return null;
+    }
+
+  }
+
+  @Test
+  void shouldToStringHandleInnerClass() throws Exception {
+    Class<?> outerClass = Outer.class;
+    Class<?> innerTesterClass = InnerTester.class;
+    Method foo = outerClass.getMethod("foo");
+    Method noTypeOuter = innerTesterClass.getMethod("noTypeOuter");
+    Method stringTypeOuter = innerTesterClass.getMethod("stringTypeOuter");
+
+    Type fooReturnType = TypeParameterResolver.resolveReturnType(foo, outerClass);
+    Type noTypeOuterReturnType = TypeParameterResolver.resolveReturnType(noTypeOuter, innerTesterClass);
+    Type stringTypeOuterReturnType = TypeParameterResolver.resolveReturnType(stringTypeOuter, innerTesterClass);
+
+    assertEquals("org.apache.ibatis.reflection.TypeParameterResolverTest$Outer<T>$Inner",
+      fooReturnType.toString());
+    assertEquals("org.apache.ibatis.reflection.TypeParameterResolverTest$Outer<?>$Inner",
+      noTypeOuterReturnType.toString());
+    assertEquals("org.apache.ibatis.reflection.TypeParameterResolverTest$Outer<java.lang.String>$Inner",
+      stringTypeOuterReturnType.toString());
+  }
+
 }