AnnotatedTypeFactory

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

All Implemented Interfaces:

AnnotationProvider

Direct Known Subclasses:

GeneralAnnotatedTypeFactory, GenericAnnotatedTypeFactory
```
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.
Type system checker writers may need to subclass this class, to add implicit and default qualifiers according to the type system semantics. Subclasses should especially override addComputedTypeAnnotations(Element, AnnotatedTypeMirror) and addComputedTypeAnnotations(Tree, AnnotatedTypeMirror). (Also, addDefaultAnnotations(AnnotatedTypeMirror) adds annotations, but that method is a work around 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
`protected static class`	`AnnotatedTypeFactory.InheritedFromClassAnnotator` A singleton utility class for pulling annotations down from a class type.

Field Summary

Fields
Modifier and Type	Field and Description
`protected 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>`	`fromTreeCache` Mapping from a Tree to its annotated type; before implicits are applied, just what the programmer wrote.
`boolean`	`ignoreUninferredTypeArguments` Whether to ignore uninferred type arguments.
`protected AnnotationClassLoader`	`loader` Annotated Type Loader used to load annotation classes via reflective lookup
`protected ProcessingEnvironment`	`processingEnv` The processing environment to use for accessing compiler internals.
`protected QualifierHierarchy`	`qualHierarchy` Represent the annotation relations.
`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.
`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.
`protected 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
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, AnnotationMirror type, 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(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(String aliasName, AnnotationMirror type, 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 `annoationToUse` 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)` Adds implicit annotations to a type obtained from a `Element`.
`protected void`	`addComputedTypeAnnotations(Tree tree, AnnotatedTypeMirror type)` Adds implicit annotations to 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.
`@Nullable AnnotationMirror`	`aliasedAnnotation(AnnotationMirror a)` Returns the canonical annotation for the passed annotation if it is an alias of a canonical one in the framework.
`protected void`	`annotateInheritedFromClass(AnnotatedTypeMirror type)` Adds annotations to the type based on the annotations from its class type if and only if no annotations are already present on the type.
`protected void`	`annotateInheritedFromClass(AnnotatedTypeMirror type, Set<AnnotationMirror> fromClass)` Callback to determine what to do with the annotations from a class declaration.
`protected void`	`checkInvalidOptionsInferSignatures()` This method is called only when `-Ainfer` is passed as an option.
`Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>>`	`constructorFromUse(NewClassTree tree)` Determines the type of the invoked constructor based on the passed new class tree.
`protected AnnotatedTypeFormatter`	`createAnnotatedTypeFormatter()` Creates the AnnotatedTypeFormatter used by this type factory and all AnnotatedTypeMirrors it creates.
`protected AnnotationFormatter`	`createAnnotationFormatter()`
`protected QualifierHierarchy`	`createQualifierHierarchy()` Returns the type qualifier hierarchy graph to be used by this processor.
`protected static QualifierHierarchy`	`createQualifierHierarchy(Elements elements, Set<Class<? extends Annotation>> supportedTypeQualifiers, MultiGraphQualifierHierarchy.MultiGraphFactory factory)` Returns the type qualifier hierarchy graph for a given set of type qualifiers and a factory.
`QualifierHierarchy`	`createQualifierHierarchy(MultiGraphQualifierHierarchy.MultiGraphFactory factory)` Factory method to easily change what QualifierHierarchy is created.
`protected MultiGraphQualifierHierarchy.MultiGraphFactory`	`createQualifierHierarchyFactory()` Factory method to easily change what Factory is used to create a QualifierHierarchy.
`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 subtyping checker using the current type qualifier hierarchy.
`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)`
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`fromElement(TypeElement elt)`
`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.AnnotatedDeclaredType`	`getAnnotatedType(ClassTree tree)`
`AnnotatedTypeMirror`	`getAnnotatedType(Element elt)` Returns an AnnotatedTypeMirror representing the annotated type of `elt`.
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getAnnotatedType(ExecutableElement elt)`
`AnnotatedTypeMirror.AnnotatedExecutableType`	`getAnnotatedType(MethodTree tree)`
`AnnotatedTypeMirror.AnnotatedArrayType`	`getAnnotatedType(NewArrayTree tree)`
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getAnnotatedType(NewClassTree tree)`
`AnnotatedTypeMirror`	`getAnnotatedType(Tree tree)` Returns an AnnotatedTypeMirror representing the annotated type of `tree`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getAnnotatedType(TypeElement elt)`
`AnnotatedTypeFormatter`	`getAnnotatedTypeFormatter()`
`AnnotatedTypeMirror`	`getAnnotatedTypeFromTypeTree(Tree tree)` Determines the annotated type from a type in tree form.
`AnnotationFormatter`	`getAnnotationFormatter()`
`AnnotationMirror`	`getAnnotationMirror(Tree tree, Class<? extends Annotation> target)` Return the annotation on `tree` that has the class `target`.
`List<Pair<AnnotationMirror,AnnotationMirror>>`	`getAnnotationWithMetaAnnotation(Element element, Class<? extends Annotation> metaAnnotation)` 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 `metaAnnotation`.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getBoxedType(AnnotatedTypeMirror.AnnotatedPrimitiveType type)` Returns the annotated boxed type of the given primitive type.
`protected Set<Class<? extends Annotation>>`	`getBundledTypeQualifiersWithoutPolyAll(Class<? extends Annotation>... explicitlyListedAnnotations)` Loads all annotations contained in the qual directory of a checker via reflection, and an explicit list of annotations to the set of annotation classes.
`protected Set<Class<? extends Annotation>>`	`getBundledTypeQualifiersWithPolyAll(Class<? extends Annotation>... explicitlyListedAnnotations)` Loads all annotations contained in the qual directory of a checker via reflection, and adds `PolyAll`, 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 the actual annotation mirror used to annotate this element, whose name equals the passed annotation class, if one exists, or null otherwise.
`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, if one exists, or null otherwise.
`Set<AnnotationMirror>`	`getDeclAnnotations(Element elt)` Returns all of the actual annotation mirrors used to annotate this element (includes stub files and declaration annotations from overridden methods).
`List<Pair<AnnotationMirror,AnnotationMirror>>`	`getDeclAnnotationWithMetaAnnotation(Element element, Class<? extends Annotation> metaAnnotation)` 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 `metaAnnotation`.
`Elements`	`getElementUtils()` Accessor for the element utilities.
`Element`	`getEnclosingMethod(Tree node)` Gets the `Element` representing the declaration of the method enclosing a tree node.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getEnclosingType(TypeElement element, Tree tree)` Determine the type of the most enclosing class of the given tree that is a subtype of the given element.
`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.
`Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType>`	`getFnInterfaceFromTree(LambdaExpressionTree tree)`
`Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType>`	`getFnInterfaceFromTree(MemberReferenceTree tree)`
`protected 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 annotations copied 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.
`AnnotatedTypeMirror`	`getReceiverType(ExpressionTree expression)` Returns the receiver type of the expression tree, or null if it does not exist.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getSelfType(Tree tree)` Returns the type of `this` in the current location, which can be used if `this` has a special semantics (e.g.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`getStringType(AnnotatedTypeMirror type)` Returns AnnotatedDeclaredType with underlying type String and annotations copied from type.
`Set<Class<? extends Annotation>>`	`getSupportedTypeQualifiers()` Returns an immutable set of the type qualifiers supported by this checker.
`Trees`	`getTreeUtils()` Accessor for the tree utilities.
`TypeArgumentInference`	`getTypeArgumentInference()`
`TypeHierarchy`	`getTypeHierarchy()`
`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.
`protected void`	`initializeReflectionResolution()`
`boolean`	`isAnyEnclosingThisDeref(ExpressionTree tree)` Does this expression have (the innermost or an outer) "this" as receiver? Note that the receiver can be either explicit or implicit.
`boolean`	`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)
`boolean`	`isFromStubFile(Element element)` Returns true if the element appears in a stub file (Currently only works for methods, constructors, and fields)
`boolean`	`isMostEnclosingThisDeref(ExpressionTree tree)` Determine whether the tree dereferences the most enclosing "this" object.
`boolean`	`isSupportedQualifier(@Nullable AnnotationMirror a)` Determines whether the given annotation is a part of the type system under which this type factory operates.
`protected boolean`	`isWithinConstructor(Tree tree)`
`Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>>`	`methodFromUse(ExpressionTree tree, ExecutableElement methodElt, AnnotatedTypeMirror receiverType)`
`Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>>`	`methodFromUse(MethodInvocationTree tree)` Determines the type of the invoked method based on the passed method invocation tree.
`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 flow.astub in the same directory as BaseTypeChecker 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`	`setPathHack(Tree node, Element enclosing)`
`void`	`setRoot(@Nullable CompilationUnitTree root)`
`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
```
protected 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.
  - 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
  - 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
```
    Annotated Type Loader used to load 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.
  - fromTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromTreeCache
```
    Mapping from a Tree to its annotated type; before implicits are applied, just what the programmer wrote.
  - ignoreUninferredTypeArguments
```
public final boolean ignoreUninferredTypeArguments
```
    Whether to ignore uninferred type arguments. This is a temporary flag to work around Issue 979.
- 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 unchecked code 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.
  - getWholeProgramInference
```
public WholeProgramInference getWholeProgramInference()
```
    Returns the WholeProgramInference instance.
  - initializeReflectionResolution
```
protected void initializeReflectionResolution()
```
  - setRoot
```
public void setRoot(@Nullable CompilationUnitTree root)
```
  - toString
```
@SideEffectFree
public String toString()
```
    Overrides:
    
    toString in class Object
  - createQualifierHierarchyFactory
```
protected MultiGraphQualifierHierarchy.MultiGraphFactory createQualifierHierarchyFactory()
```
    Factory method to easily change what Factory is used to create a QualifierHierarchy.
  - createQualifierHierarchy
```
public QualifierHierarchy createQualifierHierarchy(MultiGraphQualifierHierarchy.MultiGraphFactory factory)
```
    Factory method to easily change what QualifierHierarchy is created. Needs to be public only because the GraphFactory must be able to call this method. No external use of this method is necessary.
  - createQualifierHierarchy
```
protected QualifierHierarchy createQualifierHierarchy()
```
    Returns the type qualifier hierarchy graph to be used by this processor.
    The implementation builds the type qualifier hierarchy for the getSupportedTypeQualifiers() using the meta-annotations found in them. The current implementation returns an instance of GraphQualifierHierarchy.
    Subclasses may override this method to express any relationships that cannot be inferred using meta-annotations (e.g. due to lack of meta-annotations).
    
    Returns:
    
    an annotation relation tree representing the supported qualifiers
  - createQualifierHierarchy
```
protected static QualifierHierarchy createQualifierHierarchy(Elements elements,
                                                             Set<Class<? extends Annotation>> supportedTypeQualifiers,
                                                             MultiGraphQualifierHierarchy.MultiGraphFactory factory)
```
    Returns the type qualifier hierarchy graph for a given set of type qualifiers and a factory.
    The implementation builds the type qualifier hierarchy for the supportedTypeQualifiers. The current implementation returns an instance of GraphQualifierHierarchy.
    
    Returns:
    
    an annotation relation tree representing the supported qualifiers
  - 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()
  - createTypeHierarchy
```
protected TypeHierarchy createTypeHierarchy()
```
    Creates the type subtyping checker using the current type qualifier hierarchy.
    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()
```
  - 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 and 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 PolyAll, and 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.
    Annotations located outside the qual subdirectory, or has other ElementType values must be explicitly listed in code by overriding the createSupportedTypeQualifiers() method, as shown below.
    Lastly, for checkers that do not want to support PolyAll, it must also be explicitly written in code, as shown 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, and PolyAll:
      This is the default behavior. Simply place those annotations within the qual directory.
    2. Support annotations located in a checker's qual directory, but without PolyAll:
      Place those annotations within the qual directory, and override createSupportedTypeQualifiers() by calling getBundledTypeQualifiersWithPolyAll(Class...) with no parameters passed in. Code example:
      @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { return getBundledTypeQualifiersWithoutPolyAll(); }
    3. Support annotations located in a checker's qual directory, PolyAll, and a list of other annotations:
      Place those annotations within the qual directory, and override createSupportedTypeQualifiers() by calling getBundledTypeQualifiersWithPolyAll(Class...) with a varargs parameter list of the other annotations. Code example:
      @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { return getBundledTypeQualifiersWithPolyAll(Regex.class, PartialRegex.class, RegexBottom.class, UnknownRegex.class); }
    4. Support annotations located in a checker's qual directory and a list of other annotations, but without supporting PolyAll:
      Place those annotations within the qual directory, and override createSupportedTypeQualifiers() by calling getBundledTypeQualifiersWithoutPolyAll(Class...) with a varargs parameter list of the other annotations. Code example:
      @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { return getBundledTypeQualifiersWithoutPolyAll(UnknownFormat.class, FormatBottom.class); }
    5. 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 getBundledTypeQualifiersWithoutPolyAll(Class...) and getBundledTypeQualifiersWithPolyAll(Class...) each must return a fresh, mutable set
    Returns:
    
    the type qualifiers supported this processor, or an empty set if none
  - getBundledTypeQualifiersWithPolyAll
```
@SafeVarargs
protected final Set<Class<? extends Annotation>> getBundledTypeQualifiersWithPolyAll(Class<? extends Annotation>... explicitlyListedAnnotations)
```
    Loads all annotations contained in the qual directory of a checker via reflection, and adds PolyAll, 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, as well as PolyAll.
  - getBundledTypeQualifiersWithoutPolyAll
```
@SafeVarargs
protected final Set<Class<? extends Annotation>> getBundledTypeQualifiersWithoutPolyAll(Class<? extends Annotation>... explicitlyListedAnnotations)
```
    Loads all annotations contained in the qual directory of a checker via reflection, and an explicit list 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 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
  - getAnnotationMirror
```
public AnnotationMirror getAnnotationMirror(Tree tree,
                                            Class<? extends Annotation> target)
```
    Description copied from interface: AnnotationProvider
    
    Return the annotation on tree that has the class target. If no annotation for the given target class exists, the result is null
    
    Specified by:
    
    getAnnotationMirror in interface AnnotationProvider
    
    Parameters:
    
    tree - the tree of which the annotation is returned
    
    target - the class of the annotation
  - 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 perfrom 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
  - 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
  - addComputedTypeAnnotations
```
protected void addComputedTypeAnnotations(Tree tree,
                                          AnnotatedTypeMirror type)
```
    Adds implicit annotations to a type obtained from a Tree. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.
    
    Parameters:
    
    tree - an AST node
    
    type - the type obtained from tree
  - addComputedTypeAnnotations
```
protected void addComputedTypeAnnotations(Element elt,
                                          AnnotatedTypeMirror type)
```
    Adds implicit annotations to a type obtained from a Element. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.
    
    Parameters:
    
    elt - an element
    
    type - the type obtained from elt
  - 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 compute 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.
    Subclass 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
  - annotateInheritedFromClass
```
protected void annotateInheritedFromClass(AnnotatedTypeMirror type)
```
    Adds annotations to the type based on the annotations from its class type if and only if no annotations are already present on the type.
    The class type is found using fromElement(Element)
    
    Parameters:
    
    type - the type for which class annotations will be inherited if there are no annotations already present
  - annotateInheritedFromClass
```
protected void annotateInheritedFromClass(AnnotatedTypeMirror type,
                                          Set<AnnotationMirror> fromClass)
```
    Callback to determine what to do with the annotations from a class declaration.
  - 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 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.
    
    Parameters:
    
    tree - the expression that might have an implicit receiver
    
    Returns:
    
    the type of the receiver
  - isMostEnclosingThisDeref
```
public final boolean isMostEnclosingThisDeref(ExpressionTree tree)
```
    Determine whether the tree dereferences the most enclosing "this" object. That is, we have an expression like "f.g" and want to know whether it is an access "this.f.g" or whether e.g. f is a field of an outer class or e.g. f is a local variable.
    
    Parameters:
    
    tree - the tree to check
    
    Returns:
    
    true, iff the tree is an explicit or implicit reference to the most enclosing "this"
  - isAnyEnclosingThisDeref
```
public final boolean isAnyEnclosingThisDeref(ExpressionTree tree)
```
    Does this expression have (the innermost or an outer) "this" as receiver? Note that the receiver can be either explicit or implicit.
    
    Parameters:
    
    tree - the tree to test
    
    Returns:
    
    true, iff the expression uses (the innermost or an outer) "this" as receiver
  - getSelfType
```
public AnnotatedTypeMirror.AnnotatedDeclaredType getSelfType(Tree tree)
```
    Returns the type of this in the current location, which can be used if this has a special semantics (e.g. this is non-null).
    The parameter is an arbitrary tree and does not have to mention "this", neither explicitly nor implicitly. This method should be overridden for type-system specific behavior.
    TODO: in 1.8.2, handle all receiver type annotations. TODO: handle enclosing classes correctly.
  - getEnclosingType
```
public AnnotatedTypeMirror.AnnotatedDeclaredType getEnclosingType(TypeElement element,
                                                                  Tree tree)
```
    Determine the type of the most enclosing class of the given tree that is a subtype of the given element. Receiver type annotations of an enclosing method are considered, similarly return type annotations of an enclosing constructor.
  - getReceiverType
```
public final AnnotatedTypeMirror getReceiverType(ExpressionTree expression)
```
    Returns the receiver type of the expression tree, or null if it does not exist.
    The only trees that could potentially have a receiver are:
    - Array Access
    - Identifiers (whose receivers are usually self type)
    - Method Invocation Trees
    - Member Select Trees
    Parameters:
    
    expression - the expression for which to determine the receiver type
    
    Returns:
    
    the type of the receiver of this expression
  - methodFromUse
```
public Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>> methodFromUse(MethodInvocationTree tree)
```
    Determines the type of the invoked method based on the passed method invocation tree.
    The returned method type has all type variables resolved, whether based on receiver type, passed type parameters if any, and method invocation parameter.
    Subclasses may override this method to customize inference of types or qualifiers based on method invocation parameters.
    As an implementation detail, this method depends on AnnotatedTypes.asMemberOf(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(Tree, List, List, List) for the checks of type argument well-formedness.
    Note that "this" and "super" constructor invocations are also handled by this method. 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 Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>> methodFromUse(ExpressionTree tree,
                                                                                                 ExecutableElement methodElt,
                                                                                                 AnnotatedTypeMirror receiverType)
```
  - 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 Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>> 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(Tree, List, List, 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
  - getMethodReturnType
```
public AnnotatedTypeMirror getMethodReturnType(MethodTree m)
```
    Returns the return type of the method m.
  - 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. Adds explicit annotations and annotations inherited from class declarations annotateInheritedFromClass(AnnotatedTypeMirror).
    If the NewClassTree has type arguments, then any explicit (or inherited from class) annotations on those type arguments are included. If the NewClassTree has a diamond operator, then the annotations on the type arguments are inferred using the assignment context.
    (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
  - getUnboxedType
```
public AnnotatedTypeMirror.AnnotatedPrimitiveType getUnboxedType(AnnotatedTypeMirror.AnnotatedDeclaredType type)
                                                          throws IllegalArgumentException
```
    returns the annotated primitive type of the given declared type if it is a boxed declared type. Otherwise, it throws IllegalArgumentException exception.
    The returned type would have the annotations on the given type and nothing else.
    
    Parameters:
    
    type - the declared type
    
    Returns:
    
    the unboxed primitive type
    
    Throws:
    
    IllegalArgumentException - if the type given has no unbox conversion
  - 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 annotations copied 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
  - getVisitorState
```
public VisitorState getVisitorState()
```
    Returns the VisitorState instance used by the factory to infer types
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(ClassTree tree)
```
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(NewClassTree tree)
```
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedArrayType getAnnotatedType(NewArrayTree tree)
```
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(MethodTree tree)
```
    See Also:
    
    getAnnotatedType(Tree)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType getAnnotatedType(TypeElement elt)
```
    See Also:
    
    getAnnotatedType(Element)
  - getAnnotatedType
```
public final AnnotatedTypeMirror.AnnotatedExecutableType getAnnotatedType(ExecutableElement elt)
```
    See Also:
    
    getAnnotatedType(Element)
  - fromElement
```
public final AnnotatedTypeMirror.AnnotatedDeclaredType fromElement(TypeElement elt)
```
    See Also:
    
    fromElement(Element)
  - fromElement
```
public final AnnotatedTypeMirror.AnnotatedExecutableType fromElement(ExecutableElement elt)
```
    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 aliasedAnnotation 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
  - 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, please refer to addAliasedAnnotation(Class, AnnotationMirror, boolean, String...).
    
    Parameters:
    
    aliasClass - the class of the aliased annotation
    
    type - the canonical annotation
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(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.
    This overload provides a workaround when the alias class cannot be referenced directly. In general, it is nicer and less error-prone to use the addAliasedAnnotation(Class, AnnotationMirror) version instead.
    
    Parameters:
    
    aliasName - the fully-qualified name of the aliased annotation
    
    type - the canonical annotation
  - addAliasedAnnotation
```
protected void addAliasedAnnotation(Class<?> aliasClass,
                                    AnnotationMirror type,
                                    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. 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, @IndexFor is an alias of @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
    
    type - 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(String aliasName,
                                    AnnotationMirror type,
                                    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.
    This overload provides a workaround when the alias class cannot be referenced directly. In general, it is nicer and less error-prone to use the addAliasedAnnotation(Class, AnnotationMirror) version instead.
    
    Parameters:
    
    aliasName - the fully-qualified name of the aliased class
    
    type - 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
  - aliasedAnnotation
```
public @Nullable AnnotationMirror aliasedAnnotation(AnnotationMirror a)
```
    Returns the canonical annotation for the passed annotation if it is an alias of a canonical one in the framework. If it is not an alias, the method returns null.
    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 annoationToUse will be used instead. If multiple calls are made with the same annotation, then the anontationToUse must be the same.
  - 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 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)
```
  - setPathHack
```
public final void setPathHack(Tree node,
                              Element enclosing)
```
  - getPath
```
public final 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.
    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
  - getEnclosingMethod
```
public final Element getEnclosingMethod(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
  - 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. flow.astub in the same directory as BaseTypeChecker
    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 the actual annotation mirror used to annotate this element, whose name equals the passed annotation class, if one exists, or null otherwise.
    
    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, if one exists, or null otherwise. 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)
  - getDeclAnnotations
```
public Set<AnnotationMirror> getDeclAnnotations(Element elt)
```
    Returns all of the actual annotation mirrors used to annotate this element (includes stub files and declaration annotations from overridden methods).
    
    Parameters:
    
    elt - the element for which to determine annotations
  - getDeclAnnotationWithMetaAnnotation
```
public List<Pair<AnnotationMirror,AnnotationMirror>> getDeclAnnotationWithMetaAnnotation(Element element,
                                                                                         Class<? extends Annotation> metaAnnotation)
```
    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 metaAnnotation.
    
    Parameters:
    
    element - the element for which to determine annotations
    
    metaAnnotation - 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.
  - getAnnotationWithMetaAnnotation
```
public List<Pair<AnnotationMirror,AnnotationMirror>> getAnnotationWithMetaAnnotation(Element element,
                                                                                     Class<? extends Annotation> metaAnnotation)
```
    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 metaAnnotation.
    
    Parameters:
    
    element - the element at which to look for annotations
    
    metaAnnotation - 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.
  - 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
  - getFnInterfaceFromTree
```
public Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType> getFnInterfaceFromTree(MemberReferenceTree tree)
```
  - getFnInterfaceFromTree
```
public Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType> getFnInterfaceFromTree(LambdaExpressionTree tree)
```
  - 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.

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

typeVarSubstitutor

typeArgumentInference

checker

uid

reflectionResolver

loader

shouldCache

fromTreeCache

ignoreUninferredTypeArguments

Constructor Detail

AnnotatedTypeFactory

Method Detail

checkInvalidOptionsInferSignatures

postInit

getWholeProgramInference

initializeReflectionResolution

setRoot

toString

createQualifierHierarchyFactory

createQualifierHierarchy

createQualifierHierarchy

createQualifierHierarchy

getQualifierHierarchy

createTypeHierarchy

getTypeHierarchy

createTypeVariableSubstitutor

getTypeVarSubstitutor

createTypeArgumentInference

getTypeArgumentInference

createSupportedTypeQualifiers

getBundledTypeQualifiersWithPolyAll

getBundledTypeQualifiersWithoutPolyAll

createAnnotatedTypeFormatter

getAnnotatedTypeFormatter

createAnnotationFormatter

getAnnotationFormatter

getSupportedTypeQualifiers

getCacheSize

getAnnotatedType

getAnnotationMirror

getAnnotatedType

preProcessClassTree

postProcessClassTree

getAnnotatedTypeFromTypeTree

fromElement

addComputedTypeAnnotations

addComputedTypeAnnotations

addDefaultAnnotations

postDirectSuperTypes

postAsMemberOf

addAnnotationFromFieldInvariant

getFieldInvariants

getFieldInvariantAnnotationTree

getFieldInvariantDeclarationAnnotations

postTypeVarSubstitution

typeVariablesFromUse

annotateInheritedFromClass

annotateInheritedFromClass

getAnnotatedNullType

getImplicitReceiverType

isMostEnclosingThisDeref

isAnyEnclosingThisDeref

getSelfType

getEnclosingType