com.google.common.reflect.TypeResolver Maven / Gradle / Ivy
Show all versions of guava Show documentation
/*
* Copyright (C) 2009 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.common.reflect;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Arrays.asList;
import com.google.common.annotations.Beta;
import com.google.common.base.Joiner;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* An object of this class encapsulates type mappings from type variables. Mappings are established
* with {@link #where} and types are resolved using {@link #resolveType}.
*
* Note that usually type mappings are already implied by the static type hierarchy (for example,
* the {@code E} type variable declared by class {@code List} naturally maps to {@code String} in
* the context of {@code class MyStringList implements List}. In such case, prefer to use
* {@link TypeToken#resolveType} since it's simpler and more type safe. This class should only be
* used when the type mapping isn't implied by the static type hierarchy, but provided through other
* means such as an annotation or external configuration file.
*
* @author Ben Yu
* @since 15.0
*/
@Beta
public final class TypeResolver {
private final TypeTable typeTable;
public TypeResolver() {
this.typeTable = new TypeTable();
}
private TypeResolver(TypeTable typeTable) {
this.typeTable = typeTable;
}
/**
* Returns a resolver that resolves types "covariantly".
*
* For example, when resolving {@code List} in the context of {@code ArrayList}, {@code
* } is covariantly resolved to {@code } such that return type of {@code List::get} is
* {@code }.
*/
static TypeResolver covariantly(Type contextType) {
return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(contextType));
}
/**
* Returns a resolver that resolves types "invariantly".
*
* For example, when resolving {@code List} in the context of {@code ArrayList}, {@code
* } cannot be invariantly resolved to {@code } because otherwise the parameter type of
* {@code List::set} will be {@code } and it'll falsely say any object can be passed into
* {@code ArrayList::set}.
*
* Instead, {@code } will be resolved to a capture in the form of a type variable {@code
* }, effectively preventing {@code set} from accepting any type.
*/
static TypeResolver invariantly(Type contextType) {
Type invariantContext = WildcardCapturer.INSTANCE.capture(contextType);
return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(invariantContext));
}
/**
* Returns a new {@code TypeResolver} with type variables in {@code formal} mapping to types in
* {@code actual}.
*
* For example, if {@code formal} is a {@code TypeVariable T}, and {@code actual} is {@code
* String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
* #resolveType resolve} {@code ParameterizedType List} to {@code List}, and resolve
* {@code Map} to {@code Map} etc. Similarly, {@code formal} and
* {@code actual} can be {@code Map} and {@code Map} respectively, or they
* can be {@code E[]} and {@code String[]} respectively, or even any arbitrary combination
* thereof.
*
* @param formal The type whose type variables or itself is mapped to other type(s). It's almost
* always a bug if {@code formal} isn't a type variable and contains no type variable. Make
* sure you are passing the two parameters in the right order.
* @param actual The type that the formal type variable(s) are mapped to. It can be or contain yet
* other type variables, in which case these type variables will be further resolved if
* corresponding mappings exist in the current {@code TypeResolver} instance.
*/
public TypeResolver where(Type formal, Type actual) {
Map mappings = Maps.newHashMap();
populateTypeMappings(mappings, checkNotNull(formal), checkNotNull(actual));
return where(mappings);
}
/** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
TypeResolver where(Map mappings) {
return new TypeResolver(typeTable.where(mappings));
}
private static void populateTypeMappings(
final Map mappings, final Type from, final Type to) {
if (from.equals(to)) {
return;
}
new TypeVisitor() {
@Override
void visitTypeVariable(TypeVariable typeVariable) {
mappings.put(new TypeVariableKey(typeVariable), to);
}
@Override
void visitWildcardType(WildcardType fromWildcardType) {
if (!(to instanceof WildcardType)) {
return; // okay to say is anything
}
WildcardType toWildcardType = (WildcardType) to;
Type[] fromUpperBounds = fromWildcardType.getUpperBounds();
Type[] toUpperBounds = toWildcardType.getUpperBounds();
Type[] fromLowerBounds = fromWildcardType.getLowerBounds();
Type[] toLowerBounds = toWildcardType.getLowerBounds();
checkArgument(
fromUpperBounds.length == toUpperBounds.length
&& fromLowerBounds.length == toLowerBounds.length,
"Incompatible type: %s vs. %s",
fromWildcardType,
to);
for (int i = 0; i < fromUpperBounds.length; i++) {
populateTypeMappings(mappings, fromUpperBounds[i], toUpperBounds[i]);
}
for (int i = 0; i < fromLowerBounds.length; i++) {
populateTypeMappings(mappings, fromLowerBounds[i], toLowerBounds[i]);
}
}
@Override
void visitParameterizedType(ParameterizedType fromParameterizedType) {
if (to instanceof WildcardType) {
return; // Okay to say Foo is
}
ParameterizedType toParameterizedType = expectArgument(ParameterizedType.class, to);
if (fromParameterizedType.getOwnerType() != null
&& toParameterizedType.getOwnerType() != null) {
populateTypeMappings(
mappings, fromParameterizedType.getOwnerType(), toParameterizedType.getOwnerType());
}
checkArgument(
fromParameterizedType.getRawType().equals(toParameterizedType.getRawType()),
"Inconsistent raw type: %s vs. %s",
fromParameterizedType,
to);
Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
Type[] toArgs = toParameterizedType.getActualTypeArguments();
checkArgument(
fromArgs.length == toArgs.length,
"%s not compatible with %s",
fromParameterizedType,
toParameterizedType);
for (int i = 0; i < fromArgs.length; i++) {
populateTypeMappings(mappings, fromArgs[i], toArgs[i]);
}
}
@Override
void visitGenericArrayType(GenericArrayType fromArrayType) {
if (to instanceof WildcardType) {
return; // Okay to say A[] is
}
Type componentType = Types.getComponentType(to);
checkArgument(componentType != null, "%s is not an array type.", to);
populateTypeMappings(mappings, fromArrayType.getGenericComponentType(), componentType);
}
@Override
void visitClass(Class fromClass) {
if (to instanceof WildcardType) {
return; // Okay to say Foo is
}
// Can't map from a raw class to anything other than itself or a wildcard.
// You can't say "assuming String is Integer".
// And we don't support "assuming String is T"; user has to say "assuming T is String".
throw new IllegalArgumentException("No type mapping from " + fromClass + " to " + to);
}
}.visit(from);
}
/**
* Resolves all type variables in {@code type} and all downstream types and returns a
* corresponding type with type variables resolved.
*/
public Type resolveType(Type type) {
checkNotNull(type);
if (type instanceof TypeVariable) {
return typeTable.resolve((TypeVariable) type);
} else if (type instanceof ParameterizedType) {
return resolveParameterizedType((ParameterizedType) type);
} else if (type instanceof GenericArrayType) {
return resolveGenericArrayType((GenericArrayType) type);
} else if (type instanceof WildcardType) {
return resolveWildcardType((WildcardType) type);
} else {
// if Class, no resolution needed, we are done.
return type;
}
}
Type[] resolveTypesInPlace(Type[] types) {
for (int i = 0; i < types.length; i++) {
types[i] = resolveType(types[i]);
}
return types;
}
private Type[] resolveTypes(Type[] types) {
Type[] result = new Type[types.length];
for (int i = 0; i < types.length; i++) {
result[i] = resolveType(types[i]);
}
return result;
}
private WildcardType resolveWildcardType(WildcardType type) {
Type[] lowerBounds = type.getLowerBounds();
Type[] upperBounds = type.getUpperBounds();
return new Types.WildcardTypeImpl(resolveTypes(lowerBounds), resolveTypes(upperBounds));
}
private Type resolveGenericArrayType(GenericArrayType type) {
Type componentType = type.getGenericComponentType();
Type resolvedComponentType = resolveType(componentType);
return Types.newArrayType(resolvedComponentType);
}
private ParameterizedType resolveParameterizedType(ParameterizedType type) {
Type owner = type.getOwnerType();
Type resolvedOwner = (owner == null) ? null : resolveType(owner);
Type resolvedRawType = resolveType(type.getRawType());
Type[] args = type.getActualTypeArguments();
Type[] resolvedArgs = resolveTypes(args);
return Types.newParameterizedTypeWithOwner(
resolvedOwner, (Class) resolvedRawType, resolvedArgs);
}
private static T expectArgument(Class type, Object arg) {
try {
return type.cast(arg);
} catch (ClassCastException e) {
throw new IllegalArgumentException(arg + " is not a " + type.getSimpleName());
}
}
/** A TypeTable maintains mapping from {@link TypeVariable} to types. */
private static class TypeTable {
private final ImmutableMap map;
TypeTable() {
this.map = ImmutableMap.of();
}
private TypeTable(ImmutableMap map) {
this.map = map;
}
/** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
final TypeTable where(Map mappings) {
ImmutableMap.Builder builder = ImmutableMap.builder();
builder.putAll(map);
for (Entry mapping : mappings.entrySet()) {
TypeVariableKey variable = mapping.getKey();
Type type = mapping.getValue();
checkArgument(!variable.equalsType(type), "Type variable %s bound to itself", variable);
builder.put(variable, type);
}
return new TypeTable(builder.build());
}
final Type resolve(final TypeVariable var) {
final TypeTable unguarded = this;
TypeTable guarded =
new TypeTable() {
@Override
public Type resolveInternal(TypeVariable intermediateVar, TypeTable forDependent) {
if (intermediateVar.getGenericDeclaration().equals(var.getGenericDeclaration())) {
return intermediateVar;
}
return unguarded.resolveInternal(intermediateVar, forDependent);
}
};
return resolveInternal(var, guarded);
}
/**
* Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
* non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
* doesn't try to resolve any type variable on generic declarations that are already being
* resolved.
*
* Should only be called and overridden by {@link #resolve(TypeVariable)}.
*/
Type resolveInternal(TypeVariable var, TypeTable forDependants) {
Type type = map.get(new TypeVariableKey(var));
if (type == null) {
Type[] bounds = var.getBounds();
if (bounds.length == 0) {
return var;
}
Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
/*
* We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
* just one problem: Starting with JDK 7u51, the JDK TypeVariable's equals() method doesn't
* recognize instances of our TypeVariable implementation. This is a problem because users
* compare TypeVariables from the JDK against TypeVariables returned by TypeResolver. To
* work with all JDK versions, TypeResolver must return the appropriate TypeVariable
* implementation in each of the three possible cases:
*
* 1. Prior to JDK 7u51, the JDK TypeVariable implementation interoperates with ours.
* Therefore, we can always create our own TypeVariable.
*
* 2. Starting with JDK 7u51, the JDK TypeVariable implementations does not interoperate
* with ours. Therefore, we have to be careful about whether we create our own TypeVariable:
*
* 2a. If the resolved types are identical to the original types, then we can return the
* original, identical JDK TypeVariable. By doing so, we sidestep the problem entirely.
*
* 2b. If the resolved types are different from the original types, things are trickier. The
* only way to get a TypeVariable instance for the resolved types is to create our own. The
* created TypeVariable will not interoperate with any JDK TypeVariable. But this is OK: We
* don't _want_ our new TypeVariable to be equal to the JDK TypeVariable because it has
* _different bounds_ than the JDK TypeVariable. And it wouldn't make sense for our new
* TypeVariable to be equal to any _other_ JDK TypeVariable, either, because any other JDK
* TypeVariable must have a different declaration or name. The only TypeVariable that our
* new TypeVariable _will_ be equal to is an equivalent TypeVariable that was also created
* by us. And that equality is guaranteed to hold because it doesn't involve the JDK
* TypeVariable implementation at all.
*/
if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY
&& Arrays.equals(bounds, resolvedBounds)) {
return var;
}
return Types.newArtificialTypeVariable(
var.getGenericDeclaration(), var.getName(), resolvedBounds);
}
// in case the type is yet another type variable.
return new TypeResolver(forDependants).resolveType(type);
}
}
private static final class TypeMappingIntrospector extends TypeVisitor {
private final Map mappings = Maps.newHashMap();
/**
* Returns type mappings using type parameters and type arguments found in the generic
* superclass and the super interfaces of {@code contextClass}.
*/
static ImmutableMap getTypeMappings(Type contextType) {
checkNotNull(contextType);
TypeMappingIntrospector introspector = new TypeMappingIntrospector();
introspector.visit(contextType);
return ImmutableMap.copyOf(introspector.mappings);
}
@Override
void visitClass(Class clazz) {
visit(clazz.getGenericSuperclass());
visit(clazz.getGenericInterfaces());
}
@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());
}
@Override
void visitTypeVariable(TypeVariable t) {
visit(t.getBounds());
}
@Override
void visitWildcardType(WildcardType t) {
visit(t.getUpperBounds());
}
private void map(final TypeVariableKey var, final Type arg) {
if (mappings.containsKey(var)) {
// Mapping already established
// This is possible when following both superClass -> enclosingClass
// and enclosingclass -> superClass paths.
// Since we follow the path of superclass first, enclosing second,
// superclass mapping should take precedence.
return;
}
// First, check whether var -> arg forms a cycle
for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
if (var.equalsType(t)) {
// cycle detected, remove the entire cycle from the mapping so that
// each type variable resolves deterministically to itself.
// Otherwise, a F -> T cycle will end up resolving both F and T
// nondeterministically to either F or T.
for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {}
return;
}
}
mappings.put(var, arg);
}
}
// This is needed when resolving types against a context with wildcards
// For example:
// class Holder {
// void set(T data) {...}
// }
// Holder> should *not* resolve the set() method to set(List data).
// Instead, it should create a capture of the wildcard so that set() rejects any List.
private static class WildcardCapturer {
static final WildcardCapturer INSTANCE = new WildcardCapturer();
private final AtomicInteger id;
private WildcardCapturer() {
this(new AtomicInteger());
}
private WildcardCapturer(AtomicInteger id) {
this.id = id;
}
final Type capture(Type type) {
checkNotNull(type);
if (type instanceof Class) {
return type;
}
if (type instanceof TypeVariable) {
return type;
}
if (type instanceof GenericArrayType) {
GenericArrayType arrayType = (GenericArrayType) type;
return Types.newArrayType(
notForTypeVariable().capture(arrayType.getGenericComponentType()));
}
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
Class rawType = (Class) parameterizedType.getRawType();
TypeVariable[] typeVars = rawType.getTypeParameters();
Type[] typeArgs = parameterizedType.getActualTypeArguments();
for (int i = 0; i < typeArgs.length; i++) {
typeArgs[i] = forTypeVariable(typeVars[i]).capture(typeArgs[i]);
}
return Types.newParameterizedTypeWithOwner(
notForTypeVariable().captureNullable(parameterizedType.getOwnerType()),
rawType,
typeArgs);
}
if (type instanceof WildcardType) {
WildcardType wildcardType = (WildcardType) type;
Type[] lowerBounds = wildcardType.getLowerBounds();
if (lowerBounds.length == 0) { // ? extends something changes to capture-of
return captureAsTypeVariable(wildcardType.getUpperBounds());
} else {
// TODO(benyu): handle ? super T somehow.
return type;
}
}
throw new AssertionError("must have been one of the known types");
}
TypeVariable captureAsTypeVariable(Type[] upperBounds) {
String name =
"capture#" + id.incrementAndGet() + "-of ? extends " + Joiner.on('&').join(upperBounds);
return Types.newArtificialTypeVariable(WildcardCapturer.class, name, upperBounds);
}
private WildcardCapturer forTypeVariable(final TypeVariable typeParam) {
return new WildcardCapturer(id) {
@Override
TypeVariable captureAsTypeVariable(Type[] upperBounds) {
Set combined = new LinkedHashSet<>(asList(upperBounds));
// Since this is an artifically generated type variable, we don't bother checking
// subtyping between declared type bound and actual type bound. So it's possible that we
// may generate something like .
// Checking subtype between declared and actual type bounds
// adds recursive isSubtypeOf() call and feels complicated.
// There is no contract one way or another as long as isSubtypeOf() works as expected.
combined.addAll(asList(typeParam.getBounds()));
if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
combined.remove(Object.class);
}
return super.captureAsTypeVariable(combined.toArray(new Type[0]));
}
};
}
private WildcardCapturer notForTypeVariable() {
return new WildcardCapturer(id);
}
private Type captureNullable(@Nullable Type type) {
if (type == null) {
return null;
}
return capture(type);
}
}
/**
* Wraps around {@code TypeVariable} to ensure that any two type variables are equal as long as
* they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
* name, even if their bounds differ.
*
* While resolving a type variable from a {@code var -> type} map, we don't care whether the
* type variable's bound has been partially resolved. As long as the type variable "identity"
* matches.
*
*
On the other hand, if for example we are resolving {@code List} to {@code
* List}, we need to compare that {@code } is unequal to {@code } in order to decide to use the transformed type instead of the original type.
*/
static final class TypeVariableKey {
private final TypeVariable var;
TypeVariableKey(TypeVariable var) {
this.var = checkNotNull(var);
}
@Override
public int hashCode() {
return Objects.hashCode(var.getGenericDeclaration(), var.getName());
}
@Override
public boolean equals(Object obj) {
if (obj instanceof TypeVariableKey) {
TypeVariableKey that = (TypeVariableKey) obj;
return equalsTypeVariable(that.var);
} else {
return false;
}
}
@Override
public String toString() {
return var.toString();
}
/** Wraps {@code t} in a {@code TypeVariableKey} if it's a type variable. */
static TypeVariableKey forLookup(Type t) {
if (t instanceof TypeVariable) {
return new TypeVariableKey((TypeVariable) t);
} else {
return null;
}
}
/**
* Returns true if {@code type} is a {@code TypeVariable} with the same name and declared by the
* same {@code GenericDeclaration}.
*/
boolean equalsType(Type type) {
if (type instanceof TypeVariable) {
return equalsTypeVariable((TypeVariable) type);
} else {
return false;
}
}
private boolean equalsTypeVariable(TypeVariable that) {
return var.getGenericDeclaration().equals(that.getGenericDeclaration())
&& var.getName().equals(that.getName());
}
}
}