How to use

getTypeParameters

method

in

java.lang.Class

private static ParameterizedType canonicalizeWildcardsInParameterizedType(
  ParameterizedType type) {
 Class<?> rawType = (Class<?>) type.getRawType();
 TypeVariable<?>[] typeVars = rawType.getTypeParameters();
 Type[] typeArgs = type.getActualTypeArguments();
 for (int i = 0; i < typeArgs.length; i++) {
  typeArgs[i] = canonicalizeTypeArg(typeVars[i], typeArgs[i]);
 }
 return Types.newParameterizedTypeWithOwner(type.getOwnerType(), rawType, typeArgs);
}

ParameterizedTypeImpl(@Nullable Type ownerType, Class<?> rawType, Type[] typeArguments) {
 checkNotNull(rawType);
 checkArgument(typeArguments.length == rawType.getTypeParameters().length);
 disallowPrimitiveType(typeArguments, "type parameter");
 this.ownerType = ownerType;
 this.rawType = rawType;
 this.argumentsList = JavaVersion.CURRENT.usedInGenericType(typeArguments);
}

@Override
void visitParameterizedType(ParameterizedType parameterizedType) {
 Class<?> rawClass = (Class<?>) parameterizedType.getRawType();
 TypeVariable<?>[] vars = rawClass.getTypeParameters();
 Type[] typeArgs = parameterizedType.getActualTypeArguments();
 checkState(vars.length == typeArgs.length);
 for (int i = 0; i < vars.length; i++) {
  map(new TypeVariableKey(vars[i]), typeArgs[i]);
 }
 visit(rawClass);
 visit(parameterizedType.getOwnerType());
}

/**
 * If the class is parameterized, such as {@link java.util.ArrayList ArrayList}, this returns
 * {@code ArrayList<E>}.
 */
@Override
Type getGenericReturnType() {
 Class<?> declaringClass = getDeclaringClass();
 TypeVariable<?>[] typeParams = declaringClass.getTypeParameters();
 if (typeParams.length > 0) {
  return Types.newParameterizedType(declaringClass, typeParams);
 } else {
  return declaringClass;
 }
}

private static Type resolveTypeVariable(
  Type context, Class<?> contextRawType, TypeVariable<?> unknown) {
 Class<?> declaredByRaw = declaringClassOf(unknown);
 // We can't reduce this further.
 if (declaredByRaw == null) return unknown;
 Type declaredBy = getGenericSupertype(context, contextRawType, declaredByRaw);
 if (declaredBy instanceof ParameterizedType) {
  int index = indexOf(declaredByRaw.getTypeParameters(), unknown);
  return ((ParameterizedType) declaredBy).getActualTypeArguments()[index];
 }
 return unknown;
}

public void testGenericInterface() {
 // test the 1st generic interface on the class
 Type fType = Supplier.class.getTypeParameters()[0];
 assertEquals(
   Integer.class, TypeToken.of(IntegerStringFunction.class).resolveType(fType).getRawType());
 // test the 2nd generic interface on the class
 Type predicateParameterType = Predicate.class.getTypeParameters()[0];
 assertEquals(
   new TypeToken<List<String>>() {}.getType(),
   TypeToken.of(IntegerStringFunction.class).resolveType(predicateParameterType).getType());
}

public void testGetSupertype_fullyGenericType() {
 ParameterizedType expectedType =
   Types.newParameterizedType(
     Map.class,
     ListMap.class.getTypeParameters()[0],
     Types.newParameterizedType(List.class, ListMap.class.getTypeParameters()[1]));
 assertEquals(expectedType, TypeToken.of(ListMap.class).getSupertype(Map.class).getType());
}

public void testFalseRecursiveType_mappingOnTheSameDeclarationNotUsed() {
 Type returnType =
   genericReturnType(WithFalseRecursiveType.class, "keyShouldNotResolveToStringList");
 TypeToken<?> keyType =
   TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
 assertEquals("java.util.List<V>", keyType.getType().toString());
}

public void testFalseRecursiveType_referenceOfSubtypeDoesNotConfuseMe() {
 Type returnType = genericReturnType(WithFalseRecursiveType.class, "evenSubtypeWorks");
 TypeToken<?> keyType =
   TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
 assertEquals("java.util.List<java.util.List<V>>", keyType.getType().toString());
}

public void testFalseRecursiveType_intermediaryTypeMappingDoesNotConfuseMe() {
 Type returnType =
   genericReturnType(SubtypeOfWithFalseRecursiveType.class, "revertKeyAndValueTypes");
 TypeToken<?> keyType =
   TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
 assertEquals("java.util.List<K1>", keyType.getType().toString());
}

public void testFalseRecursiveType_notRealRecursiveMapping() {
 Type returnType = genericReturnType(WithFalseRecursiveType.class, "shouldNotCauseInfiniteLoop");
 TypeToken<?> keyType =
   TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
 assertEquals("java.util.List<K>", keyType.getType().toString());
}

public void testResolveType_fromWildcard() {
 ParameterizedType withWildcardType =
   (ParameterizedType) new TypeCapture<Comparable<? extends Iterable<String>>>() {}.capture();
 TypeToken<?> wildcardType = TypeToken.of(withWildcardType.getActualTypeArguments()[0]);
 assertEquals(
   String.class, wildcardType.resolveType(Iterable.class.getTypeParameters()[0]).getType());
}

public void testInterfaceTypeParameterResolution() throws Exception {
 assertEquals(
   String.class,
   TypeToken.of(new TypeToken<ArrayList<String>>() {}.getType())
     .resolveType(List.class.getTypeParameters()[0])
     .getType());
}

public <F extends Enum<F> & Function<String, Integer> & Iterable<Long>>
  void testResolveType_fromTypeVariable() {
 TypeToken<?> f = TypeToken.of(new TypeCapture<F>() {}.capture());
 assertEquals(String.class, f.resolveType(Function.class.getTypeParameters()[0]).getType());
 assertEquals(Integer.class, f.resolveType(Function.class.getTypeParameters()[1]).getType());
 assertEquals(Long.class, f.resolveType(Iterable.class.getTypeParameters()[0]).getType());
}

public <E extends Comparable<Iterable<String>> & Iterable<Integer>>
  void testResolveType_fromTypeVariable_onlyDirectBoundsAreUsed() {
 TypeToken<?> e = TypeToken.of(new TypeCapture<E>() {}.capture());
 assertEquals(Integer.class, e.resolveType(Iterable.class.getTypeParameters()[0]).getType());
}

public void testToString() {
 assertEquals(int[].class.getName(), Types.toString(int[].class));
 assertEquals(int[][].class.getName(), Types.toString(int[][].class));
 assertEquals(String[].class.getName(), Types.toString(String[].class));
 Type elementType = List.class.getTypeParameters()[0];
 assertEquals(elementType.toString(), Types.toString(elementType));
}

public void testGetSupertype_withTypeVariable() {
 ParameterizedType expectedType =
   Types.newParameterizedType(
     Iterable.class,
     Types.newParameterizedType(List.class, ListIterable.class.getTypeParameters()[0]));
 assertEquals(
   expectedType, TypeToken.of(ListIterable.class).getSupertype(Iterable.class).getType());
}

public void testGenericArrayType() {
 GenericArray<?> genericArray = new GenericArray<>();
 assertEquals(GenericArray.class.getTypeParameters()[0], genericArray.t);
 assertEquals(Types.newArrayType(genericArray.t), genericArray.array);
}

@SuppressWarnings("rawtypes") // purpose is to test raw type
public void testGetSupertype_fromRawClass() {
 assertEquals(
   Types.newParameterizedType(Iterable.class, List.class.getTypeParameters()[0]),
   new TypeToken<List>() {}.getSupertype(Iterable.class).getType());
}

public void testToGenericType() {
 assertEquals(TypeToken.of(String.class), TypeToken.toGenericType(String.class));
 assertEquals(new TypeToken<int[]>() {}, TypeToken.toGenericType(int[].class));
 @SuppressWarnings("rawtypes") // Iterable.class
 TypeToken<? extends Iterable> genericType = TypeToken.toGenericType(Iterable.class);
 assertEquals(Iterable.class, genericType.getRawType());
 assertEquals(
   Types.newParameterizedType(Iterable.class, Iterable.class.getTypeParameters()[0]),
   genericType.getType());
}