checkers.types

Class AnnotatedTypeFactory

@NonNull java.lang.Object

checkers.types.AnnotatedTypeFactory

Direct Known Subclasses:

BasicAnnotatedTypeFactory, GeneralAnnotatedTypeFactory, JavariAnnotatedTypeFactory

public class AnnotatedTypeFactory
extends @NonNull Object

The methods of this class take an element or AST node, and return the annotated type as an AnnotatedTypeMirror. The methods are:

• getAnnotatedType(ClassTree)
• getAnnotatedType(MethodTree)
• getAnnotatedType(Tree)
• getAnnotatedTypeFromTypeTree(Tree)
• getAnnotatedType(TypeElement)
• getAnnotatedType(ExecutableElement)
• getAnnotatedType(Element)

This implementation only adds qualifiers explicitly specified by the programmer. Type system checker writers may need to subclass this class, to add implicit and default qualifiers according to the type system semantics. Subclasses should especially override annotateImplicit(Element, AnnotatedTypeMirror) and annotateImplicit(Tree, AnnotatedTypeMirror).

See the Checker Framework manual:

How to write a checker plug-in

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	AnnotatedTypeFactory.InheritedFromClassAnnotator A singleton utility class for pulling annotations down from a class type.

Field Summary

Fields

Modifier and Type	Field and Description
protected AnnotationUtils	annotations The factory to use for creating annotations.
protected AnnotatedTypes	atypes Utility class for manipulating annotated types.
protected Elements	elements Utility class for working with Elements.
protected ProcessingEnvironment	env The processing environment to use for accessing compiler internals.
protected Map<@Nullable Tree,@Mutable AnnotatedTypeMirror>	fromTreeCache Mapping from a Tree to its annotated type; before implicits are applied, just what the programmer wrote.
protected QualifierHierarchy	qualHierarchy Represent the annotation relations.
protected @Nullable CompilationUnitTree	root Optional! The AST of the source file being operated on.
protected Trees	trees The Trees instance to use for tree node path finding.
protected Types	types Utility class for working with TypeMirrors.
int	uid Unique ID of the current object; for debugging purposes.
protected VisitorState	visitorState The state of the visitor.

Constructor Summary

Constructors

Constructor and Description
AnnotatedTypeFactory(SourceChecker checker, QualifierHierarchy qualHierarchy, @Nullable CompilationUnitTree root) Constructs a factory from the given ProcessingEnvironment instance and syntax tree root.

Method Summary

Methods

Modifier and Type	Method and Description
protected void	addAliasedAnnotation(Class<?> clazz, @Nullable AnnotationMirror type) Add the annotation clazz as an alias for the annotation type.
@Nullable AnnotationMirror	aliasedAnnotation(@Nullable AnnotationMirror a) Returns the canonical annotation for the passed annotation if it is an alias of a canonical one in the framework.
protected void	annotateImplicit(@Nullable Element elt, @Mutable AnnotatedTypeMirror type) Adds implicit annotations to a type obtained from a Element.
protected void	annotateImplicit(@Nullable Tree tree, @Mutable AnnotatedTypeMirror type) Adds implicit annotations to a type obtained from a Tree.
protected void	annotateInheritedFromClass(@Mutable AnnotatedTypeMirror type) Adds annotations to the type based on the annotations from its class type if and only if no annotations are already present on the type.
boolean	canHaveAnnotatedTypeParameters() For an annotated type parameter or wildcard (e.g.
Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<@Mutable AnnotatedTypeMirror>>	constructorFromUse(NewClassTree tree) Determines the AnnotatedTypeMirror.AnnotatedExecutableType of a constructor invocation.
protected static <K extends @NonNull Object,V extends @NonNull Object> Map<K,V>	createLRUCache(int size) A Utility method for creating LRU cache
protected @Nullable Tree	declarationFromElement(@Nullable Element elt) Gets the declaration tree for the element, if the source is available.
AnnotatedTypeMirror.AnnotatedDeclaredType	fromClass(@Nullable ClassTree tree) Determines the annotated type of a class from its declaration.
@Mutable AnnotatedTypeMirror	fromElement(@Nullable Element elt) Determines the annotated type of an element.
AnnotatedTypeMirror.AnnotatedExecutableType	fromElement(@NonNull ExecutableElement elt)
AnnotatedTypeMirror.AnnotatedDeclaredType	fromElement(TypeElement elt)
@Mutable AnnotatedTypeMirror	fromExpression(ExpressionTree tree) Determines the annotated type of an expression.
@Mutable AnnotatedTypeMirror	fromMember(@Nullable Tree tree) Determines the annotated type of a variable or method declaration.
AnnotatedTypeMirror.AnnotatedDeclaredType	fromNewClass(NewClassTree tree)
@Mutable AnnotatedTypeMirror	fromTypeTree(@Nullable Tree tree) Determines the annotated type from a type in tree form.
AnnotatedTypeMirror.AnnotatedDeclaredType	getAnnotatedType(@Nullable ClassTree tree)
@Mutable AnnotatedTypeMirror	getAnnotatedType(@Nullable Element elt) Determines the annotated type of an element using fromElement(Element).
AnnotatedTypeMirror.AnnotatedExecutableType	getAnnotatedType(@NonNull ExecutableElement elt)
AnnotatedTypeMirror.AnnotatedExecutableType	getAnnotatedType(@Nullable MethodTree tree)
AnnotatedTypeMirror.AnnotatedArrayType	getAnnotatedType(NewArrayTree tree)
AnnotatedTypeMirror.AnnotatedDeclaredType	getAnnotatedType(NewClassTree tree)
@Mutable AnnotatedTypeMirror	getAnnotatedType(@Nullable Tree tree) Determines the annotated type of an AST node.
AnnotatedTypeMirror.AnnotatedDeclaredType	getAnnotatedType(TypeElement elt)
@Mutable AnnotatedTypeMirror	getAnnotatedTypeFromTypeTree(@Nullable Tree tree) Determines the annotated type from a type in tree form.
AnnotatedTypeMirror.AnnotatedDeclaredType	getBoxedType(AnnotatedTypeMirror.AnnotatedPrimitiveType type) returns the annotated boxed type of the given primitive type.
protected @Nullable ClassTree	getCurrentClassTree(@Nullable Tree tree) Returns the current class type being visited by the visitor.
protected AnnotatedTypeMirror.AnnotatedDeclaredType	getCurrentClassType(@Nullable Tree tree)
protected AnnotatedTypeMirror.AnnotatedDeclaredType	getCurrentMethodReceiver(@Nullable Tree tree) Returns the receiver type of the current method being visited, and returns null if the visited tree is not within a method.
@Nullable AnnotationMirror	getDeclAnnotation(@Nullable Element elt, Class<? extends Annotation> anno) Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
@Mutable AnnotatedTypeMirror	getDefaultedAnnotatedType(@Nullable Tree tree) Get the defaulted type of a variable, without considering flow inference from the initializer expression.
AnnotatedTypeMirror.AnnotatedDeclaredType	getEnclosingType(TypeElement element, @Nullable Tree tree) Determine the type of the most enclosing class of the given tree that is a subtype of the given element.
protected AnnotatedTypeMirror.AnnotatedDeclaredType	getImplicitReceiverType(ExpressionTree tree) Return the implicit receiver type of an expression tree.
@Nullable TreePath	getPath(@Nullable Tree node) Gets the path for the given Tree under the current root by checking from the visitor's current path, and only using Trees.getPath(CompilationUnitTree, Tree) (which is much slower) only if node is not found on the current path.
QualifierHierarchy	getQualifierHierarchy()
@Mutable AnnotatedTypeMirror	getReceiverType(ExpressionTree expression) Returns the receiver type of the expression tree, or null if it does not exist.
AnnotatedTypeMirror.AnnotatedDeclaredType	getSelfType(@Nullable Tree tree) Returns the type of this in the current location, which can be used if this has a special semantics (e.g.
AnnotatedTypeMirror.AnnotatedPrimitiveType	getUnboxedType(AnnotatedTypeMirror.AnnotatedDeclaredType type) returns the annotated primitive type of the given declared type if it is a boxed declared type.
VisitorState	getVisitorState() Returns the VisitorState instance used by the factory to infer types
boolean	isAnyEnclosingThisDeref(ExpressionTree tree) Does this expression have (the innermost or an outer) "this" as receiver? Note that the receiver can be either explicit or implicit.
boolean	isMostEnclosingThisDeref(ExpressionTree tree) Determine whether the tree dereferences the most enclosing "this" object.
boolean	isSupportedQualifier(@Nullable AnnotationMirror a) Determines whether the given annotation is a part of the type system under which this type factory operates.
protected boolean	isWithinConstructor(@Nullable Tree tree)
Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<@Mutable AnnotatedTypeMirror>>	methodFromUse(MethodInvocationTree tree) Determines the type of the invoked method based on the passed method invocation tree.
protected void	postAsMemberOf(@Mutable AnnotatedTypeMirror type, @Mutable AnnotatedTypeMirror owner, @Nullable Element element) A callback method for the AnnotatedTypeFactory subtypes to customize AnnotatedTypes.asMemberOf().
protected void	postDirectSuperTypes(@Mutable AnnotatedTypeMirror type, List<? extends @Mutable AnnotatedTypeMirror> supertypes) A callback method for the AnnotatedTypeFactory subtypes to customize directSuperTypes().
protected void	postInit() Actions that logically belong in the constructor, but need to run after the subclass constructor has completed.
@Mutable AnnotatedTypeMirror	toAnnotatedType(TypeMirror t) A convenience method that converts a TypeMirror to an AnnotatedTypeMirror using AnnotatedTypeMirror.createType(javax.lang.model.type.TypeMirror, javax.annotation.processing.ProcessingEnvironment, checkers.types.AnnotatedTypeFactory).
@ReadOnly String	toString()
List<AnnotatedTypeMirror.AnnotatedTypeVariable>	typeVariablesFromUse(AnnotatedTypeMirror.AnnotatedDeclaredType type, TypeElement element) Adapt the upper bounds of the type variables of a class relative to the type instantiation.
protected Collection<@Nullable AnnotationMirror>	unify(Collection<@Nullable AnnotationMirror> c1, Collection<@Nullable AnnotationMirror> c2) Returns the type qualifiers that are least upper bound for c1 and c2 qualifiers.

Methods inherited from class java.lang.Object

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

Field Detail

trees

protected final Trees trees

The Trees instance to use for tree node path finding.

root

protected final @Nullable CompilationUnitTree root

Optional! The AST of the source file being operated on.

env

protected final ProcessingEnvironment env

The processing environment to use for accessing compiler internals.

annotations

protected final AnnotationUtils annotations

The factory to use for creating annotations.

elements

protected final Elements elements

Utility class for working with Elements.

types

protected final Types types

Utility class for working with TypeMirrors.

atypes

protected final AnnotatedTypes atypes

Utility class for manipulating annotated types.

visitorState

protected final VisitorState visitorState

The state of the visitor.

qualHierarchy

protected final QualifierHierarchy qualHierarchy

Represent the annotation relations.

uid

public final int uid

Unique ID of the current object; for debugging purposes.

fromTreeCache

protected final Map<@Nullable Tree,@Mutable AnnotatedTypeMirror> fromTreeCache

Mapping from a Tree to its annotated type; before implicits are applied, just what the programmer wrote.

Constructor Detail

AnnotatedTypeFactory

public AnnotatedTypeFactory(SourceChecker checker,
                    QualifierHierarchy qualHierarchy,
                    @Nullable CompilationUnitTree root)

Constructs a factory from the given ProcessingEnvironment instance and syntax tree root. (These parameters are required so that the factory may conduct the appropriate annotation-gathering analyses on certain tree types.) Root can be null if the factory does not operate on trees. A subclass must call postInit at the end of its constructor.

Parameters:

checker - the SourceChecker to which this factory belongs

root - the root of the syntax tree that this factory produces annotated types for

Throws:

IllegalArgumentException - if either argument is null

Method Detail

postInit

protected void postInit()

Actions that logically belong in the constructor, but need to run after the subclass constructor has completed. In particular, buildIndexTypes may try to do type resolution with this AnnotatedTypeFactory.

toString

public @ReadOnly String toString()

Overrides:

toString in class @NonNull Object

canHaveAnnotatedTypeParameters

public boolean canHaveAnnotatedTypeParameters()

For an annotated type parameter or wildcard (e.g. <@Nullable T>, it returns true if the annotation should target the type parameter itself, otherwise the annotation should target the extends clause, i.e. the declaration should be treated as <T extends @Nullable Object>

getAnnotatedType

public @Mutable AnnotatedTypeMirror getAnnotatedType(@Nullable Element elt)

Determines the annotated type of an element using fromElement(Element).

Parameters:

elt - the element

Returns:

the annotated type of elt

Throws:

IllegalArgumentException - if elt is null

See Also:

fromElement(Element)

getAnnotatedType

public @Mutable AnnotatedTypeMirror getAnnotatedType(@Nullable Tree tree)

Determines the annotated type of an AST node.

The type is determined as follows:

• if tree is a class declaration, determine its type via fromClass(com.sun.source.tree.ClassTree)
• if tree is a method or variable declaration, determine its type via fromMember(Tree)
• if tree is an ExpressionTree, determine its type via fromExpression(ExpressionTree)
• otherwise, throw an UnsupportedOperationException

Parameters:

tree - the AST node

Returns:

the annotated type of tree

See Also:

fromClass(ClassTree), fromMember(Tree), fromExpression(ExpressionTree)

getDefaultedAnnotatedType

public @Mutable AnnotatedTypeMirror getDefaultedAnnotatedType(@Nullable Tree tree)

Get the defaulted type of a variable, without considering flow inference from the initializer expression. This is needed to determine the type of the assignment context, which should have the "default" meaning, without flow inference. TODO: describe and generalize

getAnnotatedTypeFromTypeTree

public @Mutable AnnotatedTypeMirror getAnnotatedTypeFromTypeTree(@Nullable Tree tree)

Determines the annotated type from a type in tree form.

Parameters:

tree - the type tree

Returns:

the annotated type of the type in the AST

fromElement

public @Mutable AnnotatedTypeMirror fromElement(@Nullable Element elt)

Determines the annotated type of an element.

Parameters:

elt - the element

Returns:

the annotated type of the element

fromClass

public AnnotatedTypeMirror.AnnotatedDeclaredType fromClass(@Nullable ClassTree tree)

Determines the annotated type of a class from its declaration.

Parameters:

tree - the class declaration

Returns:

the annotated type of the class being declared

fromMember

public @Mutable AnnotatedTypeMirror fromMember(@Nullable Tree tree)

Determines the annotated type of a variable or method declaration.

Parameters:

tree - the variable or method declaration

Returns:

the annotated type of the variable or method being declared

Throws:

IllegalArgumentException - if tree is not a method or variable declaration

fromExpression

public @Mutable AnnotatedTypeMirror fromExpression(ExpressionTree tree)

Determines the annotated type of an expression.

Parameters:

tree - an expression

Returns:

the annotated type of the expression

fromTypeTree

public @Mutable AnnotatedTypeMirror fromTypeTree(@Nullable Tree tree)

Determines the annotated type from a type in tree form. This method does not add implicit annotations.

Parameters:

tree - the type tree

Returns:

the annotated type of the type in the AST

annotateImplicit

protected void annotateImplicit(@Nullable Tree tree,
                    @Mutable AnnotatedTypeMirror type)

Adds implicit annotations to a type obtained from a Tree. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.

Parameters:

tree - an AST node

type - the type obtained from tree

annotateImplicit

protected void annotateImplicit(@Nullable Element elt,
                    @Mutable AnnotatedTypeMirror type)

Adds implicit annotations to a type obtained from a Element. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.

Parameters:

elt - an element

type - the type obtained from elt

postDirectSuperTypes

protected void postDirectSuperTypes(@Mutable AnnotatedTypeMirror type,
                        List<? extends @Mutable AnnotatedTypeMirror> supertypes)

A callback method for the AnnotatedTypeFactory subtypes to customize directSuperTypes(). Overriding methods should merely change the annotations on the supertypes, without adding or removing new types. The default provided implementation adds type annotations to supertypes. This allows the type and its supertypes to have the qualifiers, e.g. the supertypes of an Immutable type are also Immutable.

Parameters:

type - the type whose supertypes are desired

supertypes - the supertypes as specified by the base AnnotatedTypeFactory

postAsMemberOf

protected void postAsMemberOf(@Mutable AnnotatedTypeMirror type,
                  @Mutable AnnotatedTypeMirror owner,
                  @Nullable Element element)

A callback method for the AnnotatedTypeFactory subtypes to customize AnnotatedTypes.asMemberOf(). Overriding methods should merely change the annotations on the subtypes, without changing the types.

Parameters:

type - the annotated type of the element

owner - the annotated type of the receiver of the accessing tree

element - the element of the field or method

typeVariablesFromUse

public List<AnnotatedTypeMirror.AnnotatedTypeVariable> typeVariablesFromUse(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                                                                   TypeElement element)

Adapt the upper bounds of the type variables of a class relative to the type instantiation. In some type systems, the upper bounds depend on the instantiation of the class. For example, in the Generic Universe Type system, consider a class declaration

   class C<X extends @Peer Object> 

then the instantiation

   @Rep C<@Rep Object> 

is legal. The upper bounds of class C have to be adapted by the main modifier.

TODO: ensure that this method is consistently used instead of directly querying the type variables.

Parameters:

type - The use of the type

element - The corresponding element

Returns:

The adapted type variables

annotateInheritedFromClass

protected void annotateInheritedFromClass(@Mutable AnnotatedTypeMirror type)

Adds annotations to the type based on the annotations from its class type if and only if no annotations are already present on the type.

Parameters:

type - the type for which class annotations will be inherited if there are no annotations already present

getImplicitReceiverType

protected AnnotatedTypeMirror.AnnotatedDeclaredType getImplicitReceiverType(ExpressionTree tree)

Return the implicit receiver type of an expression tree. The result is null for expressions that don't have a receiver, e.g. for a local variable or method parameter access. TODO: receiver annotations on outer this. TODO: Better document the difference between getImplicitReceiverType and getSelfType?

Parameters:

tree - The expression that might have an implicit receiver.

Returns:

The type of the receiver.

isMostEnclosingThisDeref

public final boolean isMostEnclosingThisDeref(ExpressionTree tree)

Determine whether the tree dereferences the most enclosing "this" object. That is, we have an expression like "f.g" and want to know whether it is an access "this.f.g" or whether e.g. f is a field of an outer class or e.g. f is a local variable.

Parameters:

tree - The tree to check.

Returns:

True, iff the tree is an explicit or implicit reference to the most enclosing "this".

isAnyEnclosingThisDeref

public final boolean isAnyEnclosingThisDeref(ExpressionTree tree)

Does this expression have (the innermost or an outer) "this" as receiver? Note that the receiver can be either explicit or implicit.

Parameters:

tree - The tree to test.

Returns:

True, iff the expression uses (the innermost or an outer) "this" as receiver.

getSelfType

public AnnotatedTypeMirror.AnnotatedDeclaredType getSelfType(@Nullable Tree tree)

Returns the type of this in the current location, which can be used if this has a special semantics (e.g. this is non-null). The parameter is an arbitrary tree and does not have to mention "this", neither explicitly nor implicitly. This method should be overridden for type-system specific behavior. TODO: in 1.3, handle all receiver type annotations. TODO: handle enclosing classes correctly.

getEnclosingType

public AnnotatedTypeMirror.AnnotatedDeclaredType getEnclosingType(TypeElement element,
                                                         @Nullable Tree tree)

Determine the type of the most enclosing class of the given tree that is a subtype of the given element. Receiver type annotations of an enclosing method are considered.

getReceiverType

public final @Mutable AnnotatedTypeMirror getReceiverType(ExpressionTree expression)

Returns the receiver type of the expression tree, or null if it does not exist. The only trees that could potentially have a receiver are:

• Array Access
• Identifiers (whose receivers are usually self type)
• Method Invocation Trees
• Member Select Trees

Parameters:

expression - The expression for which to determine the receiver type

Returns:

the type of the receiver of this expression

methodFromUse

public Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<@Mutable AnnotatedTypeMirror>> methodFromUse(MethodInvocationTree tree)

Determines the type of the invoked method based on the passed method invocation tree. The returned method type has all type variables resolved, whether based on receiver type, passed type parameters if any, and method invocation parameter. Subclasses may override this method to customize inference of types or qualifiers based on method invocation parameters. As an implementation detail, this method depends on AnnotatedTypes.asMemberOf(AnnotatedTypeMirror, Element), and customization based on receiver type should be in accordance to its specification. The return type is a pair of the type of the invoked method and the (inferred) type arguments. Note that neither the explicitly passed nor the inferred type arguments are guaranteed to be subtypes of the corresponding upper bounds. See method BaseTypeVisitor.checkTypeArguments(Tree, List, List, List) for the checks of type argument well-formedness.

Parameters:

tree - the method invocation tree

Returns:

the method type being invoked with tree and the (inferred) type arguments

constructorFromUse

public Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<@Mutable AnnotatedTypeMirror>> constructorFromUse(NewClassTree tree)

Determines the AnnotatedTypeMirror.AnnotatedExecutableType of a constructor invocation. Note that this is different than calling getAnnotatedType(Tree) or fromExpression(ExpressionTree) on the constructor invocation; those determine the type of the result of invoking the constructor, which is probably an AnnotatedTypeMirror.AnnotatedDeclaredType. TODO: Should the result of getAnnotatedType be the return type from the AnnotatedExecutableType computed here?

Parameters:

tree - the constructor invocation tree

Returns:

the annotated type of the invoked constructor (as an executable type) and the (inferred) type arguments

fromNewClass

public AnnotatedTypeMirror.AnnotatedDeclaredType fromNewClass(NewClassTree tree)

getBoxedType

public AnnotatedTypeMirror.AnnotatedDeclaredType getBoxedType(AnnotatedTypeMirror.AnnotatedPrimitiveType type)

returns the annotated boxed type of the given primitive type. The returned type would only have the annotations on the given type. Subclasses may override this method safely to override this behavior.

Parameters:

type - the primitive type

Returns:

the boxed declared type of the passed primitive type

getUnboxedType

public AnnotatedTypeMirror.AnnotatedPrimitiveType getUnboxedType(AnnotatedTypeMirror.AnnotatedDeclaredType type)
                                                          throws IllegalArgumentException

returns the annotated primitive type of the given declared type if it is a boxed declared type. Otherwise, it throws IllegalArgumentException exception. The returned type would have the annotations on the given type and nothing else.

Parameters:

type - the declared type

Returns:

the unboxed primitive type

Throws:

IllegalArgumentException - if the type given has no unbox conversion

getVisitorState

public VisitorState getVisitorState()

Returns the VisitorState instance used by the factory to infer types

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(@Nullable ClassTree tree)

See Also:

getAnnotatedType(Tree)

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(NewClassTree tree)

See Also:

getAnnotatedType(Tree)

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedArrayType getAnnotatedType(NewArrayTree tree)

See Also:

getAnnotatedType(Tree)

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(@Nullable MethodTree tree)

See Also:

getAnnotatedType(Tree)

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(TypeElement elt)

See Also:

getAnnotatedType(Element)

getAnnotatedType

public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(@NonNull ExecutableElement elt)

See Also:

getAnnotatedType(Element)

fromElement

public final AnnotatedTypeMirror.AnnotatedDeclaredType fromElement(TypeElement elt)

See Also:

getAnnotatedType(Element)

fromElement

public final AnnotatedTypeMirror.AnnotatedExecutableType fromElement(@NonNull ExecutableElement elt)

See Also:

getAnnotatedType(Element)

isSupportedQualifier

public boolean isSupportedQualifier(@Nullable AnnotationMirror a)

Determines whether the given annotation is a part of the type system under which this type factory operates.

Parameters:

a - any annotation

Returns:

true if that annotation is part of the type system under which this type factory operates, false otherwise

addAliasedAnnotation

protected void addAliasedAnnotation(Class<?> clazz,
                        @Nullable AnnotationMirror type)

Add the annotation clazz as an alias for the annotation type.

aliasedAnnotation

public @Nullable AnnotationMirror aliasedAnnotation(@Nullable AnnotationMirror a)

Returns the canonical annotation for the passed annotation if it is an alias of a canonical one in the framework. If it is not an alias, the method returns null. Returns an aliased type of the current one

toAnnotatedType

public final @Mutable AnnotatedTypeMirror toAnnotatedType(TypeMirror t)

A convenience method that converts a TypeMirror to an AnnotatedTypeMirror using AnnotatedTypeMirror.createType(javax.lang.model.type.TypeMirror, javax.annotation.processing.ProcessingEnvironment, checkers.types.AnnotatedTypeFactory).

Parameters:

t - the TypeMirror

Returns:

an AnnotatedTypeMirror that has t as its underlying type

unify

protected Collection<@Nullable AnnotationMirror> unify(Collection<@Nullable AnnotationMirror> c1,
                                           Collection<@Nullable AnnotationMirror> c2)

Returns the type qualifiers that are least upper bound for c1 and c2 qualifiers. In most cases, this is simply the intersection of the collections. However, if a type system specifies more than one type qualifier, this needs to return the least restrictive type qualifiers. Examples: For NonNull, unify('Nullable', 'NonNull') ==> Nullable For IGJ, unify('Immutable', 'Mutable') ==> ReadOnly Delegates the call to QualifierHierarchy.leastUpperBounds(Collection, Collection).

Parameters:

c1 - type qualifiers for the first type

c2 - type qualifiers for the second type

Returns:

the least restrictive qualifiers for both types

getQualifierHierarchy

public QualifierHierarchy getQualifierHierarchy()

declarationFromElement

protected final @Nullable Tree declarationFromElement(@Nullable Element elt)

Gets the declaration tree for the element, if the source is available.

Parameters:

elt - an element

Returns:

the tree declaration of the element if found

getCurrentClassTree

protected final @Nullable ClassTree getCurrentClassTree(@Nullable Tree tree)

Returns the current class type being visited by the visitor. The method uses the parameter only if the most enclosing class cannot be found directly.

Returns:

type of the most enclosing class being visited

getCurrentClassType

protected final AnnotatedTypeMirror.AnnotatedDeclaredType getCurrentClassType(@Nullable Tree tree)

getCurrentMethodReceiver

protected final AnnotatedTypeMirror.AnnotatedDeclaredType getCurrentMethodReceiver(@Nullable Tree tree)

Returns the receiver type of the current method being visited, and returns null if the visited tree is not within a method. The method uses the parameter only if the most enclosing method cannot be found directly.

Returns:

receiver type of the most enclosing method being visited.

isWithinConstructor

protected final boolean isWithinConstructor(@Nullable Tree tree)

getPath

public final @Nullable TreePath getPath(@Nullable Tree node)

Gets the path for the given Tree under the current root by checking from the visitor's current path, and only using Trees.getPath(CompilationUnitTree, Tree) (which is much slower) only if node is not found on the current path. Note that the given Tree has to be within the current compilation unit, otherwise null will be returned.

Parameters:

node - the Tree to get the path for

Returns:

the path for node under the current root

createLRUCache

protected static <K extends @NonNull Object,V extends @NonNull Object> Map<K,V> createLRUCache(int size)

A Utility method for creating LRU cache

Parameters:

size - size of the cache

Returns:

a new cache with the provided size

getDeclAnnotation

public @Nullable AnnotationMirror getDeclAnnotation(@Nullable Element elt,
                                           Class<? extends Annotation> anno)

Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.

Parameters:

anno - annotation class

Returns:

the annotation mirror for anno