| package org.checkerframework.javacutil; |
| |
| import com.sun.tools.javac.code.Symbol; |
| import com.sun.tools.javac.code.Symtab; |
| import com.sun.tools.javac.code.Type; |
| import com.sun.tools.javac.code.Type.CapturedType; |
| import com.sun.tools.javac.code.Type.ClassType; |
| import com.sun.tools.javac.code.TypeTag; |
| import com.sun.tools.javac.model.JavacTypes; |
| import com.sun.tools.javac.processing.JavacProcessingEnvironment; |
| import com.sun.tools.javac.util.Context; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.StringJoiner; |
| import javax.annotation.processing.ProcessingEnvironment; |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.Name; |
| import javax.lang.model.element.NestingKind; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.element.TypeParameterElement; |
| import javax.lang.model.type.ArrayType; |
| import javax.lang.model.type.DeclaredType; |
| 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.UnionType; |
| import javax.lang.model.type.WildcardType; |
| import javax.lang.model.util.Elements; |
| import javax.lang.model.util.Types; |
| import org.checkerframework.checker.nullness.qual.Nullable; |
| import org.checkerframework.checker.signature.qual.BinaryName; |
| import org.checkerframework.checker.signature.qual.CanonicalNameOrEmpty; |
| import org.checkerframework.checker.signature.qual.DotSeparatedIdentifiers; |
| import org.checkerframework.checker.signature.qual.FullyQualifiedName; |
| import org.plumelib.util.CollectionsPlume; |
| import org.plumelib.util.ImmutableTypes; |
| |
| /** |
| * A utility class that helps with {@link TypeMirror}s. It complements {@link Types}, providing |
| * methods that {@link Types} does not. |
| */ |
| public final class TypesUtils { |
| |
| /** Class cannot be instantiated. */ |
| private TypesUtils() { |
| throw new AssertionError("Class TypesUtils cannot be instantiated."); |
| } |
| |
| /// Creating types |
| |
| /** |
| * Returns the {@link TypeMirror} for a given {@link Class}. |
| * |
| * @param clazz a class |
| * @param types the type utilities |
| * @param elements the element utiliites |
| * @return the TypeMirror for {@code clazz} |
| */ |
| public static TypeMirror typeFromClass(Class<?> clazz, Types types, Elements elements) { |
| if (clazz == void.class) { |
| return types.getNoType(TypeKind.VOID); |
| } else if (clazz.isPrimitive()) { |
| String primitiveName = clazz.getName().toUpperCase(); |
| TypeKind primitiveKind = TypeKind.valueOf(primitiveName); |
| return types.getPrimitiveType(primitiveKind); |
| } else if (clazz.isArray()) { |
| TypeMirror componentType = typeFromClass(clazz.getComponentType(), types, elements); |
| return types.getArrayType(componentType); |
| } else { |
| String name = clazz.getCanonicalName(); |
| assert name != null : "@AssumeAssertion(nullness): assumption"; |
| TypeElement element = elements.getTypeElement(name); |
| if (element == null) { |
| throw new BugInCF("Unrecognized class: " + clazz); |
| } |
| return element.asType(); |
| } |
| } |
| |
| /** |
| * Returns an {@link ArrayType} with elements of type {@code componentType}. |
| * |
| * @param componentType the component type of the created array type |
| * @param types the type utilities |
| * @return an {@link ArrayType} whose elements have type {@code componentType} |
| */ |
| public static ArrayType createArrayType(TypeMirror componentType, Types types) { |
| JavacTypes t = (JavacTypes) types; |
| return t.getArrayType(componentType); |
| } |
| |
| /// Creating a Class<?> |
| |
| /** |
| * Returns the {@link Class} for a given {@link TypeMirror}. Returns {@code Object.class} if it |
| * cannot determine anything more specific. |
| * |
| * @param typeMirror a TypeMirror |
| * @return the class for {@code typeMirror} |
| */ |
| public static Class<?> getClassFromType(TypeMirror typeMirror) { |
| |
| switch (typeMirror.getKind()) { |
| case INT: |
| return int.class; |
| case LONG: |
| return long.class; |
| case SHORT: |
| return short.class; |
| case BYTE: |
| return byte.class; |
| case CHAR: |
| return char.class; |
| case DOUBLE: |
| return double.class; |
| case FLOAT: |
| return float.class; |
| case BOOLEAN: |
| return boolean.class; |
| |
| case ARRAY: |
| Class<?> componentClass = getClassFromType(((ArrayType) typeMirror).getComponentType()); |
| // In Java 12, use this instead: |
| // return fooClass.arrayType(); |
| return java.lang.reflect.Array.newInstance(componentClass, 0).getClass(); |
| |
| case DECLARED: |
| // BUG: need to compute a @ClassGetName, but this code computes a |
| // @CanonicalNameOrEmpty. They are different for inner classes. |
| @SuppressWarnings("signature") // https://tinyurl.com/cfissue/658 for Names.toString |
| @DotSeparatedIdentifiers String typeString = TypesUtils.getQualifiedName((DeclaredType) typeMirror).toString(); |
| if (typeString.equals("<nulltype>")) { |
| return void.class; |
| } |
| |
| try { |
| return Class.forName(typeString); |
| } catch (ClassNotFoundException | UnsupportedClassVersionError e) { |
| return Object.class; |
| } |
| |
| default: |
| return Object.class; |
| } |
| } |
| |
| /// Getters |
| |
| /** |
| * Gets the fully qualified name for a provided type. It returns an empty name if type is an |
| * anonymous type. |
| * |
| * @param type the declared type |
| * @return the name corresponding to that type |
| */ |
| @SuppressWarnings("signature:return") // todo: add fake override of Name.toString. |
| public static @CanonicalNameOrEmpty String getQualifiedName(DeclaredType type) { |
| TypeElement element = (TypeElement) type.asElement(); |
| @CanonicalNameOrEmpty Name name = element.getQualifiedName(); |
| return name.toString(); |
| } |
| |
| /** |
| * Returns the simple type name, without annotations. |
| * |
| * @param type a type |
| * @return the simple type name, without annotations |
| */ |
| public static String simpleTypeName(TypeMirror type) { |
| switch (type.getKind()) { |
| case ARRAY: |
| return simpleTypeName(((ArrayType) type).getComponentType()) + "[]"; |
| case TYPEVAR: |
| return ((TypeVariable) type).asElement().getSimpleName().toString(); |
| case DECLARED: |
| return ((DeclaredType) type).asElement().getSimpleName().toString(); |
| case NULL: |
| return "<nulltype>"; |
| case VOID: |
| return "void"; |
| case WILDCARD: |
| WildcardType wildcard = (WildcardType) type; |
| TypeMirror extendsBound = wildcard.getExtendsBound(); |
| TypeMirror superBound = wildcard.getSuperBound(); |
| return "?" |
| + (extendsBound != null ? " extends " + simpleTypeName(extendsBound) : "") |
| + (superBound != null ? " super " + simpleTypeName(superBound) : ""); |
| case UNION: |
| StringJoiner sj = new StringJoiner(" | "); |
| for (TypeMirror alternative : ((UnionType) type).getAlternatives()) { |
| sj.add(simpleTypeName(alternative)); |
| } |
| return sj.toString(); |
| default: |
| if (type.getKind().isPrimitive()) { |
| return TypeAnnotationUtils.unannotatedType(type).toString(); |
| } else { |
| throw new BugInCF( |
| "simpleTypeName: unhandled type kind: %s, type: %s", type.getKind(), type); |
| } |
| } |
| } |
| |
| /** |
| * Returns the binary name. |
| * |
| * @param type a type |
| * @return the binary name |
| */ |
| public static @BinaryName String binaryName(TypeMirror type) { |
| if (type.getKind() != TypeKind.DECLARED) { |
| throw new BugInCF("Only declared types have a binary name"); |
| } |
| return ElementUtils.getBinaryName((TypeElement) ((DeclaredType) type).asElement()); |
| } |
| |
| /** |
| * Returns the type element for {@code type} if {@code type} is a class, interface, annotation |
| * type, or enum. Otherwise, returns null. |
| * |
| * @param type whose element is returned |
| * @return the type element for {@code type} if {@code type} is a class, interface, annotation |
| * type, or enum; otherwise, returns {@code null} |
| */ |
| public static @Nullable TypeElement getTypeElement(TypeMirror type) { |
| Element element = ((Type) type).asElement(); |
| if (element == null) { |
| return null; |
| } |
| if (ElementUtils.isTypeElement(element)) { |
| return (TypeElement) element; |
| } |
| return null; |
| } |
| |
| /** |
| * Given an array type, returns the type with all array levels stripped off. |
| * |
| * @param at an array type |
| * @return the type with all array levels stripped off |
| */ |
| public static TypeMirror getInnermostComponentType(ArrayType at) { |
| TypeMirror result = at; |
| while (result.getKind() == TypeKind.ARRAY) { |
| result = ((ArrayType) result).getComponentType(); |
| } |
| return result; |
| } |
| |
| /// Equality |
| |
| /** |
| * Returns true iff the arguments are both the same declared types. |
| * |
| * <p>This is needed because class {@code Type.ClassType} does not override equals. |
| * |
| * @param t1 the first type to test |
| * @param t2 the second type to test |
| * @return whether the arguments are the same declared types |
| */ |
| public static boolean areSameDeclaredTypes(Type.ClassType t1, Type.ClassType t2) { |
| // Do a cheaper test first |
| if (t1.tsym.name != t2.tsym.name) { |
| return false; |
| } |
| return t1.toString().equals(t1.toString()); |
| } |
| |
| /** |
| * Returns true iff the arguments are both the same primitive type. |
| * |
| * @param left a type |
| * @param right a type |
| * @return whether the arguments are the same primitive type |
| */ |
| public static boolean areSamePrimitiveTypes(TypeMirror left, TypeMirror right) { |
| if (!isPrimitive(left) || !isPrimitive(right)) { |
| return false; |
| } |
| |
| return (left.getKind() == right.getKind()); |
| } |
| |
| /// Predicates |
| |
| /** |
| * Checks if the type represents a java.lang.Object declared type. |
| * |
| * @param type the type |
| * @return true iff type represents java.lang.Object |
| */ |
| public static boolean isObject(TypeMirror type) { |
| return isDeclaredOfName(type, "java.lang.Object"); |
| } |
| |
| /** |
| * Checks if the type represents the java.lang.Class declared type. |
| * |
| * @param type the type |
| * @return true iff type represents java.lang.Class |
| */ |
| public static boolean isClass(TypeMirror type) { |
| return isDeclaredOfName(type, "java.lang.Class"); |
| } |
| |
| /** |
| * Checks if the type represents a java.lang.String declared type. |
| * |
| * @param type the type |
| * @return true iff type represents java.lang.String |
| */ |
| public static boolean isString(TypeMirror type) { |
| return isDeclaredOfName(type, "java.lang.String"); |
| } |
| |
| /** |
| * Checks if the type represents a boolean type, that is either boolean (primitive type) or |
| * java.lang.Boolean. |
| * |
| * @param type the type to test |
| * @return true iff type represents a boolean type |
| */ |
| public static boolean isBooleanType(TypeMirror type) { |
| return isDeclaredOfName(type, "java.lang.Boolean") || type.getKind() == TypeKind.BOOLEAN; |
| } |
| |
| /** |
| * Check if the type represents a declared type of the given qualified name. |
| * |
| * @param type the type |
| * @return type iff type represents a declared type of the qualified name |
| */ |
| public static boolean isDeclaredOfName(TypeMirror type, CharSequence qualifiedName) { |
| return type.getKind() == TypeKind.DECLARED |
| && getQualifiedName((DeclaredType) type).contentEquals(qualifiedName); |
| } |
| |
| public static boolean isBoxedPrimitive(TypeMirror type) { |
| if (type.getKind() != TypeKind.DECLARED) { |
| return false; |
| } |
| |
| String qualifiedName = getQualifiedName((DeclaredType) type).toString(); |
| |
| return (qualifiedName.equals("java.lang.Boolean") |
| || qualifiedName.equals("java.lang.Byte") |
| || qualifiedName.equals("java.lang.Character") |
| || qualifiedName.equals("java.lang.Short") |
| || qualifiedName.equals("java.lang.Integer") |
| || qualifiedName.equals("java.lang.Long") |
| || qualifiedName.equals("java.lang.Double") |
| || qualifiedName.equals("java.lang.Float")); |
| } |
| |
| /** |
| * Return true if this is an immutable type in the JDK. |
| * |
| * <p>This does not use immutability annotations and always returns false for user-defined |
| * classes. |
| */ |
| public static boolean isImmutableTypeInJdk(TypeMirror type) { |
| return isPrimitive(type) |
| || (type.getKind() == TypeKind.DECLARED |
| && ImmutableTypes.isImmutable(getQualifiedName((DeclaredType) type).toString())); |
| } |
| |
| /** |
| * Returns true if type represents a Throwable type (e.g. Exception, Error). |
| * |
| * @return true if type represents a Throwable type (e.g. Exception, Error) |
| */ |
| public static boolean isThrowable(TypeMirror type) { |
| while (type != null && type.getKind() == TypeKind.DECLARED) { |
| DeclaredType dt = (DeclaredType) type; |
| TypeElement elem = (TypeElement) dt.asElement(); |
| Name name = elem.getQualifiedName(); |
| if ("java.lang.Throwable".contentEquals(name)) { |
| return true; |
| } |
| type = elem.getSuperclass(); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true iff the argument is an anonymous type. |
| * |
| * @return whether the argument is an anonymous type |
| */ |
| public static boolean isAnonymous(TypeMirror type) { |
| return (type instanceof DeclaredType) |
| && ((TypeElement) ((DeclaredType) type).asElement()).getNestingKind() |
| == NestingKind.ANONYMOUS; |
| } |
| |
| /** |
| * Returns true iff the argument is a primitive type. |
| * |
| * @return whether the argument is a primitive type |
| */ |
| public static boolean isPrimitive(TypeMirror type) { |
| switch (type.getKind()) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Returns true iff the argument is a primitive type or a boxed primitive type. |
| * |
| * @param type a type |
| * @return true if the argument is a primitive type or a boxed primitive type |
| */ |
| public static boolean isPrimitiveOrBoxed(TypeMirror type) { |
| switch (type.getKind()) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| return true; |
| |
| case DECLARED: |
| String qualifiedName = getQualifiedName((DeclaredType) type).toString(); |
| return (qualifiedName.equals("java.lang.Boolean") |
| || qualifiedName.equals("java.lang.Byte") |
| || qualifiedName.equals("java.lang.Character") |
| || qualifiedName.equals("java.lang.Short") |
| || qualifiedName.equals("java.lang.Integer") |
| || qualifiedName.equals("java.lang.Long") |
| || qualifiedName.equals("java.lang.Double") |
| || qualifiedName.equals("java.lang.Float")); |
| |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Returns true iff the argument is a primitive numeric type. |
| * |
| * @param type a type |
| * @return true if the argument is a primitive numeric type |
| */ |
| public static boolean isNumeric(TypeMirror type) { |
| return TypeKindUtils.isNumeric(type.getKind()); |
| } |
| |
| /** The fully-qualified names of the numeric boxed types. */ |
| static final Set<@FullyQualifiedName String> numericBoxedTypes = |
| new HashSet<>( |
| Arrays.asList( |
| "java.lang.Byte", |
| "java.lang.Character", |
| "java.lang.Short", |
| "java.lang.Integer", |
| "java.lang.Long", |
| "java.lang.Double", |
| "java.lang.Float")); |
| |
| /** |
| * Returns true iff the argument is a boxed numeric type. |
| * |
| * @param type a type |
| * @return true if the argument is a boxed numeric type |
| */ |
| public static boolean isNumericBoxed(TypeMirror type) { |
| return type.getKind() == TypeKind.DECLARED |
| && numericBoxedTypes.contains(getQualifiedName((DeclaredType) type).toString()); |
| } |
| |
| /** |
| * Returns true iff the argument is an integral primitive type. |
| * |
| * @param type a type |
| * @return whether the argument is an integral primitive type |
| */ |
| public static boolean isIntegralPrimitive(TypeMirror type) { |
| switch (type.getKind()) { |
| case BYTE: |
| case CHAR: |
| case INT: |
| case LONG: |
| case SHORT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Return true if the argument TypeMirror is a (possibly boxed) integral type. |
| * |
| * @param type the type to inspect |
| * @return true if type is an integral type |
| */ |
| public static boolean isIntegralPrimitiveOrBoxed(TypeMirror type) { |
| TypeKind kind = TypeKindUtils.primitiveOrBoxedToTypeKind(type); |
| return kind != null && TypeKindUtils.isIntegral(kind); |
| } |
| |
| /** |
| * Returns true if declaredType is a Class that is used to box primitive type (e.g. |
| * declaredType=java.lang.Double and primitiveType=22.5d ) |
| * |
| * @param declaredType a type that might be a boxed type |
| * @param primitiveType a type that might be a primitive type |
| * @return true if {@code declaredType} is a box of {@code primitiveType} |
| */ |
| public static boolean isBoxOf(TypeMirror declaredType, TypeMirror primitiveType) { |
| if (declaredType.getKind() != TypeKind.DECLARED) { |
| return false; |
| } |
| |
| final String qualifiedName = getQualifiedName((DeclaredType) declaredType).toString(); |
| switch (primitiveType.getKind()) { |
| case BOOLEAN: |
| return qualifiedName.equals("java.lang.Boolean"); |
| case BYTE: |
| return qualifiedName.equals("java.lang.Byte"); |
| case CHAR: |
| return qualifiedName.equals("java.lang.Character"); |
| case DOUBLE: |
| return qualifiedName.equals("java.lang.Double"); |
| case FLOAT: |
| return qualifiedName.equals("java.lang.Float"); |
| case INT: |
| return qualifiedName.equals("java.lang.Integer"); |
| case LONG: |
| return qualifiedName.equals("java.lang.Long"); |
| case SHORT: |
| return qualifiedName.equals("java.lang.Short"); |
| |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Returns true iff the argument is a boxed floating point type. |
| * |
| * @param type type to test |
| * @return whether the argument is a boxed floating point type |
| */ |
| public static boolean isBoxedFloating(TypeMirror type) { |
| if (type.getKind() != TypeKind.DECLARED) { |
| return false; |
| } |
| |
| String qualifiedName = getQualifiedName((DeclaredType) type).toString(); |
| return qualifiedName.equals("java.lang.Double") || qualifiedName.equals("java.lang.Float"); |
| } |
| |
| /** |
| * Returns true iff the argument is a primitive floating point type. |
| * |
| * @param type type mirror |
| * @return whether the argument is a primitive floating point type |
| */ |
| public static boolean isFloatingPrimitive(TypeMirror type) { |
| switch (type.getKind()) { |
| case DOUBLE: |
| case FLOAT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Return true if the argument TypeMirror is a (possibly boxed) floating point type. |
| * |
| * @param type the type to inspect |
| * @return true if type is a floating point type |
| */ |
| public static boolean isFloatingPoint(TypeMirror type) { |
| TypeKind kind = TypeKindUtils.primitiveOrBoxedToTypeKind(type); |
| return kind != null && TypeKindUtils.isFloatingPoint(kind); |
| } |
| |
| /** |
| * Returns whether a TypeMirror represents a class type. |
| * |
| * @param type a type that might be a class type |
| * @return true if {@code} is a class type |
| */ |
| public static boolean isClassType(TypeMirror type) { |
| return (type instanceof Type.ClassType); |
| } |
| |
| /** |
| * Returns true if {@code type} has an enclosing type. |
| * |
| * @param type type to checker |
| * @return true if {@code type} has an enclosing type |
| */ |
| public static boolean hasEnclosingType(TypeMirror type) { |
| Type e = ((Type) type).getEnclosingType(); |
| return e.getKind() != TypeKind.NONE; |
| } |
| |
| /** |
| * Returns whether or not {@code type} is a functional interface type (as defined in JLS 9.8). |
| * |
| * @param type possible functional interface type |
| * @param env ProcessingEnvironment |
| * @return whether or not {@code type} is a functional interface type (as defined in JLS 9.8) |
| */ |
| public static boolean isFunctionalInterface(TypeMirror type, ProcessingEnvironment env) { |
| Context ctx = ((JavacProcessingEnvironment) env).getContext(); |
| com.sun.tools.javac.code.Types javacTypes = com.sun.tools.javac.code.Types.instance(ctx); |
| return javacTypes.isFunctionalInterface((Type) type); |
| } |
| |
| /// Type variables and wildcards |
| |
| /** |
| * If the argument is a bounded TypeVariable or WildcardType, return its non-variable, |
| * non-wildcard upper bound. Otherwise, return the type itself. |
| * |
| * @param type a type |
| * @return the non-variable, non-wildcard upper bound of a type, if it has one, or itself if it |
| * has no bounds |
| */ |
| public static TypeMirror upperBound(TypeMirror type) { |
| do { |
| if (type instanceof TypeVariable) { |
| TypeVariable tvar = (TypeVariable) type; |
| if (tvar.getUpperBound() != null) { |
| type = tvar.getUpperBound(); |
| } else { |
| break; |
| } |
| } else if (type instanceof WildcardType) { |
| WildcardType wc = (WildcardType) type; |
| if (wc.getExtendsBound() != null) { |
| type = wc.getExtendsBound(); |
| } else { |
| break; |
| } |
| } else { |
| break; |
| } |
| } while (true); |
| return type; |
| } |
| |
| /** |
| * Get the type parameter for this wildcard from the underlying type's bound field This field is |
| * sometimes null, in that case this method will return null. |
| * |
| * @return the TypeParameterElement the wildcard is an argument to, {@code null} otherwise |
| */ |
| public static @Nullable TypeParameterElement wildcardToTypeParam( |
| final Type.WildcardType wildcard) { |
| |
| final Element typeParamElement; |
| if (wildcard.bound != null) { |
| typeParamElement = wildcard.bound.asElement(); |
| } else { |
| typeParamElement = null; |
| } |
| |
| return (TypeParameterElement) typeParamElement; |
| } |
| |
| /** |
| * Version of com.sun.tools.javac.code.Types.wildUpperBound(Type) that works with both jdk8 |
| * (called upperBound there) and jdk8u. |
| */ |
| // TODO: contrast to upperBound. |
| public static Type wildUpperBound(TypeMirror tm, ProcessingEnvironment env) { |
| Type t = (Type) tm; |
| if (t.hasTag(TypeTag.WILDCARD)) { |
| Context context = ((JavacProcessingEnvironment) env).getContext(); |
| Type.WildcardType w = (Type.WildcardType) TypeAnnotationUtils.unannotatedType(t); |
| if (w.isSuperBound()) { // returns true if w is unbound |
| Symtab syms = Symtab.instance(context); |
| // w.bound is null if the wildcard is from bytecode. |
| return w.bound == null ? syms.objectType : w.bound.getUpperBound(); |
| } else { |
| return wildUpperBound(w.type, env); |
| } |
| } else { |
| return TypeAnnotationUtils.unannotatedType(t); |
| } |
| } |
| |
| /** |
| * Version of com.sun.tools.javac.code.Types.wildLowerBound(Type) that works with both jdk8 |
| * (called upperBound there) and jdk8u. |
| */ |
| public static Type wildLowerBound(TypeMirror tm, ProcessingEnvironment env) { |
| Type t = (Type) tm; |
| if (t.hasTag(TypeTag.WILDCARD)) { |
| Context context = ((JavacProcessingEnvironment) env).getContext(); |
| Symtab syms = Symtab.instance(context); |
| Type.WildcardType w = (Type.WildcardType) TypeAnnotationUtils.unannotatedType(t); |
| return w.isExtendsBound() ? syms.botType : wildLowerBound(w.type, env); |
| } else { |
| return TypeAnnotationUtils.unannotatedType(t); |
| } |
| } |
| |
| /** |
| * Given a bounded type (wildcard or typevar) get the concrete type of its upper bound. If the |
| * bounded type extends other bounded types, this method will iterate through their bounds until a |
| * class, interface, or intersection is found. |
| * |
| * @return a type that is not a wildcard or typevar, or {@code null} if this type is an unbounded |
| * wildcard |
| */ |
| public static @Nullable TypeMirror findConcreteUpperBound(final TypeMirror boundedType) { |
| TypeMirror effectiveUpper = boundedType; |
| outerLoop: |
| while (true) { |
| switch (effectiveUpper.getKind()) { |
| case WILDCARD: |
| effectiveUpper = ((javax.lang.model.type.WildcardType) effectiveUpper).getExtendsBound(); |
| if (effectiveUpper == null) { |
| return null; |
| } |
| break; |
| |
| case TYPEVAR: |
| effectiveUpper = ((TypeVariable) effectiveUpper).getUpperBound(); |
| break; |
| |
| default: |
| break outerLoop; |
| } |
| } |
| return effectiveUpper; |
| } |
| |
| /** |
| * Returns true if the erased type of subtype is a subtype of the erased type of supertype. |
| * |
| * @param subtype possible subtype |
| * @param supertype possible supertype |
| * @param types a Types object |
| * @return true if the erased type of subtype is a subtype of the erased type of supertype |
| */ |
| public static boolean isErasedSubtype(TypeMirror subtype, TypeMirror supertype, Types types) { |
| return types.isSubtype(types.erasure(subtype), types.erasure(supertype)); |
| } |
| |
| /** Returns whether a TypeVariable represents a captured type. */ |
| public static boolean isCaptured(TypeMirror typeVar) { |
| if (typeVar.getKind() != TypeKind.TYPEVAR) { |
| return false; |
| } |
| return ((Type.TypeVar) TypeAnnotationUtils.unannotatedType(typeVar)).isCaptured(); |
| } |
| |
| /** If typeVar is a captured wildcard, returns that wildcard; otherwise returns {@code null}. */ |
| public static @Nullable WildcardType getCapturedWildcard(TypeVariable typeVar) { |
| if (isCaptured(typeVar)) { |
| return ((CapturedType) TypeAnnotationUtils.unannotatedType(typeVar)).wildcard; |
| } |
| return null; |
| } |
| |
| /// Least upper bound and greatest lower bound |
| |
| /** |
| * Returns the least upper bound of two {@link TypeMirror}s, ignoring any annotations on the |
| * types. |
| * |
| * <p>Wrapper around Types.lub to add special handling for null types, primitives, and wildcards. |
| * |
| * @param tm1 a {@link TypeMirror} |
| * @param tm2 a {@link TypeMirror} |
| * @param processingEnv the {@link ProcessingEnvironment} to use |
| * @return the least upper bound of {@code tm1} and {@code tm2} |
| */ |
| public static TypeMirror leastUpperBound( |
| TypeMirror tm1, TypeMirror tm2, ProcessingEnvironment processingEnv) { |
| Type t1 = TypeAnnotationUtils.unannotatedType(tm1); |
| Type t2 = TypeAnnotationUtils.unannotatedType(tm2); |
| // Handle the 'null' type manually (not done by types.lub). |
| if (t1.getKind() == TypeKind.NULL) { |
| return t2; |
| } |
| if (t2.getKind() == TypeKind.NULL) { |
| return t1; |
| } |
| if (t1.getKind() == TypeKind.WILDCARD) { |
| WildcardType wc1 = (WildcardType) t1; |
| t1 = (Type) wc1.getExtendsBound(); |
| if (t1 == null) { |
| // Implicit upper bound of java.lang.Object |
| Elements elements = processingEnv.getElementUtils(); |
| return elements.getTypeElement("java.lang.Object").asType(); |
| } |
| } |
| if (t2.getKind() == TypeKind.WILDCARD) { |
| WildcardType wc2 = (WildcardType) t2; |
| t2 = (Type) wc2.getExtendsBound(); |
| if (t2 == null) { |
| // Implicit upper bound of java.lang.Object |
| Elements elements = processingEnv.getElementUtils(); |
| return elements.getTypeElement("java.lang.Object").asType(); |
| } |
| } |
| JavacProcessingEnvironment javacEnv = (JavacProcessingEnvironment) processingEnv; |
| com.sun.tools.javac.code.Types types = |
| com.sun.tools.javac.code.Types.instance(javacEnv.getContext()); |
| if (types.isSameType(t1, t2)) { |
| // Special case if the two types are equal. |
| return t1; |
| } |
| // Special case for primitives. |
| if (isPrimitive(t1) || isPrimitive(t2)) { |
| if (types.isAssignable(t1, t2)) { |
| return t2; |
| } else if (types.isAssignable(t2, t1)) { |
| return t1; |
| } else { |
| Elements elements = processingEnv.getElementUtils(); |
| return elements.getTypeElement("java.lang.Object").asType(); |
| } |
| } |
| return types.lub(t1, t2); |
| } |
| |
| /** |
| * Returns the greatest lower bound of two {@link TypeMirror}s, ignoring any annotations on the |
| * types. |
| * |
| * <p>Wrapper around Types.glb to add special handling for null types, primitives, and wildcards. |
| * |
| * @param tm1 a {@link TypeMirror} |
| * @param tm2 a {@link TypeMirror} |
| * @param processingEnv the {@link ProcessingEnvironment} to use |
| * @return the greatest lower bound of {@code tm1} and {@code tm2} |
| */ |
| public static TypeMirror greatestLowerBound( |
| TypeMirror tm1, TypeMirror tm2, ProcessingEnvironment processingEnv) { |
| Type t1 = TypeAnnotationUtils.unannotatedType(tm1); |
| Type t2 = TypeAnnotationUtils.unannotatedType(tm2); |
| JavacProcessingEnvironment javacEnv = (JavacProcessingEnvironment) processingEnv; |
| com.sun.tools.javac.code.Types types = |
| com.sun.tools.javac.code.Types.instance(javacEnv.getContext()); |
| if (types.isSameType(t1, t2)) { |
| // Special case if the two types are equal. |
| return t1; |
| } |
| // Handle the 'null' type manually. |
| if (t1.getKind() == TypeKind.NULL) { |
| return t1; |
| } |
| if (t2.getKind() == TypeKind.NULL) { |
| return t2; |
| } |
| // Special case for primitives. |
| if (isPrimitive(t1) || isPrimitive(t2)) { |
| if (types.isAssignable(t1, t2)) { |
| return t1; |
| } else if (types.isAssignable(t2, t1)) { |
| return t2; |
| } else { |
| // Javac types.glb returns TypeKind.Error when the GLB does |
| // not exist, but we can't create one. Use TypeKind.NONE |
| // instead. |
| return processingEnv.getTypeUtils().getNoType(TypeKind.NONE); |
| } |
| } |
| if (t1.getKind() == TypeKind.WILDCARD) { |
| return t2; |
| } |
| if (t2.getKind() == TypeKind.WILDCARD) { |
| return t1; |
| } |
| |
| // If neither type is a primitive type, null type, or wildcard |
| // and if the types are not the same, use javac types.glb |
| return types.glb(t1, t2); |
| } |
| |
| /** |
| * Returns the most specific type from the list, or null if none exists. |
| * |
| * @param typeMirrors a list of types |
| * @param processingEnv the {@link ProcessingEnvironment} to use |
| * @return the most specific of the types, or null if none exists |
| */ |
| public static @Nullable TypeMirror mostSpecific( |
| List<TypeMirror> typeMirrors, ProcessingEnvironment processingEnv) { |
| if (typeMirrors.size() == 1) { |
| return typeMirrors.get(0); |
| } else { |
| JavacProcessingEnvironment javacEnv = (JavacProcessingEnvironment) processingEnv; |
| com.sun.tools.javac.code.Types types = |
| com.sun.tools.javac.code.Types.instance(javacEnv.getContext()); |
| com.sun.tools.javac.util.List<Type> typeList = typeMirrorListToTypeList(typeMirrors); |
| Type glb = types.glb(typeList); |
| for (Type candidate : typeList) { |
| if (types.isSameType(glb, candidate)) { |
| return candidate; |
| } |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * Given a list of TypeMirror, return a list of Type. |
| * |
| * @param typeMirrors a list of TypeMirrors |
| * @return the argument, converted to a javac list |
| */ |
| private static com.sun.tools.javac.util.List<Type> typeMirrorListToTypeList( |
| List<TypeMirror> typeMirrors) { |
| List<Type> typeList = CollectionsPlume.mapList(Type.class::cast, typeMirrors); |
| return com.sun.tools.javac.util.List.from(typeList); |
| } |
| |
| /// Substitutions |
| |
| /** |
| * Returns the return type of a method, given the receiver of the method call. |
| * |
| * @param methodElement a method |
| * @param substitutedReceiverType the receiver type, after substitution |
| * @param env the environment |
| * @return the return type of the method |
| */ |
| public static TypeMirror substituteMethodReturnType( |
| Element methodElement, TypeMirror substitutedReceiverType, ProcessingEnvironment env) { |
| |
| com.sun.tools.javac.code.Types types = |
| com.sun.tools.javac.code.Types.instance(InternalUtils.getJavacContext(env)); |
| |
| Type substitutedMethodType = |
| types.memberType((Type) substitutedReceiverType, (Symbol) methodElement); |
| return substitutedMethodType.getReturnType(); |
| } |
| |
| /** |
| * Returns {@code type} as {@code superType} if {@code superType} is a super type of {@code type}; |
| * otherwise, null. |
| * |
| * @return {@code type} as {@code superType} if {@code superType} is a super type of {@code type}; |
| * otherwise, null |
| */ |
| public static TypeMirror asSuper( |
| TypeMirror type, TypeMirror superType, ProcessingEnvironment env) { |
| Context ctx = ((JavacProcessingEnvironment) env).getContext(); |
| com.sun.tools.javac.code.Types javacTypes = com.sun.tools.javac.code.Types.instance(ctx); |
| return javacTypes.asSuper((Type) type, ((Type) superType).tsym); |
| } |
| |
| /** |
| * Returns the superclass of the given class. Returns null if there is not one. |
| * |
| * @param type a type |
| * @param types type utilities |
| * @return the superclass of the given class, or null |
| */ |
| public static @Nullable TypeMirror getSuperclass(TypeMirror type, Types types) { |
| List<? extends TypeMirror> superTypes = types.directSupertypes(type); |
| for (TypeMirror t : superTypes) { |
| // ignore interface types |
| if (!(t instanceof ClassType)) { |
| continue; |
| } |
| ClassType tt = (ClassType) t; |
| if (!tt.isInterface()) { |
| return t; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the type of primitive conversion from {@code from} to {@code to}. |
| * |
| * @param from a primitive type |
| * @param to a primitive type |
| * @return the type of primitive conversion from {@code from} to {@code to} |
| */ |
| public static TypeKindUtils.PrimitiveConversionKind getPrimitiveConversionKind( |
| PrimitiveType from, PrimitiveType to) { |
| return TypeKindUtils.getPrimitiveConversionKind(from.getKind(), to.getKind()); |
| } |
| |
| /** |
| * Returns a new type mirror with the same type as {@code type} where all the type variables in |
| * {@code typeVariables} have been substituted with the type arguments in {@code typeArgs}. |
| * |
| * <p>This is a wrapper around {@link com.sun.tools.javac.code.Types#subst(Type, |
| * com.sun.tools.javac.util.List, com.sun.tools.javac.util.List)}. |
| * |
| * @param type type to do substitution in |
| * @param typeVariables type variables that should be replaced with the type mirror at the same |
| * index of {@code typeArgs} |
| * @param typeArgs type mirrors that should replace the type variable at the same index of {@code |
| * typeVariables} |
| * @param env processing environment |
| * @return a new type mirror with the same type as {@code type} where all the type variables in |
| * {@code typeVariables} have been substituted with the type arguments in {@code typeArgs} |
| */ |
| public static TypeMirror substitute( |
| TypeMirror type, |
| List<? extends TypeMirror> typeVariables, |
| List<? extends TypeMirror> typeArgs, |
| ProcessingEnvironment env) { |
| |
| List<Type> newP = CollectionsPlume.mapList(Type.class::cast, typeVariables); |
| |
| List<Type> newT = CollectionsPlume.mapList(Type.class::cast, typeArgs); |
| |
| JavacProcessingEnvironment javacEnv = (JavacProcessingEnvironment) env; |
| com.sun.tools.javac.code.Types types = |
| com.sun.tools.javac.code.Types.instance(javacEnv.getContext()); |
| return types.subst( |
| (Type) type, |
| com.sun.tools.javac.util.List.from(newP), |
| com.sun.tools.javac.util.List.from(newT)); |
| } |
| |
| /** |
| * Returns the depth of an array type. |
| * |
| * @param arrayType an array type |
| * @return the depth of {@code arrayType} |
| */ |
| public static int getArrayDepth(TypeMirror arrayType) { |
| int counter = 0; |
| TypeMirror type = arrayType; |
| while (type.getKind() == TypeKind.ARRAY) { |
| counter++; |
| type = ((ArrayType) type).getComponentType(); |
| } |
| return counter; |
| } |
| } |
