AnnotatedTypeFactory (checker-framework 2.9.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, implicits, flow-sensitive refinemont, 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 implicit and default qualifiers according to the type system semantics. Subclasses should especially override addComputedTypeAnnotations(Element, AnnotatedTypeMirror) and addComputedTypeAnnotations(Tree, AnnotatedTypeMirror) to handle implicit 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 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 implicits are applied, just what the programmer wrote.
`protected Map<Tree,AnnotatedTypeMirror>`	`fromMemberTreeCache` Mapping from a member tree to its annotated type; before implicits are applied, just what the programmer wrote.
`protected Map<Tree,AnnotatedTypeMirror>`	`fromTypeTreeCache` Mapping from a type 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` 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.
`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
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(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, Class<?> canonicalName, 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.
`@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 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 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 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 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 is in the hierarchy that contains the qualifier `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 (or is an alias for it).
`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 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`.
`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.
`Elements`	`getElementUtils()` Accessor for the element utilities.
`Element`	`getEnclosingElementForArtificialTree(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.
`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.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType>`	`getFnInterfaceFromTree(LambdaExpressionTree tree)` Returns the functional interface and the function type that this lambda targets.
`Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType>`	`getFnInterfaceFromTree(MemberReferenceTree tree)` Returns the functional interface and the function type that this member reference targets.
`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 given 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()`
`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.
`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.
`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)`
`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.
`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 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 node, 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.
`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.
  - 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 implicits are applied, just what the programmer wrote.
  - fromMemberTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromMemberTreeCache
```
    Mapping from a member tree to its annotated type; before implicits are applied, just what the programmer wrote.
  - fromTypeTreeCache
```
protected final Map<Tree,AnnotatedTypeMirror> fromTypeTreeCache
```
    Mapping from a type 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.
  - 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 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.
  - createQualifierUpperBounds
```
protected QualifierUpperBounds createQualifierUpperBounds()
```
    Creates QualifierUpperBounds for this type factory.
  - getWholeProgramInference
```
public WholeProgramInference getWholeProgramInference()
```
    Returns the WholeProgramInference instance.
  - 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
  - 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()
```
  - 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 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.
    To not support PolyAll, see examples below.
    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, 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)
```
    Return the annotation on tree that is in the hierarchy that contains the qualifier target. Returns null if none exists, or if target is not a supported qualifier.
    
    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 -
  - 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
  - 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 implicit annotations, defaulting, and inference (flow-sensitive type refinement). Its subclasses usually override it only to customize implicit annotations.
    Subclasses that override this method should also override addComputedTypeAnnotations(Element, AnnotatedTypeMirror).
    
    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 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.
    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 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 given 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 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(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 (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)
  - 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(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. 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.
    (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 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
  - 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(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 fully-qualified 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(String aliasName,
                                    Class<?> canonicalName,
                                    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 fully-qualified name of the aliased class
    
    canonicalName - the canonical annotation name
    
    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(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 node,
                                                       Element enclosing)
```
    Handle an artificial tree by mapping it to the enclosing element.
    See org.checkerframework.framework.flow.CFCFGBuilder.CFCFGTranslationPhaseOne.handleArtificialTree(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. Stub files listed in @Stubfiles annotation on the checker; must be in same directory as the checker
    3. Stub files provide via stubs system property
    4. Stub files provide via stubs environment variable
    5. 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 (or is an alias for it). Returns null if none exists.
    
    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.
  - 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)
```
    Returns the functional interface and 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 functional interface and the function type that this method reference targets
  - getFnInterfaceFromTree
```
public Pair<AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedExecutableType> getFnInterfaceFromTree(LambdaExpressionTree tree)
```
    Returns the functional interface and 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 functional interface and the function type that this 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

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

checker

uid

reflectionResolver

loader

shouldCache

fromExpressionTreeCache

fromMemberTreeCache

fromTypeTreeCache

ignoreUninferredTypeArguments

objectGetClass

Constructor Detail

AnnotatedTypeFactory

Method Detail

checkInvalidOptionsInferSignatures

postInit

createQualifierUpperBounds

getWholeProgramInference

initializeReflectionResolution

setRoot

toString

createQualifierHierarchyFactory

createQualifierHierarchy

createQualifierHierarchy

createQualifierHierarchy

getQualifierHierarchy

createTypeHierarchy

getTypeHierarchy

createTypeVariableSubstitutor

getTypeVarSubstitutor

createTypeArgumentInference

getTypeArgumentInference

createAnnotationClassLoader

createSupportedTypeQualifiers

getBundledTypeQualifiersWithPolyAll

getBundledTypeQualifiersWithoutPolyAll

createAnnotatedTypeFormatter

getAnnotatedTypeFormatter

createAnnotationFormatter

getAnnotationFormatter

getSupportedTypeQualifiers

getCacheSize

getAnnotatedType

getAnnotationMirror

getAnnotatedType

preProcessClassTree

postProcessClassTree

getAnnotatedTypeFromTypeTree

getTypeDeclarationBounds

getDefaultTypeDeclarationBounds

getTypeOfExtendsImplements

fromElement

addComputedTypeAnnotations

addComputedTypeAnnotations

addDefaultAnnotations

postDirectSuperTypes

postAsMemberOf

addAnnotationFromFieldInvariant

getFieldInvariants

getFieldInvariantAnnotationTree

getFieldInvariantDeclarationAnnotations

postTypeVarSubstitution