/*
* Copyright 2014 Google LLC
*
* 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.auto.common;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static javax.lang.model.type.TypeKind.ARRAY;
import static javax.lang.model.type.TypeKind.DECLARED;
import static javax.lang.model.type.TypeKind.EXECUTABLE;
import static javax.lang.model.type.TypeKind.INTERSECTION;
import static javax.lang.model.type.TypeKind.TYPEVAR;
import static javax.lang.model.type.TypeKind.WILDCARD;
import com.google.common.base.Equivalence;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import javax.lang.model.type.WildcardType;
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleTypeVisitor8;
import javax.lang.model.util.Types;
/**
* Utilities related to {@link TypeMirror} instances.
*
* @author Gregory Kick
* @since 2.0
*/
public final class MoreTypes {
private static final class TypeEquivalence extends Equivalence<TypeMirror> {
private static final TypeEquivalence INSTANCE = new TypeEquivalence();
@Override
protected boolean doEquivalent(TypeMirror a, TypeMirror b) {
return MoreTypes.equal(a, b, ImmutableSet.<ComparedElements>of());
}
@Override
protected int doHash(TypeMirror t) {
return MoreTypes.hash(t, ImmutableSet.<Element>of());
}
}
/**
* Returns an {@link Equivalence} that can be used to compare types. The standard way to compare
* types is {@link javax.lang.model.util.Types#isSameType Types.isSameType}, but this alternative
* may be preferred in a number of cases:
*
* <ul>
* <li>If you don't have an instance of {@code Types}.
* <li>If you want a reliable {@code hashCode()} for the types, for example to construct a set
* of types using {@link java.util.HashSet} with {@link Equivalence#wrap(Object)}.
* <li>If you want distinct type variables to be considered equal if they have the same names
* and bounds.
* <li>If you want wildcard types to compare equal if they have the same bounds. {@code
* Types.isSameType} never considers wildcards equal, even when comparing a type to itself.
* </ul>
*/
public static Equivalence<TypeMirror> equivalence() {
return TypeEquivalence.INSTANCE;
}
// So EQUAL_VISITOR can be a singleton, we maintain visiting state, in particular which types
// have been seen already, in this object.
// The logic for handling recursive types like Comparable<T extends Comparable<T>> is very tricky.
// If we're not careful we'll end up with an infinite recursion. So we record the types that
// we've already seen during the recursion, and if we see the same pair of types again we just
// return true provisionally. But "the same pair of types" is itself poorly-defined. We can't
// just say that it is an equal pair of TypeMirrors, because of course if we knew how to
// determine that then we wouldn't need the complicated type visitor at all. On the other hand,
// we can't say that it is an identical pair of TypeMirrors either, because there's no
// guarantee that the TypeMirrors for the two Ts in Comparable<T extends Comparable<T>> will be
// represented by the same object, and indeed with the Eclipse compiler they aren't. We could
// compare the corresponding Elements, since equality is well-defined there, but that's not enough
// either, because the Element for Set<Object> is the same as the one for Set<String>. So we
// approximate by comparing the Elements and, if there are any type arguments, requiring them to
// be identical. This may not be foolproof either but it is sufficient for all the cases we've
// encountered so far.
private static final class EqualVisitorParam {
TypeMirror type;
Set<ComparedElements> visiting;
}
private static class ComparedElements {
final Element a;
final ImmutableList<TypeMirror> aArguments;
final Element b;
final ImmutableList<TypeMirror> bArguments;
ComparedElements(
Element a,
ImmutableList<TypeMirror> aArguments,
Element b,
ImmutableList<TypeMirror> bArguments) {
this.a = a;
this.aArguments = aArguments;
this.b = b;
this.bArguments = bArguments;
}
@Override
public boolean equals(Object o) {
if (o instanceof ComparedElements) {
ComparedElements that = (ComparedElements) o;
int nArguments = aArguments.size();
if (!this.a.equals(that.a)
|| !this.b.equals(that.b)
|| nArguments != bArguments.size()) {
// The arguments must be the same size, but we check anyway.
return false;
}
for (int i = 0; i < nArguments; i++) {
if (aArguments.get(i) != bArguments.get(i)) {
return false;
}
}
return true;
} else {
return false;
}
}
@Override
public int hashCode() {
return a.hashCode() * 31 + b.hashCode();
}
}
private static final class EqualVisitor extends SimpleTypeVisitor8<Boolean, EqualVisitorParam> {
private static final EqualVisitor INSTANCE = new EqualVisitor();
@Override
protected Boolean defaultAction(TypeMirror a, EqualVisitorParam p) {
return a.getKind().equals(p.type.getKind());
}
@Override
public Boolean visitArray(ArrayType a, EqualVisitorParam p) {
if (p.type.getKind().equals(ARRAY)) {
ArrayType b = (ArrayType) p.type;
return equal(a.getComponentType(), b.getComponentType(), p.visiting);
}
return false;
}
@Override
public Boolean visitDeclared(DeclaredType a, EqualVisitorParam p) {
if (p.type.getKind().equals(DECLARED)) {
DeclaredType b = (DeclaredType) p.type;
Element aElement = a.asElement();
Element bElement = b.asElement();
Set<ComparedElements> newVisiting =
visitingSetPlus(
p.visiting, aElement, a.getTypeArguments(), bElement, b.getTypeArguments());
if (newVisiting.equals(p.visiting)) {
// We're already visiting this pair of elements.
// This can happen for example with Enum in Enum<E extends Enum<E>>. Return a
// provisional true value since if the Elements are not in fact equal the original
// visitor of Enum will discover that. We have to check both Elements being compared
// though to avoid missing the fact that one of the types being compared
// differs at exactly this point.
return true;
}
return aElement.equals(bElement)
&& equal(enclosingType(a), enclosingType(b), newVisiting)
&& equalLists(a.getTypeArguments(), b.getTypeArguments(), newVisiting);
}
return false;
}
@Override
@SuppressWarnings("TypeEquals")
public Boolean visitError(ErrorType a, EqualVisitorParam p) {
return a.equals(p.type);
}
@Override
public Boolean visitExecutable(ExecutableType a, EqualVisitorParam p) {
if (p.type.getKind().equals(EXECUTABLE)) {
ExecutableType b = (ExecutableType) p.type;
return equalLists(a.getParameterTypes(), b.getParameterTypes(), p.visiting)
&& equal(a.getReturnType(), b.getReturnType(), p.visiting)
&& equalLists(a.getThrownTypes(), b.getThrownTypes(), p.visiting)
&& equalLists(a.getTypeVariables(), b.getTypeVariables(), p.visiting);
}
return false;
}
@Override
public Boolean visitIntersection(IntersectionType a, EqualVisitorParam p) {
if (p.type.getKind().equals(INTERSECTION)) {
IntersectionType b = (IntersectionType) p.type;
return equalLists(a.getBounds(), b.getBounds(), p.visiting);
}
return false;
}
@Override
public Boolean visitTypeVariable(TypeVariable a, EqualVisitorParam p) {
if (p.type.getKind().equals(TYPEVAR)) {
TypeVariable b = (TypeVariable) p.type;
TypeParameterElement aElement = (TypeParameterElement) a.asElement();
TypeParameterElement bElement = (TypeParameterElement) b.asElement();
Set<ComparedElements> newVisiting = visitingSetPlus(p.visiting, aElement, bElement);
if (newVisiting.equals(p.visiting)) {
// We're already visiting this pair of elements.
// This can happen with our friend Eclipse when looking at <T extends Comparable<T>>.
// It incorrectly reports the upper bound of T as T itself.
return true;
}
// We use aElement.getBounds() instead of a.getUpperBound() to avoid having to deal with
// the different way intersection types (like <T extends Number & Comparable<T>>) are
// represented before and after Java 8. We do have an issue that this code may consider
// that <T extends Foo & Bar> is different from <T extends Bar & Foo>, but it's very
// hard to avoid that, and not likely to be much of a problem in practice.
return equalLists(aElement.getBounds(), bElement.getBounds(), newVisiting)
&& equal(a.getLowerBound(), b.getLowerBound(), newVisiting)
&& a.asElement().getSimpleName().equals(b.asElement().getSimpleName());
}
return false;
}
@Override
public Boolean visitWildcard(WildcardType a, EqualVisitorParam p) {
if (p.type.getKind().equals(WILDCARD)) {
WildcardType b = (WildcardType) p.type;
return equal(a.getExtendsBound(), b.getExtendsBound(), p.visiting)
&& equal(a.getSuperBound(), b.getSuperBound(), p.visiting);
}
return false;
}
@Override
public Boolean visitUnknown(TypeMirror a, EqualVisitorParam p) {
throw new UnsupportedOperationException();
}
private Set<ComparedElements> visitingSetPlus(
Set<ComparedElements> visiting, Element a, Element b) {
ImmutableList<TypeMirror> noArguments = ImmutableList.of();
return visitingSetPlus(visiting, a, noArguments, b, noArguments);
}
private Set<ComparedElements> visitingSetPlus(
Set<ComparedElements> visiting,
Element a,
List<? extends TypeMirror> aArguments,
Element b,
List<? extends TypeMirror> bArguments) {
ComparedElements comparedElements =
new ComparedElements(
a, ImmutableList.<TypeMirror>copyOf(aArguments),
b, ImmutableList.<TypeMirror>copyOf(bArguments));
Set<ComparedElements> newVisiting = new HashSet<ComparedElements>(visiting);
newVisiting.add(comparedElements);
return newVisiting;
}
}
@SuppressWarnings("TypeEquals")
private static boolean equal(TypeMirror a, TypeMirror b, Set<ComparedElements> visiting) {
// TypeMirror.equals is not guaranteed to return true for types that are equal, but we can
// assume that if it does return true then the types are equal. This check also avoids getting
// stuck in infinite recursion when Eclipse decrees that the upper bound of the second K in
// <K extends Comparable<K>> is a distinct but equal K.
// The javac implementation of ExecutableType, at least in some versions, does not take thrown
// exceptions into account in its equals implementation, so avoid this optimization for
// ExecutableType.
if (Objects.equal(a, b) && !(a instanceof ExecutableType)) {
return true;
}
EqualVisitorParam p = new EqualVisitorParam();
p.type = b;
p.visiting = visiting;
return (a == b) || (a != null && b != null && a.accept(EqualVisitor.INSTANCE, p));
}
/**
* Returns the type of the innermost enclosing instance, or null if there is none. This is the
* same as {@link DeclaredType#getEnclosingType()} except that it returns null rather than
* NoType for a static type. We need this because of
* <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=508222">this bug</a> whereby
* the Eclipse compiler returns a value for static classes that is not NoType.
*/
private static TypeMirror enclosingType(DeclaredType t) {
TypeMirror enclosing = t.getEnclosingType();
if (enclosing.getKind().equals(TypeKind.NONE)
|| t.asElement().getModifiers().contains(Modifier.STATIC)) {
return null;
}
return enclosing;
}
private static boolean equalLists(
List<? extends TypeMirror> a, List<? extends TypeMirror> b, Set<ComparedElements> visiting) {
int size = a.size();
if (size != b.size()) {
return false;
}
// Use iterators in case the Lists aren't RandomAccess
Iterator<? extends TypeMirror> aIterator = a.iterator();
Iterator<? extends TypeMirror> bIterator = b.iterator();
while (aIterator.hasNext()) {
if (!bIterator.hasNext()) {
return false;
}
TypeMirror nextMirrorA = aIterator.next();
TypeMirror nextMirrorB = bIterator.next();
if (!equal(nextMirrorA, nextMirrorB, visiting)) {
return false;
}
}
return !aIterator.hasNext();
}
private static final int HASH_SEED = 17;
private static final int HASH_MULTIPLIER = 31;
private static final class HashVisitor extends SimpleTypeVisitor8<Integer, Set<Element>> {
private static final HashVisitor INSTANCE = new HashVisitor();
int hashKind(int seed, TypeMirror t) {
int result = seed * HASH_MULTIPLIER;
result += t.getKind().hashCode();
return result;
}
@Override
protected Integer defaultAction(TypeMirror e, Set<Element> visiting) {
return hashKind(HASH_SEED, e);
}
@Override
public Integer visitArray(ArrayType t, Set<Element> visiting) {
int result = hashKind(HASH_SEED, t);
result *= HASH_MULTIPLIER;
result += t.getComponentType().accept(this, visiting);
return result;
}
@Override
public Integer visitDeclared(DeclaredType t, Set<Element> visiting) {
Element element = t.asElement();
if (visiting.contains(element)) {
return 0;
}
Set<Element> newVisiting = new HashSet<Element>(visiting);
newVisiting.add(element);
int result = hashKind(HASH_SEED, t);
result *= HASH_MULTIPLIER;
result += t.asElement().hashCode();
result *= HASH_MULTIPLIER;
result += t.getEnclosingType().accept(this, newVisiting);
result *= HASH_MULTIPLIER;
result += hashList(t.getTypeArguments(), newVisiting);
return result;
}
@Override
public Integer visitExecutable(ExecutableType t, Set<Element> visiting) {
int result = hashKind(HASH_SEED, t);
result *= HASH_MULTIPLIER;
result += hashList(t.getParameterTypes(), visiting);
result *= HASH_MULTIPLIER;
result += t.getReturnType().accept(this, visiting);
result *= HASH_MULTIPLIER;
result += hashList(t.getThrownTypes(), visiting);
result *= HASH_MULTIPLIER;
result += hashList(t.getTypeVariables(), visiting);
return result;
}
@Override
public Integer visitTypeVariable(TypeVariable t, Set<Element> visiting) {
int result = hashKind(HASH_SEED, t);
result *= HASH_MULTIPLIER;
result += t.getLowerBound().accept(this, visiting);
TypeParameterElement element = (TypeParameterElement) t.asElement();
for (TypeMirror bound : element.getBounds()) {
result *= HASH_MULTIPLIER;
result += bound.accept(this, visiting);
}
return result;
}
@Override
public Integer visitWildcard(WildcardType t, Set<Element> visiting) {
int result = hashKind(HASH_SEED, t);
result *= HASH_MULTIPLIER;
result += (t.getExtendsBound() == null) ? 0 : t.getExtendsBound().accept(this, visiting);
result *= HASH_MULTIPLIER;
result += (t.getSuperBound() == null) ? 0 : t.getSuperBound().accept(this, visiting);
return result;
}
@Override
public Integer visitUnknown(TypeMirror t, Set<Element> visiting) {
throw new UnsupportedOperationException();
}
};
private static int hashList(List<? extends TypeMirror> mirrors, Set<Element> visiting) {
int result = HASH_SEED;
for (TypeMirror mirror : mirrors) {
result *= HASH_MULTIPLIER;
result += hash(mirror, visiting);
}
return result;
}
private static int hash(TypeMirror mirror, Set<Element> visiting) {
return mirror == null ? 0 : mirror.accept(HashVisitor.INSTANCE, visiting);
}
/**
* Returns the set of {@linkplain TypeElement types} that are referenced by the given {@link
* TypeMirror}.
*/
public static ImmutableSet<TypeElement> referencedTypes(TypeMirror type) {
checkNotNull(type);
ImmutableSet.Builder<TypeElement> elements = ImmutableSet.builder();
type.accept(ReferencedTypes.INSTANCE, elements);
return elements.build();
}
private static final class ReferencedTypes
extends SimpleTypeVisitor8<Void, ImmutableSet.Builder<TypeElement>> {
private static final ReferencedTypes INSTANCE = new ReferencedTypes();
@Override
public Void visitArray(ArrayType t, ImmutableSet.Builder<TypeElement> p) {
t.getComponentType().accept(this, p);
return null;
}
@Override
public Void visitDeclared(DeclaredType t, ImmutableSet.Builder<TypeElement> p) {
p.add(MoreElements.asType(t.asElement()));
for (TypeMirror typeArgument : t.getTypeArguments()) {
typeArgument.accept(this, p);
}
return null;
}
@Override
public Void visitTypeVariable(TypeVariable t, ImmutableSet.Builder<TypeElement> p) {
t.getLowerBound().accept(this, p);
t.getUpperBound().accept(this, p);
return null;
}
@Override
public Void visitWildcard(WildcardType t, ImmutableSet.Builder<TypeElement> p) {
TypeMirror extendsBound = t.getExtendsBound();
if (extendsBound != null) {
extendsBound.accept(this, p);
}
TypeMirror superBound = t.getSuperBound();
if (superBound != null) {
superBound.accept(this, p);
}
return null;
}
}
/**
* An alternate implementation of {@link Types#asElement} that does not require a {@link Types}
* instance with the notable difference that it will throw {@link IllegalArgumentException}
* instead of returning null if the {@link TypeMirror} can not be converted to an {@link Element}.
*
* @throws NullPointerException if {@code typeMirror} is {@code null}
* @throws IllegalArgumentException if {@code typeMirror} cannot be converted to an {@link
* Element}
*/
public static Element asElement(TypeMirror typeMirror) {
return typeMirror.accept(AsElementVisitor.INSTANCE, null);
}
private static final class AsElementVisitor extends SimpleTypeVisitor8<Element, Void> {
private static final AsElementVisitor INSTANCE = new AsElementVisitor();
@Override
protected Element defaultAction(TypeMirror e, Void p) {
throw new IllegalArgumentException(e + " cannot be converted to an Element");
}
@Override
public Element visitDeclared(DeclaredType t, Void p) {
return t.asElement();
}
@Override
public Element visitError(ErrorType t, Void p) {
return t.asElement();
}
@Override
public Element visitTypeVariable(TypeVariable t, Void p) {
return t.asElement();
}
};
// TODO(gak): consider removing these two methods as they're pretty trivial now
public static TypeElement asTypeElement(TypeMirror mirror) {
return MoreElements.asType(asElement(mirror));
}
public static ImmutableSet<TypeElement> asTypeElements(Iterable<? extends TypeMirror> mirrors) {
checkNotNull(mirrors);
ImmutableSet.Builder<TypeElement> builder = ImmutableSet.builder();
for (TypeMirror mirror : mirrors) {
builder.add(asTypeElement(mirror));
}
return builder.build();
}
/**
* Returns a {@link ArrayType} if the {@link TypeMirror} represents an array or throws an {@link
* IllegalArgumentException}.
*/
public static ArrayType asArray(TypeMirror maybeArrayType) {
return maybeArrayType.accept(ArrayTypeVisitor.INSTANCE, null);
}
private static final class ArrayTypeVisitor extends CastingTypeVisitor<ArrayType> {
private static final ArrayTypeVisitor INSTANCE = new ArrayTypeVisitor();
ArrayTypeVisitor() {
super("array");
}
@Override
public ArrayType visitArray(ArrayType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link DeclaredType} if the {@link TypeMirror} represents a declared type such as a
* class, interface, union/compound, or enum or throws an {@link IllegalArgumentException}.
*/
public static DeclaredType asDeclared(TypeMirror maybeDeclaredType) {
return maybeDeclaredType.accept(DeclaredTypeVisitor.INSTANCE, null);
}
private static final class DeclaredTypeVisitor extends CastingTypeVisitor<DeclaredType> {
private static final DeclaredTypeVisitor INSTANCE = new DeclaredTypeVisitor();
DeclaredTypeVisitor() {
super("declared type");
}
@Override
public DeclaredType visitDeclared(DeclaredType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link ExecutableType} if the {@link TypeMirror} represents an executable type such
* as may result from missing code, or bad compiles or throws an {@link IllegalArgumentException}.
*/
public static ErrorType asError(TypeMirror maybeErrorType) {
return maybeErrorType.accept(ErrorTypeVisitor.INSTANCE, null);
}
private static final class ErrorTypeVisitor extends CastingTypeVisitor<ErrorType> {
private static final ErrorTypeVisitor INSTANCE = new ErrorTypeVisitor();
ErrorTypeVisitor() {
super("error type");
}
@Override
public ErrorType visitError(ErrorType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link ExecutableType} if the {@link TypeMirror} represents an executable type such
* as a method, constructor, or initializer or throws an {@link IllegalArgumentException}.
*/
public static ExecutableType asExecutable(TypeMirror maybeExecutableType) {
return maybeExecutableType.accept(ExecutableTypeVisitor.INSTANCE, null);
}
private static final class ExecutableTypeVisitor extends CastingTypeVisitor<ExecutableType> {
private static final ExecutableTypeVisitor INSTANCE = new ExecutableTypeVisitor();
ExecutableTypeVisitor() {
super("executable type");
}
@Override
public ExecutableType visitExecutable(ExecutableType type, Void ignore) {
return type;
}
}
/**
* Returns an {@link IntersectionType} if the {@link TypeMirror} represents an intersection-type
* or throws an {@link IllegalArgumentException}.
*/
public static IntersectionType asIntersection(TypeMirror maybeIntersectionType) {
return maybeIntersectionType.accept(IntersectionTypeVisitor.INSTANCE, null);
}
private static final class IntersectionTypeVisitor extends CastingTypeVisitor<IntersectionType> {
private static final IntersectionTypeVisitor INSTANCE = new IntersectionTypeVisitor();
IntersectionTypeVisitor() {
super("intersection type");
}
@Override
public IntersectionType visitIntersection(IntersectionType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link NoType} if the {@link TypeMirror} represents an non-type such as void, or
* package, etc. or throws an {@link IllegalArgumentException}.
*/
public static NoType asNoType(TypeMirror maybeNoType) {
return maybeNoType.accept(NoTypeVisitor.INSTANCE, null);
}
private static final class NoTypeVisitor extends CastingTypeVisitor<NoType> {
private static final NoTypeVisitor INSTANCE = new NoTypeVisitor();
NoTypeVisitor() {
super("non-type");
}
@Override
public NoType visitNoType(NoType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link NullType} if the {@link TypeMirror} represents the null type or throws an
* {@link IllegalArgumentException}.
*/
public static NullType asNullType(TypeMirror maybeNullType) {
return maybeNullType.accept(NullTypeVisitor.INSTANCE, null);
}
private static final class NullTypeVisitor extends CastingTypeVisitor<NullType> {
private static final NullTypeVisitor INSTANCE = new NullTypeVisitor();
NullTypeVisitor() {
super("null");
}
@Override
public NullType visitNull(NullType type, Void ignore) {
return type;
}
}
/**
* Returns a {@link PrimitiveType} if the {@link TypeMirror} represents a primitive type or throws
* an {@link IllegalArgumentException}.
*/
public static PrimitiveType asPrimitiveType(TypeMirror maybePrimitiveType) {
return maybePrimitiveType.accept(PrimitiveTypeVisitor.INSTANCE, null);
}
private static final class PrimitiveTypeVisitor extends CastingTypeVisitor<PrimitiveType> {
private static final PrimitiveTypeVisitor INSTANCE = new PrimitiveTypeVisitor();
PrimitiveTypeVisitor() {
super("primitive type");
}
@Override
public PrimitiveType visitPrimitive(PrimitiveType type, Void ignore) {
return type;
}
}
//
// visitUnionType would go here, but isn't relevant for annotation processors
//
/**
* Returns a {@link TypeVariable} if the {@link TypeMirror} represents a type variable or throws
* an {@link IllegalArgumentException}.
*/
public static TypeVariable asTypeVariable(TypeMirror maybeTypeVariable) {
return maybeTypeVariable.accept(TypeVariableVisitor.INSTANCE, null);
}
private static final class TypeVariableVisitor extends CastingTypeVisitor<TypeVariable> {
private static final TypeVariableVisitor INSTANCE = new TypeVariableVisitor();
TypeVariableVisitor() {
super("type variable");
}
@Override
public TypeVariable visitTypeVariable(TypeVariable type, Void ignore) {
return type;
}
}
/**
* Returns a {@link WildcardType} if the {@link TypeMirror} represents a wildcard type or throws
* an {@link IllegalArgumentException}.
*/
public static WildcardType asWildcard(TypeMirror maybeWildcardType) {
return maybeWildcardType.accept(WildcardTypeVisitor.INSTANCE, null);
}
private static final class WildcardTypeVisitor extends CastingTypeVisitor<WildcardType> {
private static final WildcardTypeVisitor INSTANCE = new WildcardTypeVisitor();
WildcardTypeVisitor() {
super("wildcard type");
}
@Override
public WildcardType visitWildcard(WildcardType type, Void ignore) {
return type;
}
}
/**
* Returns true if the raw type underlying the given {@link TypeMirror} represents a type that can
* be referenced by a {@link Class}. If this returns true, then {@link #isTypeOf} is guaranteed to
* not throw.
*/
public static boolean isType(TypeMirror type) {
return type.accept(IsTypeVisitor.INSTANCE, null);
}
private static final class IsTypeVisitor extends SimpleTypeVisitor8<Boolean, Void> {
private static final IsTypeVisitor INSTANCE = new IsTypeVisitor();
@Override
protected Boolean defaultAction(TypeMirror type, Void ignored) {
return false;
}
@Override
public Boolean visitNoType(NoType noType, Void p) {
return noType.getKind().equals(TypeKind.VOID);
}
@Override
public Boolean visitPrimitive(PrimitiveType type, Void p) {
return true;
}
@Override
public Boolean visitArray(ArrayType array, Void p) {
return true;
}
@Override
public Boolean visitDeclared(DeclaredType type, Void ignored) {
return MoreElements.isType(type.asElement());
}
}
/**
* Returns true if the raw type underlying the given {@link TypeMirror} represents the same raw
* type as the given {@link Class} and throws an IllegalArgumentException if the {@link
* TypeMirror} does not represent a type that can be referenced by a {@link Class}
*/
public static boolean isTypeOf(final Class<?> clazz, TypeMirror type) {
checkNotNull(clazz);
return type.accept(new IsTypeOf(clazz), null);
}
private static final class IsTypeOf extends SimpleTypeVisitor8<Boolean, Void> {
private final Class<?> clazz;
IsTypeOf(Class<?> clazz) {
this.clazz = clazz;
}
@Override
protected Boolean defaultAction(TypeMirror type, Void ignored) {
throw new IllegalArgumentException(type + " cannot be represented as a Class<?>.");
}
@Override
public Boolean visitNoType(NoType noType, Void p) {
if (noType.getKind().equals(TypeKind.VOID)) {
return clazz.equals(Void.TYPE);
}
throw new IllegalArgumentException(noType + " cannot be represented as a Class<?>.");
}
@Override
public Boolean visitPrimitive(PrimitiveType type, Void p) {
switch (type.getKind()) {
case BOOLEAN:
return clazz.equals(Boolean.TYPE);
case BYTE:
return clazz.equals(Byte.TYPE);
case CHAR:
return clazz.equals(Character.TYPE);
case DOUBLE:
return clazz.equals(Double.TYPE);
case FLOAT:
return clazz.equals(Float.TYPE);
case INT:
return clazz.equals(Integer.TYPE);
case LONG:
return clazz.equals(Long.TYPE);
case SHORT:
return clazz.equals(Short.TYPE);
default:
throw new IllegalArgumentException(type + " cannot be represented as a Class<?>.");
}
}
@Override
public Boolean visitArray(ArrayType array, Void p) {
return clazz.isArray() && isTypeOf(clazz.getComponentType(), array.getComponentType());
}
@Override
public Boolean visitDeclared(DeclaredType type, Void ignored) {
TypeElement typeElement = MoreElements.asType(type.asElement());
return typeElement.getQualifiedName().contentEquals(clazz.getCanonicalName());
}
}
/**
* Returns the superclass of {@code type}, with any type parameters bound by {@code type}, or
* {@link Optional#absent()} if {@code type} is an interface or {@link Object} or its superclass
* is {@link Object}.
*/
// TODO(user): Remove unused parameter Elements?
public static Optional<DeclaredType> nonObjectSuperclass(Types types, Elements elements,
DeclaredType type) {
checkNotNull(types);
checkNotNull(elements); // This is no longer used, but here to avoid changing the API.
checkNotNull(type);
TypeMirror superclassType = asTypeElement(type).getSuperclass();
if (!isType(superclassType)) { // type is Object or an interface
return Optional.absent();
}
DeclaredType superclass = asDeclared(superclassType);
if (isObjectType(superclass)) {
return Optional.absent();
}
if (superclass.getTypeArguments().isEmpty()) {
return Optional.of(superclass);
}
// In the case where the super class has type parameters, TypeElement#getSuperclass gives
// SuperClass<T> rather than SuperClass<Foo>, so use Types#directSupertypes instead. The javadoc
// for Types#directSupertypes guarantees that a super class, if it exists, comes before any
// interfaces. Thus, we can just get the first element in the list.
return Optional.of(asDeclared(types.directSupertypes(type).get(0)));
}
private static boolean isObjectType(DeclaredType type) {
return asTypeElement(type).getQualifiedName().contentEquals("java.lang.Object");
}
/**
* Resolves a {@link VariableElement} parameter to a method or constructor based on the given
* container, or a member of a class. For parameters to a method or constructor, the variable's
* enclosing element must be a supertype of the container type. For example, given a
* {@code container} of type {@code Set<String>}, and a variable corresponding to the {@code E e}
* parameter in the {@code Set.add(E e)} method, this will return a TypeMirror for {@code String}.
*/
public static TypeMirror asMemberOf(Types types, DeclaredType container,
VariableElement variable) {
if (variable.getKind().equals(ElementKind.PARAMETER)) {
ExecutableElement methodOrConstructor =
MoreElements.asExecutable(variable.getEnclosingElement());
ExecutableType resolvedMethodOrConstructor =
MoreTypes.asExecutable(types.asMemberOf(container, methodOrConstructor));
List<? extends VariableElement> parameters = methodOrConstructor.getParameters();
List<? extends TypeMirror> parameterTypes = resolvedMethodOrConstructor.getParameterTypes();
checkState(parameters.size() == parameterTypes.size());
for (int i = 0; i < parameters.size(); i++) {
// We need to capture the parameter type of the variable we're concerned about,
// for later printing. This is the only way to do it since we can't use
// types.asMemberOf on variables of methods.
if (parameters.get(i).equals(variable)) {
return parameterTypes.get(i);
}
}
throw new IllegalStateException("Could not find variable: " + variable);
} else {
return types.asMemberOf(container, variable);
}
}
private abstract static class CastingTypeVisitor<T> extends SimpleTypeVisitor8<T, Void> {
private final String label;
CastingTypeVisitor(String label) {
this.label = label;
}
@Override
protected T defaultAction(TypeMirror e, Void v) {
throw new IllegalArgumentException(e + " does not represent a " + label);
}
}
/**
* Returns true if casting {@code Object} to the given type will elicit an unchecked warning from
* the compiler. Only type variables and parameterized types such as {@code List<String>} produce
* such warnings. There will be no warning if the type's only type parameters are simple
* wildcards, as in {@code Map<?, ?>}.
*/
public static boolean isConversionFromObjectUnchecked(TypeMirror type) {
return new CastingUncheckedVisitor().visit(type, null);
}
/**
* Visitor that tells whether a type is erased, in the sense of {@link #castIsUnchecked}. Each
* visitX method returns true if its input parameter is true or if the type being visited is
* erased.
*/
private static class CastingUncheckedVisitor extends SimpleTypeVisitor8<Boolean, Void> {
CastingUncheckedVisitor() {
super(false);
}
@Override
public Boolean visitUnknown(TypeMirror t, Void p) {
// We don't know whether casting is unchecked for this mysterious type but assume it is,
// so we will insert a possibly unnecessary @SuppressWarnings("unchecked").
return true;
}
@Override
public Boolean visitArray(ArrayType t, Void p) {
return visit(t.getComponentType(), p);
}
@Override
public Boolean visitDeclared(DeclaredType t, Void p) {
return t.getTypeArguments().stream().anyMatch(CastingUncheckedVisitor::uncheckedTypeArgument);
}
@Override
public Boolean visitTypeVariable(TypeVariable t, Void p) {
return true;
}
// If a type has a type argument, then casting to the type is unchecked, except if the argument
// is <?> or <? extends Object>. The same applies to all type arguments, so casting to Map<?, ?>
// does not produce an unchecked warning for example.
private static boolean uncheckedTypeArgument(TypeMirror arg) {
if (arg.getKind().equals(TypeKind.WILDCARD)) {
WildcardType wildcard = asWildcard(arg);
if (wildcard.getExtendsBound() == null || isJavaLangObject(wildcard.getExtendsBound())) {
// This is <?>, unless there's a super bound, in which case it is <? super Foo> and
// is erased.
return (wildcard.getSuperBound() != null);
}
}
return true;
}
private static boolean isJavaLangObject(TypeMirror type) {
if (type.getKind() != TypeKind.DECLARED) {
return false;
}
TypeElement typeElement = asTypeElement(type);
return typeElement.getQualifiedName().contentEquals("java.lang.Object");
}
}
private MoreTypes() {}
}
