checkers.types

Class AnnotatedTypes

@NonNull java.lang.Object

checkers.types.AnnotatedTypes

public class AnnotatedTypes
extends @NonNull Object

Utility methods for operating on AnnotatedTypeMirror. This class mimics the class Types.

Constructor Summary

Constructors

Constructor and Description
AnnotatedTypes(ProcessingEnvironment env, AnnotatedTypeFactory factory) Constructor for AnnotatedTypes

Method Summary

Methods

Modifier and Type	Method and Description
void	annotateAsLub(@Mutable AnnotatedTypeMirror lub, Collection<@Mutable AnnotatedTypeMirror> types) Annotate the lub type as if it is the least upper bound of the rest of the types.
boolean	areSame(@Mutable AnnotatedTypeMirror t1, @Mutable AnnotatedTypeMirror t2)
@Mutable AnnotatedTypeMirror	asMemberOf(@Mutable AnnotatedTypeMirror t, @Nullable Element elem) Returns the type of an element when that element is viewed as a member of, or otherwise directly contained by, a given type.
AnnotatedTypeMirror.AnnotatedExecutableType	asMemberOf(@Mutable AnnotatedTypeMirror t, @NonNull ExecutableElement elem)
@Mutable AnnotatedTypeMirror	assignedTo(@Nullable TreePath path) Returns the annotated type that the leaf of path is assigned to, if it is within an assignment context Returns the annotated type that the method invocation at the leaf is assigned to.
@Mutable AnnotatedTypeMirror	asSuper(@Mutable AnnotatedTypeMirror t, @Mutable AnnotatedTypeMirror superType) Returns the most specific base type of t whose erasure type is superType.
static boolean	containsModifier(@Mutable AnnotatedTypeMirror type, @Nullable AnnotationMirror modifier) Checks whether type contains the given modifier, also recursively in type arguments and arrays.
static boolean	containsTypeAnnotation(Collection<? extends @Nullable AnnotationMirror> annos)
static <ATM extends @Mutable AnnotatedTypeMirror> ATM	deepCopy(ATM type) Returns a deep copy of the passed type.
List<@Mutable AnnotatedTypeMirror>	expandVarArgs(AnnotatedTypeMirror.AnnotatedExecutableType method, List<? extends ExpressionTree> args) Returns the method parameters for the invoked method, with the same number of arguments passed in the methodInvocation tree.
Map<AnnotatedTypeMirror.AnnotatedTypeVariable,@Mutable AnnotatedTypeMirror>	findTypeArguments(ExpressionTree expr) Given a method or constructor invocation, return a mapping of the type variables to their type arguments, if any exist.
List<@Mutable AnnotatedTypeMirror>	getAnnotatedTypes(List<@Mutable AnnotatedTypeMirror> paramTypes, List<? extends ExpressionTree> trees) Return a list of the AnnotatedTypeMirror of the passed expression trees, in the same order as the trees.
int	getArrayDepth(AnnotatedTypeMirror.AnnotatedArrayType array) Returns the depth of the array type of the provided array.
@Mutable AnnotatedTypeMirror	getIteratedType(@Mutable AnnotatedTypeMirror iterableType) Returns the iterated type of the passed iterable type, and throws IllegalArgumentException if the passed type is not iterable.
Set<AnnotatedTypeMirror.AnnotatedDeclaredType>	getSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type) Returns all the super types of the given declared type.
static @Mutable AnnotatedTypeMirror	innerMostType(@Mutable AnnotatedTypeMirror t)
boolean	isAnonymousType(@Mutable AnnotatedTypeMirror type) Determines if the type is for an anonymous type or not
boolean	isIntersectType(@Mutable AnnotatedTypeMirror type) Determines if the type is for an intersect type or not
static boolean	isTypeAnnotation(@Nullable AnnotationMirror anno)
Map<AnnotatedTypeMirror.AnnotatedDeclaredType,@NonNull ExecutableElement>	overriddenMethods(@NonNull ExecutableElement method) A utility method that takes a Method element and returns a set of all elements that this method overrides (as ExecutableElements)
Map<AnnotatedTypeMirror.AnnotatedDeclaredType,@NonNull ExecutableElement>	overriddenMethods(@NonNull ExecutableElement method, Collection<AnnotatedTypeMirror.AnnotatedDeclaredType> supertypes) A utility method that takes the element for a method and the set of all supertypes of the method's containing class and returns the set of all elements that method overrides (as ExecutableElements).
@Mutable AnnotatedTypeMirror	subst(@Mutable AnnotatedTypeMirror t, List<? extends @Mutable AnnotatedTypeMirror> from, List<? extends @Mutable AnnotatedTypeMirror> to) Returns a new type, a copy of the passed t, with all instances of from type substituted with their correspondents in to.
@ReadOnly String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

AnnotatedTypes

public AnnotatedTypes(ProcessingEnvironment env,
              AnnotatedTypeFactory factory)

Constructor for AnnotatedTypes

Parameters:

env - the processing environment for this round

Method Detail

toString

public @ReadOnly String toString()

Overrides:

toString in class @NonNull Object

asSuper

public @Mutable AnnotatedTypeMirror asSuper(@Mutable AnnotatedTypeMirror t,
                                   @Mutable AnnotatedTypeMirror superType)

Returns the most specific base type of t whose erasure type is superType. It returns null if t is not a subtype of superType.

Parameters:

t - a type

superType - a type that is a supertype of t

Returns:

the base type of t of the given element

asMemberOf

public AnnotatedTypeMirror.AnnotatedExecutableType asMemberOf(@Mutable AnnotatedTypeMirror t,
                                                     @NonNull ExecutableElement elem)

See Also:

asMemberOf(AnnotatedTypeMirror, Element)

asMemberOf

public @Mutable AnnotatedTypeMirror asMemberOf(@Mutable AnnotatedTypeMirror t,
                                      @Nullable Element elem)

Returns the type of an element when that element is viewed as a member of, or otherwise directly contained by, a given type. For example, when viewed as a member of the parameterized type Set<@NonNull String>, the Set.add method is an ExecutableType whose parameter is of type @NonNull String. The result is customized according to the type system semantics, according to AnnotatedTypeFactory.postAsMemberOf( AnnotatedTypeMirror, AnnotatedTypeMirror, Element).

Parameters:

t - a type

elem - an element

subst

public @Mutable AnnotatedTypeMirror subst(@Mutable AnnotatedTypeMirror t,
                                 List<? extends @Mutable AnnotatedTypeMirror> from,
                                 List<? extends @Mutable AnnotatedTypeMirror> to)

Returns a new type, a copy of the passed t, with all instances of from type substituted with their correspondents in to.

Parameters:

t - the type

from - the from types

to - the to types

Returns:

the new type after substitutions

deepCopy

public static <ATM extends @Mutable AnnotatedTypeMirror> ATM deepCopy(ATM type)

Returns a deep copy of the passed type.

Parameters:

type - the annotated type to be copied

Returns:

a deep copy of the passed type

getIteratedType

public @Mutable AnnotatedTypeMirror getIteratedType(@Mutable AnnotatedTypeMirror iterableType)

Returns the iterated type of the passed iterable type, and throws IllegalArgumentException if the passed type is not iterable. The iterated type is the component type of an array, and the type argument of Iterable for declared types.

Parameters:

iterableType - the iterable type (either array or declared)

Returns:

the types of elements in the iterable type

getSuperTypes

public Set<AnnotatedTypeMirror.AnnotatedDeclaredType> getSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type)

Returns all the super types of the given declared type.

Parameters:

type - a declared type

Returns:

all the supertypes of the given type

overriddenMethods

public Map<AnnotatedTypeMirror.AnnotatedDeclaredType,@NonNull ExecutableElement> overriddenMethods(@NonNull ExecutableElement method)

A utility method that takes a Method element and returns a set of all elements that this method overrides (as ExecutableElements)

Parameters:

method - the overriding method

Returns:

an unmodifiable set of ExecutableElements representing the elements that method overrides

overriddenMethods

public Map<AnnotatedTypeMirror.AnnotatedDeclaredType,@NonNull ExecutableElement> overriddenMethods(@NonNull ExecutableElement method,
                                                                                          Collection<AnnotatedTypeMirror.AnnotatedDeclaredType> supertypes)

A utility method that takes the element for a method and the set of all supertypes of the method's containing class and returns the set of all elements that method overrides (as ExecutableElements).

Parameters:

method - the overriding method

supertypes - the set of supertypes to check for methods that are overridden by method

Returns:

an unmodified set of ExecutableElements representing the elements that method overrides among supertypes

findTypeArguments

public Map<AnnotatedTypeMirror.AnnotatedTypeVariable,@Mutable AnnotatedTypeMirror> findTypeArguments(ExpressionTree expr)

Given a method or constructor invocation, return a mapping of the type variables to their type arguments, if any exist. It uses the method or constructor invocation type arguments if they were specified and otherwise it infers them based on the passed arguments or the return type context, according to JLS 15.12.2.

Parameters:

expr - the method or constructor invocation tree; the passed argument has to be a subtype of MethodInvocationTree or NewClassTree.

Returns:

the mapping of the type variables to type arguments for this method or constructor invocation.

assignedTo

public @Mutable AnnotatedTypeMirror assignedTo(@Nullable TreePath path)

Returns the annotated type that the leaf of path is assigned to, if it is within an assignment context Returns the annotated type that the method invocation at the leaf is assigned to.

Parameters:

path -

Returns:

type that it path leaf is assigned to

isAnonymousType

public boolean isAnonymousType(@Mutable AnnotatedTypeMirror type)

Determines if the type is for an anonymous type or not

Parameters:

type - type to be checked

Returns:

true iff type is an anonymous type

isIntersectType

public boolean isIntersectType(@Mutable AnnotatedTypeMirror type)

Determines if the type is for an intersect type or not

Parameters:

type - type to be checked

Returns:

true iff type is an intersect type

annotateAsLub

public void annotateAsLub(@Mutable AnnotatedTypeMirror lub,
                 Collection<@Mutable AnnotatedTypeMirror> types)

Annotate the lub type as if it is the least upper bound of the rest of the types. This is a useful method for finding conditional expression types. All the types need to be subtypes of lub.

Parameters:

lub - the type to be the least upper bound

types - the type arguments

expandVarArgs

public List<@Mutable AnnotatedTypeMirror> expandVarArgs(AnnotatedTypeMirror.AnnotatedExecutableType method,
                                               List<? extends ExpressionTree> args)

Returns the method parameters for the invoked method, with the same number of arguments passed in the methodInvocation tree. If the invoked method is not a vararg method or it is a vararg method but the invocation passes an array to the vararg parameter, it would simply return the method parameters. Otherwise, it would return the list of parameters as if the vararg is expanded to match the size of the passed arguments.

Parameters:

method - the method's type

args - the arguments to the method invocation

Returns:

the types that the method invocation arguments need to be subtype of

getAnnotatedTypes

public List<@Mutable AnnotatedTypeMirror> getAnnotatedTypes(List<@Mutable AnnotatedTypeMirror> paramTypes,
                                                   List<? extends ExpressionTree> trees)

Return a list of the AnnotatedTypeMirror of the passed expression trees, in the same order as the trees.

Parameters:

paramTypes - The parameter types to use as assignment context

trees - the AST nodes

Returns:

a list with the AnnotatedTypeMirror of each tree in trees.

areSame

public boolean areSame(@Mutable AnnotatedTypeMirror t1,
              @Mutable AnnotatedTypeMirror t2)

getArrayDepth

public int getArrayDepth(AnnotatedTypeMirror.AnnotatedArrayType array)

Returns the depth of the array type of the provided array.

Parameters:

array - the type of the array

Returns:

the depth of the provided array

innerMostType

public static @Mutable AnnotatedTypeMirror innerMostType(@Mutable AnnotatedTypeMirror t)

containsModifier

public static boolean containsModifier(@Mutable AnnotatedTypeMirror type,
                       @Nullable AnnotationMirror modifier)

Checks whether type contains the given modifier, also recursively in type arguments and arrays. This method might be easier to implement directly as instance method in AnnotatedTypeMirror; it corresponds to a "deep" version of AnnotatedTypeMirror.hasAnnotation(AnnotationMirror).

Parameters:

type - the type to search.

modifier - the modifier to search for.

Returns:

whether the type contains the modifier.

isTypeAnnotation

public static boolean isTypeAnnotation(@Nullable AnnotationMirror anno)

containsTypeAnnotation

public static boolean containsTypeAnnotation(Collection<? extends @Nullable AnnotationMirror> annos)