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()); }