checkers.types

Class BasicAnnotatedTypeFactory<Checker extends BaseTypeChecker>

@NonNull java.lang.Object

checkers.types.AnnotatedTypeFactory

checkers.types.BasicAnnotatedTypeFactory<Checker>

Direct Known Subclasses:

FenumAnnotatedTypeFactory, I18nAnnotatedTypeFactory, IGJAnnotatedTypeFactory, ImmutabilityAnnotatedTypeFactory, InterningAnnotatedTypeFactory, KeyForAnnotatedTypeFactory, LinearAnnotatedTypeFactory, LockAnnotatedTypeFactory, NullnessAnnotatedTypeFactory, OwnershipAnnotatedTypeFactory, PropertyKeyAnnotatedTypeFactory, RegexAnnotatedTypeFactory, SignatureAnnotatedTypeFactory, UnitsAnnotatedTypeFactory

public class BasicAnnotatedTypeFactory<Checker extends BaseTypeChecker>
extends AnnotatedTypeFactory

A factory that extends AnnotatedTypeFactory to optionally use flow-sensitive qualifier inference, qualifier polymorphism, implicit annotations via ImplicitFor, and user-specified defaults via DefaultQualifier

See Also:

Flow

Nested Class Summary

Nested classes/interfaces inherited from class checkers.types.AnnotatedTypeFactory

AnnotatedTypeFactory.InheritedFromClassAnnotator

Field Summary

Fields

Modifier and Type	Field and Description
protected Checker	checker The type checker to use.
protected QualifierDefaults	defaults to handle defaults specified by the user
protected Flow	flow Flow sensitive instance
protected static boolean	FLOW_BY_DEFAULT should use flow by default
protected QualifierPolymorphism	poly to handle any polymorphic types
protected TreeAnnotator	treeAnnotator to annotate types based on the given un-annotated types
protected TypeAnnotator	typeAnnotator to annotate types based on the given tree
protected boolean	useFlow Should use flow analysis?

Fields inherited from class checkers.types.AnnotatedTypeFactory

annotations, atypes, elements, env, fromTreeCache, qualHierarchy, root, trees, types, uid, visitorState

Constructor Summary

Constructors

Constructor and Description
BasicAnnotatedTypeFactory(Checker checker, @Nullable CompilationUnitTree root) Creates a type factory for checking the given compilation unit with respect to the given annotation.
BasicAnnotatedTypeFactory(Checker checker, @Nullable CompilationUnitTree root, boolean useFlow) Creates a type factory for checking the given compilation unit with respect to the given annotation.

Method Summary

Methods

Modifier and Type	Method and Description
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	annotateImplicit(@Nullable Tree tree, @Mutable AnnotatedTypeMirror type, boolean iUseFlow)
Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<@Mutable AnnotatedTypeMirror>>	constructorFromUse(NewClassTree tree) Determines the AnnotatedTypeMirror.AnnotatedExecutableType of a constructor invocation.
protected Flow	createFlow(Checker checker, @Nullable CompilationUnitTree root, Set<@Nullable AnnotationMirror> flowQuals) Returns a Flow instance that performs flow sensitive analysis to infer qualifiers on unqualified types.
protected Set<@Nullable AnnotationMirror>	createFlowQualifiers(Checker checker) Returns the set of annotations to be inferred in flow analysis
protected TreeAnnotator	createTreeAnnotator(Checker checker) Returns a TreeAnnotator that adds annotations to a type based on the contents of a tree.
protected TypeAnnotator	createTypeAnnotator(Checker checker) Returns a TypeAnnotator that adds annotations to a type based on the content of the type itself.
@Mutable AnnotatedTypeMirror	getDefaultedAnnotatedType(@Nullable Tree tree) Get the defaulted type of a variable, without considering flow inference from the initializer expression.
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	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.

Methods inherited from class checkers.types.AnnotatedTypeFactory

addAliasedAnnotation, aliasedAnnotation, annotateInheritedFromClass, canHaveAnnotatedTypeParameters, createLRUCache, declarationFromElement, fromClass, fromElement, fromElement, fromElement, fromExpression, fromMember, fromNewClass, fromTypeTree, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedTypeFromTypeTree, getBoxedType, getCurrentClassTree, getCurrentClassType, getCurrentMethodReceiver, getDeclAnnotation, getEnclosingType, getImplicitReceiverType, getPath, getQualifierHierarchy, getReceiverType, getSelfType, getUnboxedType, getVisitorState, isAnyEnclosingThisDeref, isMostEnclosingThisDeref, isSupportedQualifier, isWithinConstructor, postAsMemberOf, toAnnotatedType, toString, typeVariablesFromUse, unify

Methods inherited from class java.lang.Object

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

Field Detail

checker

protected Checker extends BaseTypeChecker checker

The type checker to use.

FLOW_BY_DEFAULT

protected static boolean FLOW_BY_DEFAULT

should use flow by default

typeAnnotator

protected final TypeAnnotator typeAnnotator

to annotate types based on the given tree

treeAnnotator

protected final TreeAnnotator treeAnnotator

to annotate types based on the given un-annotated types

poly

protected final QualifierPolymorphism poly

to handle any polymorphic types

defaults

protected final QualifierDefaults defaults

to handle defaults specified by the user

useFlow

protected boolean useFlow

Should use flow analysis?

flow

protected Flow flow

Flow sensitive instance

Constructor Detail

BasicAnnotatedTypeFactory

public BasicAnnotatedTypeFactory(Checker checker,
                         @Nullable CompilationUnitTree root,
                         boolean useFlow)

Creates a type factory for checking the given compilation unit with respect to the given annotation.

Parameters:

checker - the checker to which this type factory belongs

root - the compilation unit to scan

useFlow - whether flow analysis should be performed

BasicAnnotatedTypeFactory

public BasicAnnotatedTypeFactory(Checker checker,
                         @Nullable CompilationUnitTree root)

Creates a type factory for checking the given compilation unit with respect to the given annotation.

Parameters:

checker - the checker to which this type factory belongs

root - the compilation unit to scan

Method Detail

postInit

protected void postInit()

Description copied from class: AnnotatedTypeFactory

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.

Overrides:

postInit in class AnnotatedTypeFactory

createTreeAnnotator

protected TreeAnnotator createTreeAnnotator(Checker checker)

Returns a TreeAnnotator that adds annotations to a type based on the contents of a tree. Subclasses may override this method to specify more appriopriate TreeAnnotator

Returns:

a tree annotator

createTypeAnnotator

protected TypeAnnotator createTypeAnnotator(Checker checker)

Returns a TypeAnnotator that adds annotations to a type based on the content of the type itself.

Returns:

a type annotator

createFlow

protected Flow createFlow(Checker checker,
              @Nullable CompilationUnitTree root,
              Set<@Nullable AnnotationMirror> flowQuals)

Returns a Flow instance that performs flow sensitive analysis to infer qualifiers on unqualified types.

Parameters:

checker - the checker

root - the compilation unit associated with this factory

flowQuals - the qualifiers to infer

Returns:

the flow analysis class

postDirectSuperTypes

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

Description copied from class: AnnotatedTypeFactory

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.

Overrides:

postDirectSuperTypes in class AnnotatedTypeFactory

Parameters:

type - the type whose supertypes are desired

supertypes - the supertypes as specified by the base AnnotatedTypeFactory

annotateImplicit

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

annotateImplicit

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

Description copied from class: AnnotatedTypeFactory

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.

Overrides:

annotateImplicit in class AnnotatedTypeFactory

Parameters:

tree - an AST node

type - the type obtained from tree

getDefaultedAnnotatedType

public @Mutable AnnotatedTypeMirror getDefaultedAnnotatedType(@Nullable Tree tree)

Description copied from class: AnnotatedTypeFactory

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

Overrides:

getDefaultedAnnotatedType in class AnnotatedTypeFactory

annotateImplicit

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

Description copied from class: AnnotatedTypeFactory

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.

Overrides:

annotateImplicit in class AnnotatedTypeFactory

Parameters:

elt - an element

type - the type obtained from elt

methodFromUse

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

Description copied from class: AnnotatedTypeFactory

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.

Overrides:

methodFromUse in class AnnotatedTypeFactory

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)

Description copied from class: AnnotatedTypeFactory

Determines the AnnotatedTypeMirror.AnnotatedExecutableType of a constructor invocation. Note that this is different than calling AnnotatedTypeFactory.getAnnotatedType(Tree) or AnnotatedTypeFactory.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?

Overrides:

constructorFromUse in class AnnotatedTypeFactory

Parameters:

tree - the constructor invocation tree

Returns:

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

createFlowQualifiers

protected Set<@Nullable AnnotationMirror> createFlowQualifiers(Checker checker)

Returns the set of annotations to be inferred in flow analysis