AnnotatedTypeFactory (checker-framework 3.7.0 API)

java.lang.Object
- org.checkerframework.framework.type.AnnotatedTypeFactory

All Implemented Interfaces:

AnnotationProvider

Direct Known Subclasses:

GenericAnnotatedTypeFactory, TypeOutputtingChecker.GeneralAnnotatedTypeFactory
```
public class AnnotatedTypeFactory
extends Object
implements AnnotationProvider
```
The methods of this class take an element or AST node, and return the annotated type as an AnnotatedTypeMirror. The methods are:
This implementation only adds qualifiers explicitly specified by the programmer. Subclasses override addComputedTypeAnnotations(com.sun.source.tree.Tree, org.checkerframework.framework.type.AnnotatedTypeMirror) to add defaults, flow-sensitive refinement, and type-system-specific rules.
Unless otherwise indicated, each public method in this class returns a "fully annotated" type, which is one that has an annotation in all positions.
Type system checker writers may need to subclass this class, to add default qualifiers according to the type system semantics. Subclasses should especially override addComputedTypeAnnotations(Element, AnnotatedTypeMirror) and addComputedTypeAnnotations(Tree, AnnotatedTypeMirror) to handle default annotations. (Also, addDefaultAnnotations(AnnotatedTypeMirror) adds annotations, but that method is a workaround for Issue 979.)
See the Checker Framework Manual:
How to write a checker plug-in

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AnnotatedTypeFactory.ParameterizedExecutableType
The type for an instantiated generic method or constructor.

Nested Classes
Modifier and Type	Class and Description
`static class`	`AnnotatedTypeFactory.ParameterizedExecutableType` The type for an instantiated generic method or constructor.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<Tree,Element>`	`artificialTreeToEnclosingElementMap` Mapping from CFG generated trees to their enclosing elements.
`protected BaseTypeChecker`	`checker` The checker to use for option handling and resource management.
`protected Elements`	`elements` Utility class for working with `Element`s.
`protected Map<Tree,AnnotatedTypeMirror>`	`fromExpressionTreeCache` Mapping from an expression tree to its annotated type; before defaults are applied, just what the programmer wrote.
`protected Map<Tree,AnnotatedTypeMirror>`	`fromMemberTreeCache` Mapping from a member tree to its annotated type; before defaults are applied, just what the programmer wrote.
`protected Map<Tree,AnnotatedTypeMirror>`	`fromTypeTreeCache` Mapping from a type tree to its annotated type; before defaults are applied, just what the programmer wrote.
`boolean`	`ignoreUninferredTypeArguments` Whether to ignore uninferred type arguments.
`protected AnnotationClassLoader`	`loader` AnnotationClassLoader used to load type annotation classes via reflective lookup.
`protected ExecutableElement`	`objectGetClass` The Object.getClass method.
`protected ProcessingEnvironment`	`processingEnv` The processing environment to use for accessing compiler internals.
`protected QualifierHierarchy`	`qualHierarchy` Represent the annotation relations.
`protected QualifierUpperBounds`	`qualifierUpperBounds` Holds the qualifier upper bounds for type uses.
`protected ReflectionResolver`	`reflectionResolver` Object that is used to resolve reflective method calls, if reflection resolution is turned on.
`protected @Nullable CompilationUnitTree`	`root` Optional! The AST of the source file being operated on.
`boolean`	`shouldCache` Should results be cached? This means that ATM.deepCopy() will be called.
`StubTypes`	`stubTypes` Parses stub files and stores annotations from stub files.
`protected Trees`	`trees` The `Trees` instance to use for tree node path finding.
`protected TypeArgumentInference`	`typeArgumentInference` Provides utility method to infer type arguments.
`protected AnnotatedTypeFormatter`	`typeFormatter` This formatter is used for converting AnnotatedTypeMirrors to Strings.
`protected TypeHierarchy`	`typeHierarchy` Represent the type relations.
`Types`	`types` Utility class for working with `TypeMirror`s.
`protected TypeVariableSubstitutor`	`typeVarSubstitutor` Provides utility method to substitute arguments for their type variables.
`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(BaseTypeChecker checker)
Constructs a factory from the given ProcessingEnvironment instance and syntax tree root.

Constructors
Constructor and Description
`AnnotatedTypeFactory(BaseTypeChecker checker)` Constructs a factory from the given `ProcessingEnvironment` instance and syntax tree root.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`adaptGetClassReturnTypeToReceiver(AnnotatedTypeMirror.AnnotatedExecutableType getClassType, AnnotatedTypeMirror receiverType)` Java special-cases the return type of `getClass()`.
`protected void`	`addAliasedAnnotation(Class<?> aliasClass, AnnotationMirror type)` Adds the annotation `aliasClass` as an alias for the canonical annotation `type` that will be used by the Checker Framework in the alias's place.
`protected void`	`addAliasedAnnotation(Class<?> aliasClass, Class<?> canonical, boolean copyElements, String... ignorableElements)` Adds the annotation `aliasClass` as an alias for the canonical annotation `type` that will be used by the Checker Framework in the alias's place.
`protected void`	`addAliasedAnnotation(@FullyQualifiedName String aliasName, AnnotationMirror type)` Adds the annotation, whose fully-qualified name is given by `aliasName`, as an alias for the canonical annotation `type` that will be used by the Checker Framework in the alias's place.
`protected void`	`addAliasedAnnotation(@FullyQualifiedName String aliasName, Class<?> canonicalAnno, boolean copyElements, String... ignorableElements)` Adds the annotation, whose fully-qualified name is given by `aliasName`, as an alias for the canonical annotation `type` that will be used by the Checker Framework in the alias's place.
`protected void`	`addAliasedDeclAnnotation(Class<? extends Annotation> alias, Class<? extends Annotation> annotation, AnnotationMirror annotationToUse)` Add the annotation `alias` as an alias for the declaration annotation `annotation`, where the annotation mirror `annotationToUse` will be used instead.
`protected void`	`addAnnotationFromFieldInvariant(AnnotatedTypeMirror type, AnnotatedTypeMirror accessedVia, VariableElement field)` Adds the qualifier specified by a field invariant for `field` to `type`.
`protected void`	`addComputedTypeAnnotations(Element elt, AnnotatedTypeMirror type)` Changes annotations on a type obtained from an `Element`.
`protected void`	`addComputedTypeAnnotations(Tree tree, AnnotatedTypeMirror type)` Changes annotations on a type obtained from a `Tree`.
`protected void`	`addDefaultAnnotations(AnnotatedTypeMirror type)` Adds default annotations to `type`.
`protected void`	`addInheritedAnnotation(AnnotationMirror annotation)` Adds the annotation `annotation` in the set of declaration annotations that should be inherited.
`AnnotatedTypeMirror.AnnotatedPrimitiveType`	`applyUnboxing(AnnotatedTypeMirror type)` Return a primitive type: either the argument, or the result of unboxing it (which might affect its annotations).
`boolean`	`areSameByClass(AnnotationMirror am, Class<? extends Annotation> annoClass)` Checks that the annotation `am` has the name of `annoClass`.
`Pair<AnnotatedTypeMirror,AnnotatedTypeMirror>`	`binaryTreeArgTypes(BinaryTree node)` Returns the types of the two arguments to the BinaryTree, accounting for widening if applicable.
`@Nullable AnnotationMirror`	`canonicalAnnotation(AnnotationMirror a)` Returns the canonical annotation for the passed annotation.
`protected void`	`checkInvalidOptionsInferSignatures()` This method is called only when `-Ainfer` is passed as an option.
`AnnotatedTypeFactory.ParameterizedExecutableType`	`constructorFromUse(NewClassTree tree)` Determines the type of the invoked constructor based on the passed new class tree.
`protected void`	`constructorFromUsePreSubstitution(NewClassTree tree, AnnotatedTypeMirror.AnnotatedExecutableType type)` A callback method for the AnnotatedTypeFactory subtypes to customize the handling of the declared constructor type before type variable substitution.
`boolean`	`containsSameByClass(Collection<? extends AnnotationMirror> c, Class<? extends Annotation> anno)` Checks that the collection contains the annotation.
`protected AnnotatedTypeFormatter`	`createAnnotatedTypeFormatter()` Creates the AnnotatedTypeFormatter used by this type factory and all AnnotatedTypeMirrors it creates.
`protected AnnotationClassLoader`	`createAnnotationClassLoader()` Factory method to easily change what `AnnotationClassLoader` is created to load type annotation classes.
`protected AnnotationFormatter`	`createAnnotationFormatter()`
`protected QualifierHierarchy`	`createQualifierHierarchy()` Returns the `QualifierHierarchy` to be used by this checker.
`QualifierHierarchy`	`createQualifierHierarchyWithMultiGraphFactory(MultiGraphQualifierHierarchy.MultiGraphFactory factory)` Deprecated. Use either `ElementQualifierHierarchy`, `NoElementQualifierHierarchy`, or `MostlyNoElementQualifierHierarchy` instead. This method will be removed in a future release.
`protected QualifierUpperBounds`	`createQualifierUpperBounds()` Creates `QualifierUpperBounds` for this type factory.
`protected Set<Class<? extends Annotation>>`	`createSupportedTypeQualifiers()` Returns a mutable set of annotation classes that are supported by a checker.
`protected TypeArgumentInference`	`createTypeArgumentInference()` TypeArgumentInference infers the method type arguments when they are not explicitly written.
`protected TypeHierarchy`	`createTypeHierarchy()` Creates the type hierarchy to be used by this factory.
`protected TypeVariableSubstitutor`	`createTypeVariableSubstitutor()` TypeVariableSubstitutor provides a method to replace type parameters with their arguments.
`Tree`	`declarationFromElement(Element elt)` Gets the declaration tree for the element, if the source is available.
`AnnotatedTypeMirror`	`fromElement(Element elt)` Creates an AnnotatedTypeMirror for `elt` that includes: annotations explicitly written on the element and annotations from stub files.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`fromElement(ExecutableElement elt)` See `fromElement(Element)`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`fromElement(TypeElement elt)` See `fromElement(Element)`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`fromNewClass(NewClassTree newClassTree)` Creates an AnnotatedDeclaredType for a NewClassTree.
`AnnotatedTypeMirror.AnnotatedNullType`	`getAnnotatedNullType(Set<? extends AnnotationMirror> annotations)` Creates and returns an AnnotatedNullType qualified with `annotations`.
`AnnotatedTypeMirror`	`getAnnotatedType(Class<?> clazz)` Returns an AnnotatedTypeMirror representing the annotated type of `clazz`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getAnnotatedType(ClassTree tree)` See `getAnnotatedType(Tree)`.
`AnnotatedTypeMirror`	`getAnnotatedType(Element elt)` Returns an AnnotatedTypeMirror representing the annotated type of `elt`.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getAnnotatedType(ExecutableElement elt)` See `getAnnotatedType(Element)`.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getAnnotatedType(MethodTree tree)` See `getAnnotatedType(Tree)`.
`AnnotatedTypeMirror.AnnotatedArrayType`	`getAnnotatedType(NewArrayTree tree)` See `getAnnotatedType(Tree)`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getAnnotatedType(NewClassTree tree)` See `getAnnotatedType(Tree)`.
`AnnotatedTypeMirror`	`getAnnotatedType(Tree tree)` Returns an AnnotatedTypeMirror representing the annotated type of `tree`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getAnnotatedType(TypeElement elt)` See `getAnnotatedType(Element)`.
`AnnotatedTypeFormatter`	`getAnnotatedTypeFormatter()`
`AnnotatedTypeMirror`	`getAnnotatedTypeFromTypeTree(Tree tree)` Determines the annotated type from a type in tree form.
`@Nullable AnnotationMirror`	`getAnnotationByClass(Collection<? extends AnnotationMirror> c, Class<? extends Annotation> anno)` Returns the AnnotationMirror in `c` that has the same class as `anno`.
`AnnotationFormatter`	`getAnnotationFormatter()`
`@Nullable AnnotationMirror`	`getAnnotationMirror(Tree tree, Class<? extends Annotation> target)` Return the annotation on `tree` that is in the hierarchy that contains the qualifier `target`.
`List<Pair<AnnotationMirror,AnnotationMirror>>`	`getAnnotationWithMetaAnnotation(Element element, Class<? extends Annotation> metaAnnotationClass)` Returns a list of all annotations used to annotate this element, which have a meta-annotation (i.e., an annotation on that annotation) with class `metaAnnotationClass`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getBoxedType(AnnotatedTypeMirror.AnnotatedPrimitiveType type)` Returns the annotated boxed type of the given primitive type.
`protected Set<Class<? extends Annotation>>`	`getBundledTypeQualifiers(Class<? extends Annotation>... explicitlyListedAnnotations)` Loads all annotations contained in the qual directory of a checker via reflection; if a polymorphic type qualifier exists, and an explicit array of annotations to the set of annotation classes.
`protected int`	`getCacheSize()` Returns the int supplied to the checker via the atfCacheSize option or the default cache size.
`CFContext`	`getContext()` Accessor for the `CFContext`.
`protected ClassTree`	`getCurrentClassTree(Tree tree)` Returns the current class type being visited by the visitor.
`protected AnnotatedTypeMirror.AnnotatedDeclaredType`	`getCurrentClassType(Tree tree)`
`protected @Nullable AnnotatedTypeMirror.AnnotatedDeclaredType`	`getCurrentMethodReceiver(Tree tree)` Returns the receiver type of the current method being visited, and returns null if the visited tree is not within a method or if that method has no receiver (e.g.
`AnnotationMirror`	`getDeclAnnotation(Element elt, Class<? extends Annotation> anno)` Returns all of the declaration annotations whose name equals the passed annotation class (or is an alias for it) including annotations: on the element written in stubfiles inherited from overriden methods, (see `InheritedAnnotation`) inherited from superclasses or super interfaces (see `Inherited`)
`AnnotationMirror`	`getDeclAnnotationNoAliases(Element elt, Class<? extends Annotation> anno)` Returns the actual annotation mirror used to annotate this element, whose name equals the passed annotation class.
`Set<AnnotationMirror>`	`getDeclAnnotations(Element elt)` Returns all of the declaration annotations on this element including annotations on the element written in stubfiles inherited from overriden methods, (see `InheritedAnnotation`) inherited from superclasses or super interfaces (see `Inherited`)
`List<Pair<AnnotationMirror,AnnotationMirror>>`	`getDeclAnnotationWithMetaAnnotation(Element element, Class<? extends Annotation> metaAnnotationClass)` Returns a list of all declaration annotations used to annotate this element, which have a meta-annotation (i.e., an annotation on that annotation) with class `metaAnnotationClass`.
`protected Set<? extends AnnotationMirror>`	`getDefaultTypeDeclarationBounds()` Returns the set of qualifiers that are the upper bound for a type use if no other bound is specified for the type.
`@Nullable AnnotatedTypeMirror`	`getDummyAssignedTo(ExpressionTree expressionTree)` Returns `null` or an annotated type mirror that type argument inference should assume `expressionTree` is assigned to.
`Elements`	`getElementUtils()` Accessor for the element utilities.
`protected Tree`	`getEnclosingClassOrMethod(Tree tree)` Returns the inner most enclosing method or class tree of `tree`.
`Element`	`getEnclosingElementForArtificialTree(Tree node)` Gets the `Element` representing the declaration of the method enclosing a tree node.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getEnclosingType(TypeElement typeElement, Tree tree)` Returns the `AnnotatedTypeMirror` of the enclosing type at the location of `tree` that is the same type as `typeElement`.
`static Pair<String,String>`	`getExpressionAndOffset(String expression)` Given an expression, split it into a subexpression and a constant offset.
`AnnotationTree`	`getFieldInvariantAnnotationTree(List<? extends AnnotationTree> annoTrees)` Returns the AnnotationTree which is a use of one of the field invariant annotations (as specified via `getFieldInvariantDeclarationAnnotations()`.
`protected Set<Class<? extends Annotation>>`	`getFieldInvariantDeclarationAnnotations()` Returns the set of classes of field invariant annotations.
`FieldInvariants`	`getFieldInvariants(TypeElement element)` Returns the field invariants for the given class, as expressed by the user in `@FieldInvariant` method annotations.
`Pair<AnnotatedTypeMirror,AnnotatedTypeMirror.AnnotatedExecutableType>`	`getFnInterfaceFromTree(Tree tree)` Returns the functional interface and the function type that this lambda or member references targets.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getFunctionTypeFromTree(LambdaExpressionTree tree)` Returns the function type that this lambda targets.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getFunctionTypeFromTree(MemberReferenceTree tree)` Returns the function type that this member reference targets.
`protected @Nullable AnnotatedTypeMirror.AnnotatedDeclaredType`	`getImplicitReceiverType(ExpressionTree tree)` Return the implicit receiver type of an expression tree.
`AnnotatedTypeMirror`	`getMethodReturnType(MethodTree m)` Returns the return type of the method `m`.
`AnnotatedTypeMirror`	`getMethodReturnType(MethodTree m, ReturnTree r)` Returns the return type of the method `m` at the return statement `r`.
`AnnotatedTypeMirror.AnnotatedPrimitiveType`	`getNarrowedPrimitive(AnnotatedTypeMirror.AnnotatedPrimitiveType type, TypeMirror narrowedTypeMirror)` Returns AnnotatedPrimitiveType with underlying type `narrowedTypeMirror` and with annotations copied or adapted from `type`.
`TreePath`	`getPath(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.
`ProcessingEnvironment`	`getProcessingEnv()` Accessor for the processing environment.
`QualifierHierarchy`	`getQualifierHierarchy()` Returns the type qualifier hierarchy graph to be used by this processor.
`Set<AnnotationMirror>`	`getQualifierParameterHierarchies(AnnotatedTypeMirror annotatedType)` Returns the set of top annotations representing all the hierarchies for which this type has a qualifier parameter.
`Set<AnnotationMirror>`	`getQualifierParameterHierarchies(Element element)` Returns the set of top annotations representing all the hierarchies for which this element has a qualifier parameter.
`QualifierUpperBounds`	`getQualifierUpperBounds()` Return `QualifierUpperBounds` for this type factory.
`AnnotatedTypeMirror`	`getReceiverType(ExpressionTree expression)` Returns the receiver type of the expression tree, or null if it does not exist.
`@Nullable AnnotatedTypeMirror.AnnotatedDeclaredType`	`getSelfType(Tree tree)` Returns the type of `this` at the location of `tree`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getStringType(AnnotatedTypeMirror type)` Returns AnnotatedDeclaredType with underlying type String and annotations copied from type.
`Set<String>`	`getSupportedTypeQualifierNames()` Returns an immutable set of the fully qualified names of the type qualifiers supported by this checker.
`Set<Class<? extends Annotation>>`	`getSupportedTypeQualifiers()` Returns an immutable set of the classes corresponding to the type qualifiers supported by this checker.
`Trees`	`getTreeUtils()` Accessor for the tree utilities.
`TypeArgumentInference`	`getTypeArgumentInference()`
`Set<AnnotationMirror>`	`getTypeDeclarationBounds(TypeMirror type)` Returns the set of qualifiers that are the upper bounds for a use of the type.
`TypeHierarchy`	`getTypeHierarchy()`
`AnnotatedTypeMirror`	`getTypeOfExtendsImplements(Tree clause)` Returns the type of the extends or implements clause.
`TypeVariableSubstitutor`	`getTypeVarSubstitutor()`
`AnnotatedTypeMirror.AnnotatedPrimitiveType`	`getUnboxedType(AnnotatedTypeMirror.AnnotatedDeclaredType type)` Returns the annotated primitive type of the given declared type if it is a boxed declared type.
`AnnotatedTypeMirror.AnnotatedWildcardType`	`getUninferredWildcardType(AnnotatedTypeMirror.AnnotatedTypeVariable typeVar)` Returns a wildcard type to be used as a type argument when the correct type could not be inferred.
`VisitorState`	`getVisitorState()` Returns the VisitorState instance used by the factory to infer types.
`WholeProgramInference`	`getWholeProgramInference()` Returns the WholeProgramInference instance (may be null).
`Set<AnnotationMirror>`	`getWidenedAnnotations(Set<AnnotationMirror> annos, TypeKind typeKind, TypeKind widenedTypeKind)` Returns annotations applicable to type `widenedTypeKind`, that are copied or adapted from `annos`.
`AnnotatedTypeMirror`	`getWidenedType(AnnotatedTypeMirror exprType, AnnotatedTypeMirror widenedType)` Returns a widened type if applicable, otherwise returns its first argument.
`boolean`	`hasExplicitNoQualifierParameterInHierarchy(Element element, AnnotationMirror top)` Returns whether the `NoQualifierParameter` annotation was explicitly written on `element` for the hierarchy given by `top`.
`boolean`	`hasExplicitQualifierParameterInHierarchy(Element element, AnnotationMirror top)` Returns whether the `HasQualifierParameter` annotation was explicitly written on `element` for the hierarchy given by `top`.
`boolean`	`hasQualifierParameterInHierarchy(AnnotatedTypeMirror annotatedTypeMirror, AnnotationMirror top)` Whether or not the `annotatedTypeMirror` has a qualifier parameter.
`boolean`	`hasQualifierParameterInHierarchy(@Nullable Element element, AnnotationMirror top)` Whether or not the `element` has a qualifier parameter.
`protected void`	`initializeReflectionResolution()`
`boolean`	`isFromByteCode(Element element)` Returns true if the element is from bytecode and the if the element did not appear in a stub file.
`boolean`	`isFromStubFile(Element element)` Returns true if the element appears in a stub file (Currently only works for methods, constructors, and fields).
`boolean`	`isSupportedQualifier(@Nullable AnnotationMirror a)` Determines whether the given annotation is a part of the type system under which this type factory operates.
`boolean`	`isSupportedQualifier(Class<? extends Annotation> clazz)` Determines whether the given class is a part of the type system under which this type factory operates.
`boolean`	`isSupportedQualifier(String className)` Determines whether the given class name is a part of the type system under which this type factory operates.
`protected boolean`	`isWithinConstructor(Tree tree)`
`protected AnnotatedTypeMirror`	`mergeStubsIntoType(@Nullable AnnotatedTypeMirror type, Element elt)` Merges types from stub files for `elt` into `type` by taking the greatest lower bound of the annotations in both.
`AnnotatedTypeFactory.ParameterizedExecutableType`	`methodFromUse(ExpressionTree tree, ExecutableElement methodElt, AnnotatedTypeMirror receiverType)` Determines the type of the invoked method based on the passed expression tree, executable element, and receiver type.
`AnnotatedTypeFactory.ParameterizedExecutableType`	`methodFromUse(MethodInvocationTree tree)` Determines the type of the invoked method based on the passed method invocation tree.
`protected void`	`methodFromUsePreSubstitution(ExpressionTree tree, AnnotatedTypeMirror.AnnotatedExecutableType type)` A callback method for the AnnotatedTypeFactory subtypes to customize the handling of the declared method type before type variable substitution.
`static String`	`negateConstant(String constantExpression)` Given an expression string, returns its negation.
`protected void`	`parseStubFiles()` Parses the stub files in the following order: jdk.astub in the same directory as the checker, if it exists and ignorejdkastub option is not supplied jdkN.astub, where N is the Java version in the same directory as the checker, if it exists and ignorejdkastub option is not supplied Stub files listed in @StubFiles annotation on the checker; must be in same directory as the checker Stub files provide via stubs system property Stub files provide via stubs environment variable Stub files provide via stubs compiler option
`void`	`postAsMemberOf(AnnotatedTypeMirror type, AnnotatedTypeMirror owner, Element element)` A callback method for the AnnotatedTypeFactory subtypes to customize AnnotatedTypes.asMemberOf().
`protected void`	`postDirectSuperTypes(AnnotatedTypeMirror type, List<? extends 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.
`void`	`postProcessClassTree(ClassTree tree)` Called by `BaseTypeVisitor.visitClass(ClassTree, Void)` after the ClassTree has been type checked.
`void`	`postTypeVarSubstitution(AnnotatedTypeMirror.AnnotatedTypeVariable varDecl, AnnotatedTypeMirror.AnnotatedTypeVariable varUse, AnnotatedTypeMirror value)` A callback method for the AnnotatedTypeFactory subtypes to customize AnnotatedTypeMirror.substitute().
`void`	`preProcessClassTree(ClassTree classTree)` Called by `BaseTypeVisitor.visitClass(ClassTree, Void)` before the classTree is type checked.
`void`	`setEnclosingElementForArtificialTree(Tree tree, Element enclosing)` Handle an artificial tree by mapping it to the enclosing element.
`void`	`setRoot(@Nullable CompilationUnitTree root)` Set the CompilationUnitTree that should be used.
`boolean`	`shouldWarnIfStubRedundantWithBytecode()` Returns true if redundancy between a stub file and bytecode should be reported.
`protected AnnotatedTypeMirror`	`toAnnotatedType(TypeMirror t, boolean declaration)` A convenience method that converts a `TypeMirror` to an empty `AnnotatedTypeMirror` using `AnnotatedTypeMirror.createType(javax.lang.model.type.TypeMirror, org.checkerframework.framework.type.AnnotatedTypeFactory, boolean)`.
`String`	`toString()`
`protected AnnotatedTypeMirror`	`type(Tree node)` Determines an empty annotated type of the given tree.
`List<AnnotatedTypeParameterBounds>`	`typeVariablesFromUse(AnnotatedTypeMirror.AnnotatedDeclaredType type, TypeElement element)` Adapt the upper bounds of the type variables of a class relative to the type instantiation.
`AnnotatedTypeMirror`	`widenToUpperBound(AnnotatedTypeMirror annotatedTypeMirror, AnnotatedTypeMirror.AnnotatedWildcardType wildcard)` If `wildcard`'s upper bound is a super type of `annotatedTypeMirror`, this method returns an AnnotatedTypeMirror with the same qualifiers as `annotatedTypeMirror`, but the underlying Java type is the most specific base type of `annotatedTypeMirror` whose erasure type is equivalent to the upper bound of `wildcard`.

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 @Nullable CompilationUnitTree root
```
    Optional! The AST of the source file being operated on.
  - processingEnv
```
protected final ProcessingEnvironment processingEnv
```
    The processing environment to use for accessing compiler internals.
  - elements
```
protected final Elements elements
```
    Utility class for working with Elements.
  - types
```
public final Types types
```
    Utility class for working with TypeMirrors.
  - visitorState
```
protected final VisitorState visitorState
```
    The state of the visitor.
  - qualHierarchy
```
protected QualifierHierarchy qualHierarchy
```
    Represent the annotation relations.
  - typeHierarchy
```
protected TypeHierarchy typeHierarchy
```
    Represent the type relations.
  - typeFormatter
```
protected final AnnotatedTypeFormatter typeFormatter
```
    This formatter is used for converting AnnotatedTypeMirrors to Strings. This formatter will be used by all AnnotatedTypeMirrors created by this factory in their toString methods.
  - qualifierUpperBounds
```
protected QualifierUpperBounds qualifierUpperBounds
```
    Holds the qualifier upper bounds for type uses.
  - typeVarSubstitutor
```
protected TypeVariableSubstitutor typeVarSubstitutor
```
    Provides utility method to substitute arguments for their type variables. Field should be final, but can only be set in postInit, because subtypes might need other state to be initialized first.
  - typeArgumentInference
```
protected TypeArgumentInference typeArgumentInference
```
    Provides utility method to infer type arguments.
  - stubTypes
```
public final StubTypes stubTypes
```
    Parses stub files and stores annotations from stub files.
  - checker
```
protected final BaseTypeChecker checker
```
    The checker to use for option handling and resource management.
  - uid
```
public final int uid
```
    Unique ID of the current object; for debugging purposes.
  - reflectionResolver
```
protected ReflectionResolver reflectionResolver
```
    Object that is used to resolve reflective method calls, if reflection resolution is turned on.
  - loader
```
protected AnnotationClassLoader loader
```
    AnnotationClassLoader used to load type annotation classes via reflective lookup.
  - shouldCache
```
public boolean shouldCache
```
    Should results be cached? This means that ATM.deepCopy() will be called. ATM.deepCopy() used to (and perhaps still does) side effect the ATM being copied. So setting this to false is not equivalent to setting shouldReadCache to false.
  - fromExpressionTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromExpressionTreeCache
```
    Mapping from an expression tree to its annotated type; before defaults are applied, just what the programmer wrote.
  - fromMemberTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromMemberTreeCache
```
    Mapping from a member tree to its annotated type; before defaults are applied, just what the programmer wrote.
  - fromTypeTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromTypeTreeCache
```
    Mapping from a type tree to its annotated type; before defaults are applied, just what the programmer wrote.
  - artificialTreeToEnclosingElementMap
```
protected final Map<Tree,Element> artificialTreeToEnclosingElementMap
```
    Mapping from CFG generated trees to their enclosing elements.
  - ignoreUninferredTypeArguments
```
public final boolean ignoreUninferredTypeArguments
```
    Whether to ignore uninferred type arguments. This is a temporary flag to work around Issue 979.
  - objectGetClass
```
protected final ExecutableElement objectGetClass
```
    The Object.getClass method.
- Constructor Detail
  - AnnotatedTypeFactory
```
public AnnotatedTypeFactory(BaseTypeChecker checker)
```
    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. postInit must be the last call in the constructor or else types from stub files may not be created as expected.
    
    Parameters:
    
    checker - the SourceChecker to which this factory belongs
    
    Throws:
    
    IllegalArgumentException - if either argument is null
- Method Detail
  - checkInvalidOptionsInferSignatures
```
protected void checkInvalidOptionsInferSignatures()
```
    This method is called only when -Ainfer is passed as an option. It checks if another option that should not occur simultaneously with the whole-program inference is also passed as argument, and aborts the process if that is the case. For example, the whole-program inference process was not designed to work with conservative defaults.
    Subclasses may override this method to add more options.
  - postInit
```
protected void postInit()
```
    Actions that logically belong in the constructor, but need to run after the subclass constructor has completed. In particular, parseStubFiles() may try to do type resolution with this AnnotatedTypeFactory.
  - createQualifierUpperBounds
```
protected QualifierUpperBounds createQualifierUpperBounds()
```
    Creates QualifierUpperBounds for this type factory.
  - getQualifierUpperBounds
```
public QualifierUpperBounds getQualifierUpperBounds()
```
    Return QualifierUpperBounds for this type factory.
    
    Returns:
    
    QualifierUpperBounds for this type factory
  - getWholeProgramInference
```
public WholeProgramInference getWholeProgramInference()
```
    Returns the WholeProgramInference instance (may be null).
    
    Returns:
    
    the WholeProgramInference instance, or null
  - initializeReflectionResolution
```
protected void initializeReflectionResolution()
```
  - setRoot
```
public void setRoot(@Nullable CompilationUnitTree root)
```
    Set the CompilationUnitTree that should be used.
    
    Parameters:
    
    root - the new compilation unit to use
  - toString
```
@SideEffectFree
public String toString()
```
    Overrides:
    
    toString in class Object
  - createQualifierHierarchy
```
protected QualifierHierarchy createQualifierHierarchy()
```
    Returns the QualifierHierarchy to be used by this checker.
    The implementation builds the type qualifier hierarchy for the getSupportedTypeQualifiers() using the meta-annotations found in them. The current implementation returns an instance of NoElementQualifierHierarchy.
    Subclasses must override this method if their qualifiers have elements; the method must return an implementation of QualifierHierarchy, such as ElementQualifierHierarchy.
    
    Returns:
    
    a QualifierHierarchy for this type system
  - getQualifierHierarchy
```
public final QualifierHierarchy getQualifierHierarchy()
```
    Returns the type qualifier hierarchy graph to be used by this processor.
    
    Returns:
    
    the QualifierHierarchy for this checker
    
    See Also:
    
    createQualifierHierarchy()
  - createQualifierHierarchyWithMultiGraphFactory
```
@Deprecated
public QualifierHierarchy createQualifierHierarchyWithMultiGraphFactory(MultiGraphQualifierHierarchy.MultiGraphFactory factory)
```
    Deprecated. Use either ElementQualifierHierarchy, NoElementQualifierHierarchy, or MostlyNoElementQualifierHierarchy instead. This method will be removed in a future release.
    
    To continue to use a subclass of MultiGraphQualifierHierarchy or GraphQualifierHierarchy, override this method so that it returns a new instance of the subclass. Then override createQualifierHierarchy() so that it returns the result of a call to MultiGraphQualifierHierarchy.createMultiGraphQualifierHierarchy(AnnotatedTypeFactory).
    
    Parameters:
    
    factory - MultiGraphFactory
    
    Returns:
    
    QualifierHierarchy
  - createTypeHierarchy
```
protected TypeHierarchy createTypeHierarchy()
```
    Creates the type hierarchy to be used by this factory.
    Subclasses may override this method to specify new type-checking rules beyond the typical Java subtyping rules.
    
    Returns:
    
    the type relations class to check type subtyping
  - getTypeHierarchy
```
public final TypeHierarchy getTypeHierarchy()
```
  - createTypeVariableSubstitutor
```
protected TypeVariableSubstitutor createTypeVariableSubstitutor()
```
    TypeVariableSubstitutor provides a method to replace type parameters with their arguments.
  - getTypeVarSubstitutor
```
public TypeVariableSubstitutor getTypeVarSubstitutor()
```
  - createTypeArgumentInference
```
protected TypeArgumentInference createTypeArgumentInference()
```
    TypeArgumentInference infers the method type arguments when they are not explicitly written.
  - getTypeArgumentInference
```
public TypeArgumentInference getTypeArgumentInference()
```
  - createAnnotationClassLoader
```
protected AnnotationClassLoader createAnnotationClassLoader()
```
    Factory method to easily change what AnnotationClassLoader is created to load type annotation classes. Subclasses can override this method and return a custom AnnotationClassLoader subclass to customize loading logic.
  - createSupportedTypeQualifiers
```
protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers()
```
    Returns a mutable set of annotation classes that are supported by a checker.
    Subclasses may override this method to return a mutable set of their supported type qualifiers through one of the 5 approaches shown below.
    Subclasses should not call this method; they should call getSupportedTypeQualifiers() instead.
    By default, a checker supports all annotations located in a subdirectory called qual that's located in the same directory as the checker. Note that only annotations defined with the @Target({ElementType.TYPE_USE}) meta-annotation (and optionally with the additional value of ElementType.TYPE_PARAMETER, but no other ElementType values) are automatically considered as supported annotations.
    To support a different set of annotations than those in the qual subdirectory, or that have other ElementType values, see examples below.
    In total, there are 5 ways to indicate annotations that are supported by a checker:
    1. Only support annotations located in a checker's qual directory:
      This is the default behavior. Simply place those annotations within the qual directory.
    2. Support annotations located in a checker's qual directory and a list of other annotations:
      Place those annotations within the qual directory, and override createSupportedTypeQualifiers() by calling getBundledTypeQualifiers(Class...) with a varargs parameter list of the other annotations. Code example:
      @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { return getBundledTypeQualifiers(Regex.class, PartialRegex.class, RegexBottom.class, UnknownRegex.class); }
    3. Supporting only annotations that are explicitly listed: Override createSupportedTypeQualifiers() and return a mutable set of the supported annotations. Code example:
      @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { return new HashSet<Class<? extends Annotation>>( Arrays.asList(A.class, B.class)); }
      The set of qualifiers returned by createSupportedTypeQualifiers() must be a fresh, mutable set. The methods getBundledTypeQualifiers(Class...) must return a fresh, mutable set
    Returns:
    
    the type qualifiers supported this processor, or an empty set if none
  - getBundledTypeQualifiers
```
@SafeVarargs
protected final Set<Class<? extends Annotation>> getBundledTypeQualifiers(Class<? extends Annotation>... explicitlyListedAnnotations)
```
    Loads all annotations contained in the qual directory of a checker via reflection; if a polymorphic type qualifier exists, and an explicit array of annotations to the set of annotation classes.
    This method can be called in the overridden versions of createSupportedTypeQualifiers() in each checker.
    
    Parameters:
    
    explicitlyListedAnnotations - a varargs array of explicitly listed annotation classes to be added to the returned set. For example, it is used frequently to add Bottom qualifiers.
    
    Returns:
    
    a mutable set of the loaded and listed annotation classes
  - createAnnotatedTypeFormatter
```
protected AnnotatedTypeFormatter createAnnotatedTypeFormatter()
```
    Creates the AnnotatedTypeFormatter used by this type factory and all AnnotatedTypeMirrors it creates. The AnnotatedTypeFormatter is used in AnnotatedTypeMirror.toString and will affect the error messages printed for checkers that use this type factory.
    
    Returns:
    
    the AnnotatedTypeFormatter to pass to all instantiated AnnotatedTypeMirrors
  - getAnnotatedTypeFormatter
```
public AnnotatedTypeFormatter getAnnotatedTypeFormatter()
```
  - createAnnotationFormatter
```
protected AnnotationFormatter createAnnotationFormatter()
```
  - getAnnotationFormatter
```
public AnnotationFormatter getAnnotationFormatter()
```
  - getSupportedTypeQualifiers
```
public final Set<Class<? extends Annotation>> getSupportedTypeQualifiers()
```
    Returns an immutable set of the classes corresponding to the type qualifiers supported by this checker.
    Subclasses cannot override this method; they should override createSupportedTypeQualifiers instead.
    
    Returns:
    
    an immutable set of the supported type qualifiers, or an empty set if no qualifiers are supported
    
    See Also:
    
    createSupportedTypeQualifiers()
  - getSupportedTypeQualifierNames
```
public final Set<String> getSupportedTypeQualifierNames()
```
    Returns an immutable set of the fully qualified names of the type qualifiers supported by this checker.
    Subclasses cannot override this method; they should override createSupportedTypeQualifiers instead.
    
    Returns:
    
    an immutable set of the supported type qualifiers, or an empty set if no qualifiers are supported
    
    See Also:
    
    createSupportedTypeQualifiers()
  - getCacheSize
```
protected int getCacheSize()
```
    Returns the int supplied to the checker via the atfCacheSize option or the default cache size.
    
    Returns:
    
    cache size passed as argument to checker or DEFAULT_CACHE_SIZE
  - getAnnotatedType
```
public AnnotatedTypeMirror getAnnotatedType(Element elt)
```
    Returns an AnnotatedTypeMirror representing the annotated type of elt.
    
    Parameters:
    
    elt - the element
    
    Returns:
    
    the annotated type of elt
  - getAnnotatedType
```
public AnnotatedTypeMirror getAnnotatedType(Class<?> clazz)
```
    Returns an AnnotatedTypeMirror representing the annotated type of clazz.
    
    Parameters:
    
    clazz - a class
    
    Returns:
    
    the annotated type of clazz
  - getAnnotationMirror
```
public @Nullable AnnotationMirror getAnnotationMirror(Tree tree,
                                                      Class<? extends Annotation> target)
```
    Description copied from interface: AnnotationProvider
    
    Return the annotation on tree that is in the hierarchy that contains the qualifier target. Returns null if none exists.
    
    Specified by:
    
    getAnnotationMirror in interface AnnotationProvider
    
    Parameters:
    
    tree - the tree of which the annotation is returned
    
    target - the class of the annotation
    
    Returns:
    
    the annotation on tree that has the class target, or null
  - getAnnotatedType
```
public AnnotatedTypeMirror getAnnotatedType(Tree tree)
```
    Returns an AnnotatedTypeMirror representing the annotated type of tree.
    
    Parameters:
    
    tree - the AST node
    
    Returns:
    
    the annotated type of tree
  - preProcessClassTree
```
public void preProcessClassTree(ClassTree classTree)
```
    Called by BaseTypeVisitor.visitClass(ClassTree, Void) before the classTree is type checked.
    
    Parameters:
    
    classTree - ClassTree on which to perform preprocessing
  - postProcessClassTree
```
public void postProcessClassTree(ClassTree tree)
```
    Called by BaseTypeVisitor.visitClass(ClassTree, Void) after the ClassTree has been type checked.
    The default implementation uses this to store the defaulted AnnotatedTypeMirrors and inherited declaration annotations back into the corresponding Elements. Subclasses might want to override this method if storing defaulted types is not desirable.
  - getAnnotatedTypeFromTypeTree
```
public AnnotatedTypeMirror getAnnotatedTypeFromTypeTree(Tree tree)
```
    Determines the annotated type from a type in tree form.
    Note that we cannot decide from a Tree whether it is a type use or an expression. TreeUtils.isTypeTree is only an under-approximation. For example, an identifier can be either a type or an expression.
    
    Parameters:
    
    tree - the type tree
    
    Returns:
    
    the annotated type of the type in the AST
  - getTypeDeclarationBounds
```
public Set<AnnotationMirror> getTypeDeclarationBounds(TypeMirror type)
```
    Returns the set of qualifiers that are the upper bounds for a use of the type.
    
    Parameters:
    
    type - a type whose upper bounds to obtain
  - getDefaultTypeDeclarationBounds
```
protected Set<? extends AnnotationMirror> getDefaultTypeDeclarationBounds()
```
    Returns the set of qualifiers that are the upper bound for a type use if no other bound is specified for the type.
    This implementation returns the top qualifiers by default. Subclass may override to return different qualifiers.
    
    Returns:
    
    the set of qualifiers that are the upper bound for a type use if no other bound is specified for the type
  - getTypeOfExtendsImplements
```
public AnnotatedTypeMirror getTypeOfExtendsImplements(Tree clause)
```
    Returns the type of the extends or implements clause.
    The primary qualifier is either an explicit annotation on clause, or it is the qualifier upper bounds for uses of the type of the clause.
    
    Parameters:
    
    clause - tree that represents an extends or implements clause
    
    Returns:
    
    the type of the extends or implements clause
  - fromElement
```
public AnnotatedTypeMirror fromElement(Element elt)
```
    Creates an AnnotatedTypeMirror for elt that includes: annotations explicitly written on the element and annotations from stub files.
    
    Parameters:
    
    elt - the element
    
    Returns:
    
    AnnotatedTypeMirror of the element with explicitly-written and stub file annotations
  - mergeStubsIntoType
```
protected AnnotatedTypeMirror mergeStubsIntoType(@Nullable AnnotatedTypeMirror type,
                                                 Element elt)
```
    Merges types from stub files for elt into type by taking the greatest lower bound of the annotations in both.
    
    Parameters:
    
    type - the type to apply stub types to
    
    elt - the element from which to read stub types
    
    Returns:
    
    the type, side-effected to add the stub types
  - addComputedTypeAnnotations
```
protected void addComputedTypeAnnotations(Tree tree,
                                          AnnotatedTypeMirror type)
```
    Changes annotations on a type obtained from a Tree. By default, this method does nothing. GenericAnnotatedTypeFactory uses this method to implement defaulting and inference (flow-sensitive type refinement). Its subclasses usually override it only to customize default annotations.
    Subclasses that override this method should also override addComputedTypeAnnotations(Element, AnnotatedTypeMirror).
    In classes that extend GenericAnnotatedTypeFactory, override GenericAnnotatedTypeFactory.addComputedTypeAnnotations(Tree, AnnotatedTypeMirror, boolean) instead of this method.
    
    Parameters:
    
    tree - an AST node
    
    type - the type obtained from tree
  - addComputedTypeAnnotations
```
protected void addComputedTypeAnnotations(Element elt,
                                          AnnotatedTypeMirror type)
```
    Changes annotations on a type obtained from an Element. By default, this method does nothing. GenericAnnotatedTypeFactory uses this method to implement defaulting.
    Subclasses that override this method should also override addComputedTypeAnnotations(Tree, AnnotatedTypeMirror).
    
    Parameters:
    
    elt - an element
    
    type - the type obtained from elt
  - addDefaultAnnotations
```
protected void addDefaultAnnotations(AnnotatedTypeMirror type)
```
    Adds default annotations to type. This method should only be used in places where the correct annotations cannot be computed because of uninferred type arguments. (See AnnotatedTypeMirror.AnnotatedWildcardType.isUninferredTypeArgument().)
    
    Parameters:
    
    type - annotated type to which default annotations are added
  - postDirectSuperTypes
```
protected void postDirectSuperTypes(AnnotatedTypeMirror type,
                                    List<? extends 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.
    
    Parameters:
    
    type - the type whose supertypes are desired
    
    supertypes - the supertypes as specified by the base AnnotatedTypeFactory
  - postAsMemberOf
```
public void postAsMemberOf(AnnotatedTypeMirror type,
                           AnnotatedTypeMirror owner,
                           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
  - addAnnotationFromFieldInvariant
```
protected void addAnnotationFromFieldInvariant(AnnotatedTypeMirror type,
                                               AnnotatedTypeMirror accessedVia,
                                               VariableElement field)
```
    Adds the qualifier specified by a field invariant for field to type.
    
    Parameters:
    
    type - annotated type to which the annotation is added
    
    accessedVia - the annotated type of the receiver of the accessing tree. (Only used to get the type element of the underling type.)
    
    field - element representing the field
  - getFieldInvariants
```
public FieldInvariants getFieldInvariants(TypeElement element)
```
    Returns the field invariants for the given class, as expressed by the user in @FieldInvariant method annotations.
    Subclasses may implement their own field invariant annotations if @FieldInvariant is not expressive enough. They must override this method to properly create AnnotationMirror and also override getFieldInvariantDeclarationAnnotations() to return their field invariants.
    
    Parameters:
    
    element - class for which to get invariants
    
    Returns:
    
    fields invariants for element
  - getFieldInvariantAnnotationTree
```
public AnnotationTree getFieldInvariantAnnotationTree(List<? extends AnnotationTree> annoTrees)
```
    Returns the AnnotationTree which is a use of one of the field invariant annotations (as specified via getFieldInvariantDeclarationAnnotations(). If one isn't found, null is returned.
    
    Parameters:
    
    annoTrees - trees to look
    
    Returns:
    
    returns the AnnotationTree which is a use of one of the field invariant annotations or null if one isn't found
  - getFieldInvariantDeclarationAnnotations
```
protected Set<Class<? extends Annotation>> getFieldInvariantDeclarationAnnotations()
```
    Returns the set of classes of field invariant annotations.
  - postTypeVarSubstitution
```
public void postTypeVarSubstitution(AnnotatedTypeMirror.AnnotatedTypeVariable varDecl,
                                    AnnotatedTypeMirror.AnnotatedTypeVariable varUse,
                                    AnnotatedTypeMirror value)
```
    A callback method for the AnnotatedTypeFactory subtypes to customize AnnotatedTypeMirror.substitute().
    
    Parameters:
    
    varDecl - a declaration of a type variable
    
    varUse - a use of the same type variable
    
    value - the new type to substitute in for the type variable
  - typeVariablesFromUse
```
public List<AnnotatedTypeParameterBounds> 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.
    An example of an adaptation follows. Suppose, I have a declaration:
```
  class MyClass<E extends List<E>>
```
    And an instantiation:
```
  new MyClass<@NonNull String>()
```
    The upper bound of E adapted to the argument String, would be List<@NonNull String> and the lower bound would be an AnnotatedNullType.
    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 bounds of the type parameters
  - getAnnotatedNullType
```
public AnnotatedTypeMirror.AnnotatedNullType getAnnotatedNullType(Set<? extends AnnotationMirror> annotations)
```
    Creates and returns an AnnotatedNullType qualified with annotations.
    
    Parameters:
    
    annotations - set of AnnotationMirrors to qualify the returned type with
    
    Returns:
    
    AnnotatedNullType qualified with annotations
  - getImplicitReceiverType
```
protected @Nullable 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. The result is also null for expressions that have an explicit receiver.
    Clients should generally call getReceiverType(com.sun.source.tree.ExpressionTree).
    
    Parameters:
    
    tree - the expression that might have an implicit receiver
    
    Returns:
    
    the type of the implicit receiver
  - getSelfType
```
public @Nullable AnnotatedTypeMirror.AnnotatedDeclaredType getSelfType(Tree tree)
```
    Returns the type of this at the location of tree. If tree is in a location where this has no meaning, such as the body of a static method, then null is returned.
    The parameter is an arbitrary tree and does not have to mention "this", neither explicitly nor implicitly. This method can be overridden for type-system specific behavior.
    
    Parameters:
    
    tree - location used to decide the type of this
    
    Returns:
    
    the type of this at the location of tree
  - getEnclosingClassOrMethod
```
protected Tree getEnclosingClassOrMethod(Tree tree)
```
    Returns the inner most enclosing method or class tree of tree. If tree is artificial, that is create by dataflow, then artificialTreeToEnclosingElementMap is used to find the enclosing tree;
    
    Parameters:
    
    tree - tree to whose inner most enclosing method or class is returned.
    
    Returns:
    
    the inner most enclosing method or class tree of tree
  - getEnclosingType
```
public AnnotatedTypeMirror.AnnotatedDeclaredType getEnclosingType(TypeElement typeElement,
                                                                  Tree tree)
```
    Returns the AnnotatedTypeMirror of the enclosing type at the location of tree that is the same type as typeElement.
    
    Parameters:
    
    typeElement - type of the enclosing type to return
    
    tree - location to use
    
    Returns:
    
    he enclosing type at the location of tree that is the same type as typeElement
  - getReceiverType
```
public final AnnotatedTypeMirror getReceiverType(ExpressionTree expression)
```
    Returns the receiver type of the expression tree, or null if it does not exist.
    A type is returned even if the receiver is an implicit this.
    
    Parameters:
    
    expression - the expression for which to determine the receiver type
    
    Returns:
    
    the type of the receiver of expression
  - methodFromUse
```
public AnnotatedTypeFactory.ParameterizedExecutableType 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(Types, AnnotatedTypeFactory, 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(com.sun.source.tree.Tree, java.util.List<? extends org.checkerframework.framework.type.AnnotatedTypeParameterBounds>, java.util.List<? extends org.checkerframework.framework.type.AnnotatedTypeMirror>, java.util.List<? extends com.sun.source.tree.Tree>, javax.lang.model.element.Name, java.util.List<?>) for the checks of type argument well-formedness.
    Note that "this" and "super" constructor invocations are also handled by this method (explicit or implicit ones, at the beginning of a constructor). Method constructorFromUse(NewClassTree) is only used for a constructor invocation in a "new" expression.
    
    Parameters:
    
    tree - the method invocation tree
    
    Returns:
    
    the method type being invoked with tree and the (inferred) type arguments
  - methodFromUse
```
public AnnotatedTypeFactory.ParameterizedExecutableType methodFromUse(ExpressionTree tree,
                                                                      ExecutableElement methodElt,
                                                                      AnnotatedTypeMirror receiverType)
```
    Determines the type of the invoked method based on the passed expression tree, executable element, and receiver type.
    
    Parameters:
    
    tree - either a MethodInvocationTree or a MemberReferenceTree
    
    methodElt - the element of the referenced method
    
    receiverType - the type of the receiver
    
    Returns:
    
    the method type being invoked with tree and the (inferred) type arguments
    
    See Also:
    
    methodFromUse(MethodInvocationTree)
  - methodFromUsePreSubstitution
```
protected void methodFromUsePreSubstitution(ExpressionTree tree,
                                            AnnotatedTypeMirror.AnnotatedExecutableType type)
```
    A callback method for the AnnotatedTypeFactory subtypes to customize the handling of the declared method type before type variable substitution.
    
    Parameters:
    
    tree - either a method invocation or a member reference tree
    
    type - declared method type before type variable substitution
  - adaptGetClassReturnTypeToReceiver
```
protected void adaptGetClassReturnTypeToReceiver(AnnotatedTypeMirror.AnnotatedExecutableType getClassType,
                                                 AnnotatedTypeMirror receiverType)
```
    Java special-cases the return type of getClass(). Though the method has a return type of Class<?>, the compiler special cases this return-type and changes the bound of the type argument to the erasure of the receiver type. For example:
    - x.getClass() has the type Class< ? extends erasure_of_x >
    - someInteger.getClass() has the type Class< ? extends Integer >
    Parameters:
    
    getClassType - this must be a type representing a call to Object.getClass otherwise a runtime exception will be thrown. It is modified by side effect.
    
    receiverType - the receiver type of the method invocation (not the declared receiver type)
  - constructorFromUse
```
public AnnotatedTypeFactory.ParameterizedExecutableType constructorFromUse(NewClassTree tree)
```
    Determines the type of the invoked constructor based on the passed new class tree.
    The returned method type has all type variables resolved, whether based on receiver type, passed type parameters if any, and constructor invocation parameter.
    Subclasses may override this method to customize inference of types or qualifiers based on constructor invocation parameters.
    As an implementation detail, this method depends on AnnotatedTypes.asMemberOf(Types, AnnotatedTypeFactory, AnnotatedTypeMirror, Element), and customization based on receiver type should be in accordance with its specification.
    The return type is a pair of the type of the invoked constructor 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(com.sun.source.tree.Tree, java.util.List<? extends org.checkerframework.framework.type.AnnotatedTypeParameterBounds>, java.util.List<? extends org.checkerframework.framework.type.AnnotatedTypeMirror>, java.util.List<? extends com.sun.source.tree.Tree>, javax.lang.model.element.Name, java.util.List<?>) for the checks of type argument well-formedness.
    Note that "this" and "super" constructor invocations are handled by method methodFromUse(com.sun.source.tree.MethodInvocationTree). This method only handles constructor invocations in a "new" expression.
    
    Parameters:
    
    tree - the constructor invocation tree
    
    Returns:
    
    the annotated type of the invoked constructor (as an executable type) and the (inferred) type arguments
  - constructorFromUsePreSubstitution
```
protected void constructorFromUsePreSubstitution(NewClassTree tree,
                                                 AnnotatedTypeMirror.AnnotatedExecutableType type)
```
    A callback method for the AnnotatedTypeFactory subtypes to customize the handling of the declared constructor type before type variable substitution.
    
    Parameters:
    
    tree - a NewClassTree from constructorFromUse()
    
    type - declared method type before type variable substitution
  - getMethodReturnType
```
public AnnotatedTypeMirror getMethodReturnType(MethodTree m)
```
    Returns the return type of the method m.
    
    Parameters:
    
    m - a tree of method
    
    Returns:
    
    the return type of the method
  - getMethodReturnType
```
public AnnotatedTypeMirror getMethodReturnType(MethodTree m,
                                               ReturnTree r)
```
    Returns the return type of the method m at the return statement r.
  - fromNewClass
```
public AnnotatedTypeMirror.AnnotatedDeclaredType fromNewClass(NewClassTree newClassTree)
```
    Creates an AnnotatedDeclaredType for a NewClassTree. Only adds explicit annotations, unless newClassTree has a diamond operator. In that case, the annotations on the type arguments are inferred using the assignment context and contain defaults.
    Also, fully annotates the enclosing type of the returned declared type.
    (Subclass beside GenericAnnotatedTypeFactory should not override this method.)
    
    Parameters:
    
    newClassTree - NewClassTree
    
    Returns:
    
    AnnotatedDeclaredType
  - 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
  - applyUnboxing
```
public final AnnotatedTypeMirror.AnnotatedPrimitiveType applyUnboxing(AnnotatedTypeMirror type)
```
    Return a primitive type: either the argument, or the result of unboxing it (which might affect its annotations).
    Subclasses should override getUnboxedType(org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType) rather than this method.
    
    Parameters:
    
    type - a type: a primitive or boxed primitive
    
    Returns:
    
    the unboxed variant of the 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.
    In the AnnotatedTypeFactory implementation, the returned type has the same primary annotations as the given type. Subclasses may override this behavior.
    
    Parameters:
    
    type - the declared type
    
    Returns:
    
    the unboxed primitive type
    
    Throws:
    
    IllegalArgumentException - if the type given has no unbox conversion
  - getStringType
```
public AnnotatedTypeMirror.AnnotatedDeclaredType getStringType(AnnotatedTypeMirror type)
```
    Returns AnnotatedDeclaredType with underlying type String and annotations copied from type. Subclasses may change the annotations.
    
    Parameters:
    
    type - type to convert to String
    
    Returns:
    
    AnnotatedTypeMirror that results from converting type to a String type
  - getNarrowedPrimitive
```
public AnnotatedTypeMirror.AnnotatedPrimitiveType getNarrowedPrimitive(AnnotatedTypeMirror.AnnotatedPrimitiveType type,
                                                                       TypeMirror narrowedTypeMirror)
```
    Returns AnnotatedPrimitiveType with underlying type narrowedTypeMirror and with annotations copied or adapted from type.
    Currently this method is called only for primitives that are narrowed at assignments from literal ints, for example, byte b = 1;. All other narrowing conversions happen at typecasts.
    
    Parameters:
    
    type - type to narrow
    
    narrowedTypeMirror - underlying type for the returned type mirror
    
    Returns:
    
    result of converting type to narrowedTypeMirror
  - getWidenedType
```
public final AnnotatedTypeMirror getWidenedType(AnnotatedTypeMirror exprType,
                                                AnnotatedTypeMirror widenedType)
```
    Returns a widened type if applicable, otherwise returns its first argument.
    Subclasses should override getWidenedAnnotations(java.util.Set<javax.lang.model.element.AnnotationMirror>, javax.lang.model.type.TypeKind, javax.lang.model.type.TypeKind) rather than this method.
    
    Parameters:
    
    exprType - type to possibly widen
    
    widenedType - type to possibly widen to; its annotations are ignored
    
    Returns:
    
    if widening is applicable, the result of converting type to the underlying type of widenedType; otherwise type
  - getWidenedAnnotations
```
public Set<AnnotationMirror> getWidenedAnnotations(Set<AnnotationMirror> annos,
                                                   TypeKind typeKind,
                                                   TypeKind widenedTypeKind)
```
    Returns annotations applicable to type widenedTypeKind, that are copied or adapted from annos.
    
    Parameters:
    
    annos - annotations to widen, from a primitive or boxed primitive
    
    typeKind - primitive type to widen
    
    widenedTypeKind - target for the returned annotations; a primitive type
    
    Returns:
    
    result of converting annos from typeKind to widenedTypeKind
  - binaryTreeArgTypes
```
public Pair<AnnotatedTypeMirror,AnnotatedTypeMirror> binaryTreeArgTypes(BinaryTree node)
```
    Returns the types of the two arguments to the BinaryTree, accounting for widening if applicable.
    
    Parameters:
    
    node - a binary tree
    
    Returns:
    
    the types of the two arguments
  - getVisitorState
```
public VisitorState getVisitorState()
```
    Returns the VisitorState instance used by the factory to infer types.
    
    Returns:
    
    the VisitorState instance used by the factory to infer types
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(ClassTree tree)
```
    See getAnnotatedType(Tree).
    
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(NewClassTree tree)
```
    See getAnnotatedType(Tree).
    
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedArrayType getAnnotatedType(NewArrayTree tree)
```
    See getAnnotatedType(Tree).
    
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(MethodTree tree)
```
    See getAnnotatedType(Tree).
    
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(TypeElement elt)
```
    See getAnnotatedType(Element).
    
    See Also:
    
    getAnnotatedType(Element)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(ExecutableElement elt)
```
    See getAnnotatedType(Element).
    
    See Also:
    
    getAnnotatedType(Element)
  - fromElement
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType fromElement(TypeElement elt)
```
    See fromElement(Element).
    
    See Also:
    
    fromElement(Element)
  - fromElement
```
public final AnnotatedTypeMirror.AnnotatedExecutableType fromElement(ExecutableElement elt)
```
    See fromElement(Element).
    
    See Also:
    
    fromElement(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. Null is never a supported qualifier; the parameter is nullable to allow the result of canonicalAnnotation to be passed in directly.
    
    Parameters:
    
    a - any annotation
    
    Returns:
    
    true if that annotation is part of the type system under which this type factory operates, false otherwise
  - isSupportedQualifier
```
public boolean isSupportedQualifier(Class<? extends Annotation> clazz)
```
    Determines whether the given class is a part of the type system under which this type factory operates.
    
    Parameters:
    
    clazz - annotation class
    
    Returns:
    
    true if that class is a type qualifier in the type system under which this type factory operates, false otherwise
  - isSupportedQualifier
```
public boolean isSupportedQualifier(String className)
```
    Determines whether the given class name is a part of the type system under which this type factory operates.
    
    Parameters:
    
    className - fully-qualified annotation class name
    
    Returns:
    
    true if that class name is a type qualifier in the type system under which this type factory operates, false otherwise
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(Class<?> aliasClass,
                                    AnnotationMirror type)
```
    Adds the annotation aliasClass as an alias for the canonical annotation type that will be used by the Checker Framework in the alias's place.
    By specifying the alias/canonical relationship using this method, the elements of the alias are not preserved when the canonical annotation to use is constructed from the alias. If you want the elements to be copied over as well, use addAliasedAnnotation(Class, Class, boolean, String...).
    
    Parameters:
    
    aliasClass - the class of the aliased annotation
    
    type - the canonical annotation
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(@FullyQualifiedName String aliasName,
                                    AnnotationMirror type)
```
    Adds the annotation, whose fully-qualified name is given by aliasName, as an alias for the canonical annotation type that will be used by the Checker Framework in the alias's place.
    Use this method if the alias class is not necessarily on the classpath at Checker Framework compile and run time. Otherwise, use addAliasedAnnotation(Class, AnnotationMirror) which prevents the possibility of a typo in the class name.
    
    Parameters:
    
    aliasName - the canonical name of the aliased annotation
    
    type - the canonical annotation
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(Class<?> aliasClass,
                                    Class<?> canonical,
                                    boolean copyElements,
                                    String... ignorableElements)
```
    Adds the annotation aliasClass as an alias for the canonical annotation type that will be used by the Checker Framework in the alias's place.
    You may specify the copyElements flag to indicate whether you want the elements of the alias to be copied over when the canonical annotation is constructed as a copy of type. Be careful that the framework will try to copy the elements by name matching, so make sure that names and types of the elements to be copied over are exactly the same as the ones in the canonical annotation. Otherwise, an 'Couldn't find element in annotation' error is raised.
    To facilitate the cases where some of the elements is ignored on purpose when constructing the canonical annotation, this method also provides a varargs ignorableElements for you to explicitly specify the ignoring rules. For example, org.checkerframework.checker.index.qual.IndexFor is an alias of org.checkerframework.checker.index.qual.NonNegative, but the element "value" of @IndexFor should be ignored when constructing @NonNegative. In the cases where all elements are ignored, we can simply use addAliasedAnnotation(Class, AnnotationMirror) instead.
    
    Parameters:
    
    aliasClass - the class of the aliased annotation
    
    canonical - the canonical annotation
    
    copyElements - a flag that indicates whether you want to copy the elements over when getting the alias from the canonical annotation
    
    ignorableElements - a list of elements that can be safely dropped when the elements are being copied over
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(@FullyQualifiedName String aliasName,
                                    Class<?> canonicalAnno,
                                    boolean copyElements,
                                    String... ignorableElements)
```
    Adds the annotation, whose fully-qualified name is given by aliasName, as an alias for the canonical annotation type that will be used by the Checker Framework in the alias's place.
    Use this method if the alias class is not necessarily on the classpath at Checker Framework compile and run time. Otherwise, use addAliasedAnnotation(Class, Class, boolean, String[]) which prevents the possibility of a typo in the class name.
    
    Parameters:
    
    aliasName - the canonical name of the aliased class
    
    canonicalAnno - the canonical annotation
    
    copyElements - a flag that indicates whether we want to copy the elements over when getting the alias from the canonical annotation
    
    ignorableElements - a list of elements that can be safely dropped when the elements are being copied over
  - canonicalAnnotation
```
public @Nullable AnnotationMirror canonicalAnnotation(AnnotationMirror a)
```
    Returns the canonical annotation for the passed annotation. Returns null if the passed annotation is not an alias of a canonical one in the framework.
    A canonical annotation is the internal annotation that will be used by the Checker Framework in the aliased annotation's place.
    
    Parameters:
    
    a - the qualifier to check for an alias
    
    Returns:
    
    the canonical annotation, or null if none exists
  - addAliasedDeclAnnotation
```
protected void addAliasedDeclAnnotation(Class<? extends Annotation> alias,
                                        Class<? extends Annotation> annotation,
                                        AnnotationMirror annotationToUse)
```
    Add the annotation alias as an alias for the declaration annotation annotation, where the annotation mirror annotationToUse will be used instead. If multiple calls are made with the same annotation, then the annotationToUse must be the same.
    The point of annotationToUse is that it may include elements/fields.
  - addInheritedAnnotation
```
protected void addInheritedAnnotation(AnnotationMirror annotation)
```
    Adds the annotation annotation in the set of declaration annotations that should be inherited. A declaration annotation will be inherited if it is in this list, or if it has the meta-annotation @InheritedAnnotation. The meta-annotation @InheritedAnnotation should be used instead of this method, if possible.
  - toAnnotatedType
```
protected final AnnotatedTypeMirror toAnnotatedType(TypeMirror t,
                                                    boolean declaration)
```
    A convenience method that converts a TypeMirror to an empty AnnotatedTypeMirror using AnnotatedTypeMirror.createType(javax.lang.model.type.TypeMirror, org.checkerframework.framework.type.AnnotatedTypeFactory, boolean).
    
    Parameters:
    
    t - the TypeMirror
    
    declaration - true if the result should be marked as a type declaration
    
    Returns:
    
    an AnnotatedTypeMirror that has t as its underlying type
  - type
```
protected final AnnotatedTypeMirror type(Tree node)
```
    Determines an empty annotated type of the given tree. In other words, finds the TypeMirror for the tree and converts that into an AnnotatedTypeMirror, but does not add any annotations to the result.
    Most users will want to use getAnnotatedType(Tree) instead; this method is mostly for internal use.
    
    Parameters:
    
    node - the tree to analyze
    
    Returns:
    
    the type of node, without any annotations
  - declarationFromElement
```
public final Tree declarationFromElement(Element elt)
```
    Gets the declaration tree for the element, if the source is available.
    TODO: would be nice to move this to InternalUtils/TreeUtils.
    
    Parameters:
    
    elt - an element
    
    Returns:
    
    the tree declaration of the element if found
  - getCurrentClassTree
```
protected final ClassTree getCurrentClassTree(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(Tree tree)
```
  - getCurrentMethodReceiver
```
protected final @Nullable AnnotatedTypeMirror.AnnotatedDeclaredType getCurrentMethodReceiver(Tree tree)
```
    Returns the receiver type of the current method being visited, and returns null if the visited tree is not within a method or if that method has no receiver (e.g. a static 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(Tree tree)
```
  - getPath
```
public final TreePath getPath(@FindDistinct
                              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
  - getEnclosingElementForArtificialTree
```
public final Element getEnclosingElementForArtificialTree(Tree node)
```
    Gets the Element representing the declaration of the method enclosing a tree node. This feature is used to record the enclosing methods of Trees that are created internally by the checker.
    TODO: Find a better way to store information about enclosing Trees.
    
    Parameters:
    
    node - the Tree to get the enclosing method for
    
    Returns:
    
    the method Element enclosing the argument, or null if none has been recorded
  - setEnclosingElementForArtificialTree
```
public final void setEnclosingElementForArtificialTree(Tree tree,
                                                       Element enclosing)
```
    Handle an artificial tree by mapping it to the enclosing element.
    See org.checkerframework.framework.flow.CFCFGBuilder.CFCFGTranslationPhaseOne.handleArtificialTree(Tree).
    
    Parameters:
    
    tree - artifical tree
    
    enclosing - element that encloses tree
  - parseStubFiles
```
protected void parseStubFiles()
```
    Parses the stub files in the following order:
    1. jdk.astub in the same directory as the checker, if it exists and ignorejdkastub option is not supplied
    2. jdkN.astub, where N is the Java version in the same directory as the checker, if it exists and ignorejdkastub option is not supplied
    3. Stub files listed in @StubFiles annotation on the checker; must be in same directory as the checker
    4. Stub files provide via stubs system property
    5. Stub files provide via stubs environment variable
    6. Stub files provide via stubs compiler option
    If a type is annotated with a qualifier from the same hierarchy in more than one stub file, the qualifier in the last stub file is applied.
    Sets typesFromStubFiles and declAnnosFromStubFiles by side effect, just before returning.
  - getDeclAnnotation
```
public final AnnotationMirror getDeclAnnotation(Element elt,
                                                Class<? extends Annotation> anno)
```
    Returns all of the declaration annotations whose name equals the passed annotation class (or is an alias for it) including annotations:
    - on the element
    - written in stubfiles
    - inherited from overriden methods, (see InheritedAnnotation)
    - inherited from superclasses or super interfaces (see Inherited)
    Specified by:
    
    getDeclAnnotation in interface AnnotationProvider
    
    Parameters:
    
    elt - the element to retrieve the declaration annotation from
    
    anno - annotation class
    
    Returns:
    
    the annotation mirror for anno
    
    See Also:
    
    getDeclAnnotationNoAliases(javax.lang.model.element.Element, java.lang.Class<? extends java.lang.annotation.Annotation>)
  - getDeclAnnotationNoAliases
```
public final AnnotationMirror getDeclAnnotationNoAliases(Element elt,
                                                         Class<? extends Annotation> anno)
```
    Returns the actual annotation mirror used to annotate this element, whose name equals the passed annotation class. Returns null if none exists. Does not check for aliases of the annotation class.
    Call this method from a checker that needs to alias annotations for one purpose and not for another. For example, in the Lock Checker, @LockingFree and @ReleasesNoLocks are both aliases of @SideEffectFree since they are all considered side-effect-free with regard to the set of locks held before and after the method call. However, a synchronized block is permitted inside a @ReleasesNoLocks method but not inside a @LockingFree or @SideEffectFree method.
    
    Parameters:
    
    elt - the element to retrieve the declaration annotation from
    
    anno - annotation class
    
    Returns:
    
    the annotation mirror for anno
    
    See Also:
    
    getDeclAnnotation(javax.lang.model.element.Element, java.lang.Class<? extends java.lang.annotation.Annotation>)
  - isFromStubFile
```
public boolean isFromStubFile(Element element)
```
    Returns true if the element appears in a stub file (Currently only works for methods, constructors, and fields).
  - isFromByteCode
```
public boolean isFromByteCode(Element element)
```
    Returns true if the element is from bytecode and the if the element did not appear in a stub file. Currently only works for methods, constructors, and fields.
  - shouldWarnIfStubRedundantWithBytecode
```
public boolean shouldWarnIfStubRedundantWithBytecode()
```
    Returns true if redundancy between a stub file and bytecode should be reported.
    For most type systems the default behavior of returning true is correct. For subcheckers, redundancy in one of the type hierarchies can be ok. Such implementations should return false.
    
    Returns:
    
    whether to warn about redundancy between a stub file and bytecode
  - getDeclAnnotations
```
public Set<AnnotationMirror> getDeclAnnotations(Element elt)
```
    Returns all of the declaration annotations on this element including annotations
    - on the element
    - written in stubfiles
    - inherited from overriden methods, (see InheritedAnnotation)
    - inherited from superclasses or super interfaces (see Inherited)
    This method returns the actual annotations not their aliases. getDeclAnnotation(Element, Class) returns aliases.
    Parameters:
    
    elt - the element for which to determine annotations
    
    Returns:
    
    all of the declaration annotations on this element, written in stub files, or inherited.
  - getDeclAnnotationWithMetaAnnotation
```
public List<Pair<AnnotationMirror,AnnotationMirror>> getDeclAnnotationWithMetaAnnotation(Element element,
                                                                                         Class<? extends Annotation> metaAnnotationClass)
```
    Returns a list of all declaration annotations used to annotate this element, which have a meta-annotation (i.e., an annotation on that annotation) with class metaAnnotationClass.
    
    Parameters:
    
    element - the element for which to determine annotations
    
    metaAnnotationClass - the class of the meta-annotation that needs to be present
    
    Returns:
    
    a list of pairs (anno, metaAnno) where anno is the annotation mirror at element, and metaAnno is the annotation mirror (of type metaAnnotationClass) used to meta-annotate the declaration of anno
  - getAnnotationWithMetaAnnotation
```
public List<Pair<AnnotationMirror,AnnotationMirror>> getAnnotationWithMetaAnnotation(Element element,
                                                                                     Class<? extends Annotation> metaAnnotationClass)
```
    Returns a list of all annotations used to annotate this element, which have a meta-annotation (i.e., an annotation on that annotation) with class metaAnnotationClass.
    
    Parameters:
    
    element - the element at which to look for annotations
    
    metaAnnotationClass - the class of the meta-annotation that needs to be present
    
    Returns:
    
    a list of pairs (anno, metaAnno) where anno is the annotation mirror at element, and metaAnno is the annotation mirror used to annotate anno.
  - hasQualifierParameterInHierarchy
```
public boolean hasQualifierParameterInHierarchy(AnnotatedTypeMirror annotatedTypeMirror,
                                                AnnotationMirror top)
```
    Whether or not the annotatedTypeMirror has a qualifier parameter.
    
    Parameters:
    
    annotatedTypeMirror - AnnotatedTypeMirror to check
    
    top - the top of the hierarchy to check
    
    Returns:
    
    true if the type has a qualifier parameter
  - hasQualifierParameterInHierarchy
```
public boolean hasQualifierParameterInHierarchy(@Nullable Element element,
                                                AnnotationMirror top)
```
    Whether or not the element has a qualifier parameter.
    
    Parameters:
    
    element - element to check
    
    top - the top of the hierarchy to check
    
    Returns:
    
    true if the type has a qualifier parameter
  - hasExplicitQualifierParameterInHierarchy
```
public boolean hasExplicitQualifierParameterInHierarchy(Element element,
                                                        AnnotationMirror top)
```
    Returns whether the HasQualifierParameter annotation was explicitly written on element for the hierarchy given by top.
    
    Parameters:
    
    element - Element to check
    
    top - the top qualifier for the hierarchy to check
    
    Returns:
    
    whether the class given by element has been explicitly annotated with HasQualifierParameter for the given hierarchy
  - hasExplicitNoQualifierParameterInHierarchy
```
public boolean hasExplicitNoQualifierParameterInHierarchy(Element element,
                                                          AnnotationMirror top)
```
    Returns whether the NoQualifierParameter annotation was explicitly written on element for the hierarchy given by top.
    
    Parameters:
    
    element - Element to check
    
    top - the top qualifier for the hierarchy to check
    
    Returns:
    
    whether the class given by element has been explicitly annotated with NoQualifierParameter for the given hierarchy
  - getQualifierParameterHierarchies
```
public Set<AnnotationMirror> getQualifierParameterHierarchies(AnnotatedTypeMirror annotatedType)
```
    Returns the set of top annotations representing all the hierarchies for which this type has a qualifier parameter.
    
    Parameters:
    
    annotatedType - AnnotatedTypeMirror to check
    
    Returns:
    
    the set of top annotations representing all the hierarchies for which this type has a qualifier parameter
  - getQualifierParameterHierarchies
```
public Set<AnnotationMirror> getQualifierParameterHierarchies(Element element)
```
    Returns the set of top annotations representing all the hierarchies for which this element has a qualifier parameter.
    
    Parameters:
    
    element - Element to check
    
    Returns:
    
    the set of top annotations representing all the hierarchies for which this element has a qualifier parameter
  - getUninferredWildcardType
```
public AnnotatedTypeMirror.AnnotatedWildcardType getUninferredWildcardType(AnnotatedTypeMirror.AnnotatedTypeVariable typeVar)
```
    Returns a wildcard type to be used as a type argument when the correct type could not be inferred. The wildcard will be marked as an uninferred wildcard so that AnnotatedTypeMirror.AnnotatedWildcardType.isUninferredTypeArgument() returns true.
    This method should only be used by type argument inference. org.checkerframework.framework.util.AnnotatedTypes.inferTypeArguments(ProcessingEnvironment, AnnotatedTypeFactory, ExpressionTree, ExecutableElement)
    
    Parameters:
    
    typeVar - TypeVariable which could not be inferred
    
    Returns:
    
    a wildcard that is marked as an uninferred type argument
  - widenToUpperBound
```
public AnnotatedTypeMirror widenToUpperBound(AnnotatedTypeMirror annotatedTypeMirror,
                                             AnnotatedTypeMirror.AnnotatedWildcardType wildcard)
```
    If wildcard's upper bound is a super type of annotatedTypeMirror, this method returns an AnnotatedTypeMirror with the same qualifiers as annotatedTypeMirror, but the underlying Java type is the most specific base type of annotatedTypeMirror whose erasure type is equivalent to the upper bound of wildcard.
    Otherwise, returns annotatedTypeMirror unmodified.
    For example:
```
 wildcard := @NonNull ? extends @NonNull Object
 annotatedTypeMirror := @Nullable String

 widenToUpperBound(annotatedTypeMirror, wildcard) returns @Nullable Object
 
```
    This method is needed because, the Java compiler allows wildcards to have upper bounds above the type variable upper bounds for which they are type arguments. For example, given the following parametric type:
```
  class MyClass<T extends Number>
 
```
    the following is legal:
```
  MyClass<? extends Object>
 
```
    This is sound because in Java the wildcard is capture converted to: CAP#1 extends Number from capture of ? extends Object.
    Because the Checker Framework does not implement capture conversion, wildcard upper bounds may cause spurious errors in subtyping checks. This method prevents those errors by widening the upper bound of the type parameter.
    This method widens the underlying Java type of the upper bound of the type parameter rather than narrowing the bound of the wildcard in order to avoid issuing an error with an upper bound that is not in source code.
    The widened type should only be used for typing checks that require it. Using the widened type elsewhere would cause confusing error messages with types not in the source code.
    Parameters:
    
    annotatedTypeMirror - AnnotatedTypeMirror to widen
    
    wildcard - AnnotatedWildcardType whose upper bound is used to widen
    
    Returns:
    
    annotatedTypeMirror widen to the upper bound of wildcard
  - getFunctionTypeFromTree
```
public AnnotatedTypeMirror.AnnotatedExecutableType getFunctionTypeFromTree(MemberReferenceTree tree)
```
    Returns the function type that this member reference targets.
    The function type is the type of the single method declared in the functional interface adapted as if it were invoked using the functional interface as the receiver expression.
    The target type of a member reference is the type to which it is assigned or casted.
    
    Parameters:
    
    tree - member reference tree
    
    Returns:
    
    the function type that this method reference targets
  - getFunctionTypeFromTree
```
public AnnotatedTypeMirror.AnnotatedExecutableType getFunctionTypeFromTree(LambdaExpressionTree tree)
```
    Returns the function type that this lambda targets.
    The function type is the type of the single method declared in the functional interface adapted as if it were invoked using the functional interface as the receiver expression.
    The target type of a lambda is the type to which it is assigned or casted.
    
    Parameters:
    
    tree - lambda expression tree
    
    Returns:
    
    the function type that this lambda targets
  - getFnInterfaceFromTree
```
public Pair<AnnotatedTypeMirror,AnnotatedTypeMirror.AnnotatedExecutableType> getFnInterfaceFromTree(Tree tree)
```
    Returns the functional interface and the function type that this lambda or member references targets.
    The function type is the type of the single method declared in the functional interface adapted as if it were invoked using the functional interface as the receiver expression.
    The target type of a lambda or a method reference is the type to which it is assigned or casted.
    
    Parameters:
    
    tree - lambda expression tree or member reference tree
    
    Returns:
    
    the functional interface and the function type that this method reference or lambda targets
  - getElementUtils
```
public Elements getElementUtils()
```
    Accessor for the element utilities.
  - getTreeUtils
```
public Trees getTreeUtils()
```
    Accessor for the tree utilities.
  - getProcessingEnv
```
public ProcessingEnvironment getProcessingEnv()
```
    Accessor for the processing environment.
  - getContext
```
public CFContext getContext()
```
    Accessor for the CFContext.
  - getExpressionAndOffset
```
public static Pair<String,String> getExpressionAndOffset(String expression)
```
    Given an expression, split it into a subexpression and a constant offset. For example:
```
 "a" => <"a", "0">
 "a + 5" => <"a", "5">
 "a + -5" => <"a", "-5">
 "a - 5" => <"a", "-5">
 
```
    There are methods that can only take as input an expression that represents a Receiver. The purpose of this is to pre-process expressions to make those methods more likely to succeed.
    Parameters:
    
    expression - an expression to remove a constant offset from
    
    Returns:
    
    a sub-expression and a constant offset. The offset is "0" if this routine is unable to splite the given expression
  - negateConstant
```
public static String negateConstant(String constantExpression)
```
    Given an expression string, returns its negation.
    
    Parameters:
    
    constantExpression - a string representing an integer constant
    
    Returns:
    
    the negation of constantExpression
  - getDummyAssignedTo
```
public @Nullable AnnotatedTypeMirror getDummyAssignedTo(ExpressionTree expressionTree)
```
    Returns null or an annotated type mirror that type argument inference should assume expressionTree is assigned to.
    If null is returned, inference proceeds normally.
    If a type is returned, then inference assumes that expressionTree was asigned to it. This biases the inference algorithm toward the annotations in the returned type. In particular, if the annotations on type variables in invariant positions are a super type of the annotations inferred, the super type annotations are chosen.
    This implementation returns null, but subclasses may override this method to return a type.
    
    Parameters:
    
    expressionTree - an expression which has no assignment context and for which type arguments need to be inferred
    
    Returns:
    
    null or an annotated type mirror that inferrence should pretend expressionTree is assigned to
  - areSameByClass
```
public boolean areSameByClass(AnnotationMirror am,
                              Class<? extends Annotation> annoClass)
```
    Checks that the annotation am has the name of annoClass. Values are ignored.
    This method is faster than AnnotationUtils.areSameByClass(AnnotationMirror, Class) because is caches the name of the class rather than computing it each time.
    
    Parameters:
    
    am - the AnnotationMirror whose class to compare
    
    annoClass - the class to compare
    
    Returns:
    
    true if annoclass is the class of am
  - containsSameByClass
```
public boolean containsSameByClass(Collection<? extends AnnotationMirror> c,
                                   Class<? extends Annotation> anno)
```
    Checks that the collection contains the annotation. Using Collection.contains does not always work, because it does not use areSame for comparison.
    This method is faster than AnnotationUtils.containsSameByClass(Collection, Class) because is caches the name of the class rather than computing it each time.
    
    Parameters:
    
    c - a collection of AnnotationMirrors
    
    anno - the annotation class to search for in c
    
    Returns:
    
    true iff c contains anno, according to areSameByClass
  - getAnnotationByClass
```
public @Nullable AnnotationMirror getAnnotationByClass(Collection<? extends AnnotationMirror> c,
                                                       Class<? extends Annotation> anno)
```
    Returns the AnnotationMirror in c that has the same class as anno.
    This method is faster than AnnotationUtils.getAnnotationByClass(Collection, Class) because is caches the name of the class rather than computing it each time.
    
    Parameters:
    
    c - a collection of AnnotationMirrors
    
    anno - the class to search for in c
    
    Returns:
    
    AnnotationMirror with the same class as anno iff c contains anno, according to areSameByClass; otherwise, null

Class AnnotatedTypeFactory

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

trees

root

processingEnv

elements

types

visitorState

qualHierarchy

typeHierarchy

typeFormatter

qualifierUpperBounds

typeVarSubstitutor

typeArgumentInference

stubTypes

checker

uid

reflectionResolver

loader

shouldCache

fromExpressionTreeCache

fromMemberTreeCache

fromTypeTreeCache

artificialTreeToEnclosingElementMap

ignoreUninferredTypeArguments

objectGetClass

Constructor Detail

AnnotatedTypeFactory

Method Detail

checkInvalidOptionsInferSignatures

postInit

createQualifierUpperBounds

getQualifierUpperBounds

getWholeProgramInference

initializeReflectionResolution

setRoot

toString

createQualifierHierarchy

getQualifierHierarchy

createQualifierHierarchyWithMultiGraphFactory

createTypeHierarchy

getTypeHierarchy

createTypeVariableSubstitutor

getTypeVarSubstitutor

createTypeArgumentInference

getTypeArgumentInference

createAnnotationClassLoader

createSupportedTypeQualifiers

getBundledTypeQualifiers

createAnnotatedTypeFormatter

getAnnotatedTypeFormatter

createAnnotationFormatter

getAnnotationFormatter

getSupportedTypeQualifiers

getSupportedTypeQualifierNames

getCacheSize

getAnnotatedType

getAnnotatedType

getAnnotationMirror

getAnnotatedType

preProcessClassTree

postProcessClassTree

getAnnotatedTypeFromTypeTree

getTypeDeclarationBounds

getDefaultTypeDeclarationBounds

getTypeOfExtendsImplements

fromElement

mergeStubsIntoType

addComputedTypeAnnotations

addComputedTypeAnnotations

addDefaultAnnotations

postDirectSuperTypes

postAsMemberOf

addAnnotationFromFieldInvariant

getFieldInvariants