GenericAnnotatedTypeFactory (checker-framework 2.9.0 API)

java.lang.Object
- org.checkerframework.framework.type.AnnotatedTypeFactory
- - org.checkerframework.framework.type.GenericAnnotatedTypeFactory<Value,Store,TransferFunction,FlowAnalysis>

All Implemented Interfaces:

AnnotationProvider

Direct Known Subclasses:

BaseAnnotatedTypeFactory, InitializationAnnotatedTypeFactory, KeyForAnnotatedTypeFactory, LockAnnotatedTypeFactory
```
public abstract class GenericAnnotatedTypeFactory<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>,TransferFunction extends CFAbstractTransfer<Value,Store,TransferFunction>,FlowAnalysis extends CFAbstractAnalysis<Value,Store,TransferFunction>>
extends AnnotatedTypeFactory
```
A factory that extends AnnotatedTypeFactory to optionally use flow-sensitive qualifier inference, qualifier polymorphism, default annotations via DefaultFor, and user-specified defaults via DefaultQualifier.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`GenericAnnotatedTypeFactory.ScanState` Track the state of org.checkerframework.dataflow analysis scanning for each class tree in the compilation unit.

Nested classes/interfaces inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory
AnnotatedTypeFactory.ParameterizedExecutableType

Field Summary

Fields
Modifier and Type	Field and Description
`protected FlowAnalysis`	`analysis`
`protected CFGVisualizer<Value,Store,TransferFunction>`	`cfgVisualizer` The CFGVisualizer to be used by all CFAbstractAnalysis instances.
`protected QualifierDefaults`	`defaults` to handle defaults specified by the user
`protected DependentTypesHelper`	`dependentTypesHelper` to handle dependent type annotations
`protected Store`	`emptyStore` An empty store.
`protected static boolean`	`flowByDefault` Should use flow by default.
`protected AnalysisResult<Value,Store>`	`flowResult` The result of the flow analysis.
`protected Map<TransferInput<Value,Store>,IdentityHashMap<Node,TransferResult<Value,Store>>>`	`flowResultAnalysisCaches` Caches for `AnalysisResult.runAnalysisFor(Node, boolean, TransferInput, IdentityHashMap, Map)`.
`protected Store`	`initializationStaticStore`
`protected Store`	`initializationStore`
`protected IdentityHashMap<MethodInvocationTree,Store>`	`methodInvocationStores` A mapping from methods to their a list with all return statements and the corresponding store.
`protected QualifierPolymorphism`	`poly` to handle any polymorphic types
`protected IdentityHashMap<Tree,Store>`	`regularExitStores` A mapping from methods (or other code blocks) to their regular exit store (used to check postconditions).
`protected IdentityHashMap<MethodTree,List<Pair<ReturnNode,TransferResult<Value,Store>>>>`	`returnStatementStores` A mapping from methods to a list with all return statements and the corresponding store.
`protected Map<ClassTree,GenericAnnotatedTypeFactory.ScanState>`	`scannedClasses` Map from ClassTree to their dataflow analysis state.
`protected TransferFunction`	`transfer`
`protected TreeAnnotator`	`treeAnnotator` to annotate types based on the given un-annotated types
`protected TypeAnnotator`	`typeAnnotator` to annotate types based on the given tree

Fields inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory
checker, elements, fromExpressionTreeCache, fromMemberTreeCache, fromTypeTreeCache, ignoreUninferredTypeArguments, loader, objectGetClass, processingEnv, qualHierarchy, qualifierUpperBounds, reflectionResolver, root, shouldCache, trees, typeArgumentInference, typeFormatter, typeHierarchy, types, typeVarSubstitutor, uid, visitorState

Constructor Summary

Constructors
Constructor and Description
`GenericAnnotatedTypeFactory(BaseTypeChecker checker)` Creates a type factory for checking the given compilation unit with respect to the given annotation.
`GenericAnnotatedTypeFactory(BaseTypeChecker checker, boolean useFlow)` Creates a type factory for checking the given compilation unit with respect to the given annotation.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addAnnotationsFromDefaultQualifierForUse(@Nullable Element element, AnnotatedTypeMirror type)` Adds default qualifiers bases on the underlying type of `type` to `type`.
`protected void`	`addCheckedCodeDefaults(QualifierDefaults defs)` Adds default qualifiers for type-checked code by reading `DefaultFor` and `DefaultQualifierInHierarchy` meta-annotations.
`protected void`	`addCheckedStandardDefaults(QualifierDefaults defs)` Adds the standard CLIMB defaults that do not conflict with previously added defaults.
`void`	`addComputedTypeAnnotations(Element elt, AnnotatedTypeMirror type)` Changes annotations on a type obtained from an `Element`.
`protected void`	`addComputedTypeAnnotations(Tree tree, AnnotatedTypeMirror type)` This method is final; override `addComputedTypeAnnotations(Tree, AnnotatedTypeMirror, boolean)` instead.
`protected void`	`addComputedTypeAnnotations(Tree tree, AnnotatedTypeMirror type, boolean iUseFlow)` Like {#addComputedTypeAnnotations(Tree, AnnotatedTypeMirror)}.
`void`	`addDefaultAnnotations(AnnotatedTypeMirror type)` Adds default annotations to `type`.
`protected void`	`addUncheckedCodeDefaults(QualifierDefaults defs)` Adds default qualifiers for code that is not type-checked by reading `@DefaultInUncheckedCodeFor` and `@DefaultQualifierInHierarchyInUncheckedCode` meta-annotations.
`protected void`	`addUncheckedStandardDefaults(QualifierDefaults defs)` Adds standard unchecked defaults that do not conflict with previously added defaults.
`protected void`	`analyze(Queue<Pair<ClassTree,Store>> queue, Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue, UnderlyingAST ast, List<Pair<VariableElement,Value>> fieldValues, ClassTree currentClass, boolean isInitializationCode, boolean updateInitializationStore, boolean isStatic, Store capturedStore)` Analyze the AST `ast` and store the result.
`protected void`	`applyInferredAnnotations(AnnotatedTypeMirror type, Value as)` Applies the annotations inferred by the org.checkerframework.dataflow analysis to the type `type`.
`protected void`	`checkAndPerformFlowAnalysis(Tree tree)` Flow analysis will be performed if all of the following are true.
`protected void`	`checkForDefaultQualifierInHierarchy(QualifierDefaults defs)` Check that a default qualifier (in at least one hierarchy) has been set and issue an error if not.
`AnnotatedTypeFactory.ParameterizedExecutableType`	`constructorFromUse(NewClassTree tree)` Determines the type of the invoked constructor based on the passed new class tree.
`protected QualifierDefaults`	`createAndInitQualifierDefaults()` Create `QualifierDefaults` which handles checker specified defaults, and initialize the created `QualifierDefaults`.
`protected CFGVisualizer<Value,Store,TransferFunction>`	`createCFGVisualizer()`
`protected DefaultQualifierForUseTypeAnnotator`	`createDefaultForUseTypeAnnotator()` Creates an `DefaultQualifierForUseTypeAnnotator`.
`protected DependentTypesHelper`	`createDependentTypesHelper()` Creates an `DependentTypesHelper` and returns it.
`protected FlowAnalysis`	`createFlowAnalysis(List<Pair<VariableElement,Value>> fieldValues)` Returns the appropriate flow analysis class that is used for the org.checkerframework.dataflow analysis.
`TransferFunction`	`createFlowTransferFunction(CFAbstractAnalysis<Value,Store,TransferFunction> analysis)` Returns the appropriate transfer function that is used for the org.checkerframework.dataflow analysis.
`protected QualifierDefaults`	`createQualifierDefaults()` Create `QualifierDefaults` which handles checker specified defaults.
`protected QualifierPolymorphism`	`createQualifierPolymorphism()` Creates the `QualifierPolymorphism` instance which supports the QualifierPolymorphism mechanism.
`protected TreeAnnotator`	`createTreeAnnotator()` Returns a `TreeAnnotator` that adds annotations to a type based on the contents of a tree.
`protected TypeAnnotator`	`createTypeAnnotator()` Returns a `DefaultForTypeAnnotator` that adds annotations to a type based on the content of the type itself.
`AnnotatedTypeMirror.AnnotatedDeclaredType`	`fromNewClass(NewClassTree newClassTree)` Creates an AnnotatedDeclaredType for a NewClassTree.
`AnnotatedTypeMirror`	`getAnnotatedTypeLhs(Tree lhsTree)` Returns the type of a left-hand side of an assignment.
`AnnotatedTypeMirror`	`getAnnotatedTypeLhsNoTypeVarDefault(Tree lhsTree)` Returns the type of the left-hand side of an assignment without applying local variable defaults to type variables.
`AnnotatedTypeMirror`	`getAnnotatedTypeRhsUnaryAssign(UnaryTree tree)`
`AnnotatedTypeMirror`	`getAnnotatedTypeVarargsArray(Tree tree)` Returns the type of a varargs array of a method invocation or a constructor invocation.
`AnnotationMirror`	`getAnnotationFromJavaExpressionString(String expression, Tree tree, TreePath path, Class<? extends Annotation> clazz)` Returns the primary annotation on expression if it were evaluated at path.
`AnnotationMirror`	`getAnnotationFromReceiver(FlowExpressions.Receiver receiver, Tree tree, Class<? extends Annotation> clazz)` Returns the primary annotation on a receiver.
`AnnotationMirror`	`getAnnotationMirrorFromJavaExpressionString(String expression, Tree tree, TreePath currentPath)` Returns the annotation mirror from dataflow for `expression`.
`CFGVisualizer<Value,Store,TransferFunction>`	`getCFGVisualizer()` The CFGVisualizer to be used by all CFAbstractAnalysis instances.
`DependentTypesHelper`	`getDependentTypesHelper()`
`Store`	`getEmptyStore()`
`HashMap<Element,Value>`	`getFinalLocalValues()`
`<T extends Node> T`	`getFirstNodeOfKindForTree(Tree tree, Class<T> kind)` Return the first `Node` for a given `Tree` that has class `kind`.
`Value`	`getInferredValueFor(Tree tree)` Returns the inferred value (by the org.checkerframework.dataflow analysis) for a given 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`.
`Set<Node>`	`getNodesForTree(Tree tree)`
`QualifierPolymorphism`	`getQualifierPolymorphism()` Gives the current `QualifierPolymorphism` instance which supports the QualifierPolymorphism mechanism.
`Pair<FlowExpressions.Receiver,String>`	`getReceiverAndOffsetFromJavaExpressionString(String expression, TreePath currentPath)` Produces the receiver and offset associated with an expression.
`FlowExpressions.Receiver`	`getReceiverFromJavaExpressionString(String expression, TreePath currentPath)` Produces the receiver associated with expression on currentPath.
`Store`	`getRegularExitStore(Tree t)` Returns the regular exit store for a method or another code block (such as static initializers).
`AnnotatedTypeMirror`	`getResultingTypeOfConstructorMemberReference(MemberReferenceTree memberReferenceTree, AnnotatedTypeMirror.AnnotatedExecutableType constructorType)` Gets the type of the resulting constructor call of a MemberReferenceTree.
`List<Pair<ReturnNode,TransferResult<Value,Store>>>`	`getReturnStatementStores(MethodTree methodTree)`
`boolean`	`getShouldDefaultTypeVarLocals()` Should the local variable default annotation be applied to type variables?
`protected String`	`getSortedQualifierNames()` Creates and returns a string containing the number of qualifiers and the canonical class names of each qualifier that has been added to this checker's supported qualifier set.
`Store`	`getStoreAfter(Node node)`
`Store`	`getStoreAfter(Set<Node> nodes)`
`Store`	`getStoreAfter(Tree tree)`
`Store`	`getStoreBefore(Node node)`
`Store`	`getStoreBefore(Set<Node> nodes)`
`Store`	`getStoreBefore(Tree tree)`
`Set<Class<? extends Annotation>>`	`getSupportedMonotonicTypeQualifiers()` Returns an immutable set of the monotonic type qualifiers supported by this checker.
`<T extends GenericAnnotatedTypeFactory<?,?,?,?>,U extends BaseTypeChecker> T`	`getTypeFactoryOfSubchecker(Class<U> checkerClass)` Returns the AnnotatedTypeFactory of the subchecker and copies the current visitor state to the sub-factory so that the types are computed properly.
`protected void`	`handleCFGViz()` Handle the visualization of the CFG, by calling `visualizeCFG` on the analysis.
`AnnotatedTypeFactory.ParameterizedExecutableType`	`methodFromUse(MethodInvocationTree tree)` Determines the type of the invoked method based on the passed method invocation tree.
`protected void`	`performFlowAnalysis(ClassTree classTree)` Perform a org.checkerframework.dataflow analysis over a single class tree and its nested classes.
`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`	`preProcessClassTree(ClassTree classTree)` Performs flow-sensitive type refinement on `classTree` if this type factory is configured to do so.
`void`	`setRoot(@Nullable CompilationUnitTree root)` Set the CompilationUnitTree that should be used.
`List<AnnotatedTypeParameterBounds>`	`typeVariablesFromUse(AnnotatedTypeMirror.AnnotatedDeclaredType type, TypeElement element)` Adapt the upper bounds of the type variables of a class relative to the type instantiation.

Methods inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory
adaptGetClassReturnTypeToReceiver, addAliasedAnnotation, addAliasedAnnotation, addAliasedAnnotation, addAliasedAnnotation, addAliasedDeclAnnotation, addAnnotationFromFieldInvariant, addInheritedAnnotation, canonicalAnnotation, checkInvalidOptionsInferSignatures, createAnnotatedTypeFormatter, createAnnotationClassLoader, createAnnotationFormatter, createQualifierHierarchy, createQualifierHierarchy, createQualifierHierarchy, createQualifierHierarchyFactory, createQualifierUpperBounds, createSupportedTypeQualifiers, createTypeArgumentInference, createTypeHierarchy, createTypeVariableSubstitutor, declarationFromElement, fromElement, fromElement, fromElement, getAnnotatedNullType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedType, getAnnotatedTypeFormatter, getAnnotatedTypeFromTypeTree, getAnnotationFormatter, getAnnotationMirror, getAnnotationWithMetaAnnotation, getBoxedType, getBundledTypeQualifiersWithoutPolyAll, getBundledTypeQualifiersWithPolyAll, getCacheSize, getContext, getCurrentClassTree, getCurrentClassType, getCurrentMethodReceiver, getDeclAnnotation, getDeclAnnotationNoAliases, getDeclAnnotations, getDeclAnnotationWithMetaAnnotation, getDefaultTypeDeclarationBounds, getElementUtils, getEnclosingElementForArtificialTree, getEnclosingType, getExpressionAndOffset, getFieldInvariantAnnotationTree, getFieldInvariantDeclarationAnnotations, getFieldInvariants, getFnInterfaceFromTree, getFnInterfaceFromTree, getImplicitReceiverType, getNarrowedPrimitive, getPath, getProcessingEnv, getQualifierHierarchy, getReceiverType, getSelfType, getStringType, getSupportedTypeQualifiers, getTreeUtils, getTypeArgumentInference, getTypeDeclarationBounds, getTypeHierarchy, getTypeOfExtendsImplements, getTypeVarSubstitutor, getUnboxedType, getUninferredWildcardType, getVisitorState, getWholeProgramInference, initializeReflectionResolution, isAnyEnclosingThisDeref, isFromByteCode, isFromStubFile, isMostEnclosingThisDeref, isSupportedQualifier, isWithinConstructor, methodFromUse, negateConstant, parseStubFiles, postAsMemberOf, postProcessClassTree, postTypeVarSubstitution, setEnclosingElementForArtificialTree, toAnnotatedType, toString, type, widenToUpperBound

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - flowByDefault
```
protected static boolean flowByDefault
```
    Should use flow by default.
  - typeAnnotator
```
protected TypeAnnotator typeAnnotator
```
    to annotate types based on the given tree
  - treeAnnotator
```
protected TreeAnnotator treeAnnotator
```
    to annotate types based on the given un-annotated types
  - poly
```
protected QualifierPolymorphism poly
```
    to handle any polymorphic types
  - defaults
```
protected QualifierDefaults defaults
```
    to handle defaults specified by the user
  - dependentTypesHelper
```
protected DependentTypesHelper dependentTypesHelper
```
    to handle dependent type annotations
  - emptyStore
```
protected Store extends CFAbstractStore<Value,Store> emptyStore
```
    An empty store.
  - analysis
```
protected FlowAnalysis extends CFAbstractAnalysis<Value,Store,TransferFunction> analysis
```
  - transfer
```
protected TransferFunction extends CFAbstractTransfer<Value,Store,TransferFunction> transfer
```
  - initializationStore
```
protected Store extends CFAbstractStore<Value,Store> initializationStore
```
  - initializationStaticStore
```
protected Store extends CFAbstractStore<Value,Store> initializationStaticStore
```
  - flowResultAnalysisCaches
```
protected final Map<TransferInput<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>>,IdentityHashMap<Node,TransferResult<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>>>> flowResultAnalysisCaches
```
    Caches for AnalysisResult.runAnalysisFor(Node, boolean, TransferInput, IdentityHashMap, Map). This cache is enabled if AnnotatedTypeFactory.shouldCache is true. The cache size is derived from AnnotatedTypeFactory.getCacheSize().
    
    See Also:
    
    AnalysisResult.runAnalysisFor(Node, boolean, TransferInput, IdentityHashMap, Map)
  - scannedClasses
```
protected final Map<ClassTree,GenericAnnotatedTypeFactory.ScanState> scannedClasses
```
    Map from ClassTree to their dataflow analysis state.
  - flowResult
```
protected AnalysisResult<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>> flowResult
```
    The result of the flow analysis. Invariant:
```
  scannedClasses.get(c) == FINISHED for some class c ⇒ flowResult != null
 
```
    Note that flowResult contains analysis results for Trees from multiple classes which are produced by multiple calls to performFlowAnalysis.
  - regularExitStores
```
protected IdentityHashMap<Tree,Store extends CFAbstractStore<Value,Store>> regularExitStores
```
    A mapping from methods (or other code blocks) to their regular exit store (used to check postconditions).
  - returnStatementStores
```
protected IdentityHashMap<MethodTree,List<Pair<ReturnNode,TransferResult<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>>>>> returnStatementStores
```
    A mapping from methods to a list with all return statements and the corresponding store.
  - methodInvocationStores
```
protected IdentityHashMap<MethodInvocationTree,Store extends CFAbstractStore<Value,Store>> methodInvocationStores
```
    A mapping from methods to their a list with all return statements and the corresponding store.
  - cfgVisualizer
```
protected final CFGVisualizer<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>,TransferFunction extends CFAbstractTransfer<Value,Store,TransferFunction>> cfgVisualizer
```
    The CFGVisualizer to be used by all CFAbstractAnalysis instances.
- Constructor Detail
  - GenericAnnotatedTypeFactory
```
public GenericAnnotatedTypeFactory(BaseTypeChecker checker,
                                   boolean useFlow)
```
    Creates a type factory for checking the given compilation unit with respect to the given annotation.
    
    Parameters:
    
    checker - the checker to which this type factory belongs
    
    useFlow - whether flow analysis should be performed
  - GenericAnnotatedTypeFactory
```
public GenericAnnotatedTypeFactory(BaseTypeChecker checker)
```
    Creates a type factory for checking the given compilation unit with respect to the given annotation.
    
    Parameters:
    
    checker - the checker to which this type factory belongs
- Method Detail
  - postInit
```
protected void postInit()
```
    Description copied from class: AnnotatedTypeFactory
    
    Actions that logically belong in the constructor, but need to run after the subclass constructor has completed. In particular, parseStubFiles() may try to do type resolution with this AnnotatedTypeFactory.
    
    Overrides:
    
    postInit in class AnnotatedTypeFactory
  - preProcessClassTree
```
public void preProcessClassTree(ClassTree classTree)
```
    Performs flow-sensitive type refinement on classTree if this type factory is configured to do so.
    
    Overrides:
    
    preProcessClassTree in class AnnotatedTypeFactory
    
    Parameters:
    
    classTree - tree on which to perform flow-sensitive type refinement
  - setRoot
```
public void setRoot(@Nullable CompilationUnitTree root)
```
    Description copied from class: AnnotatedTypeFactory
    
    Set the CompilationUnitTree that should be used.
    
    Overrides:
    
    setRoot in class AnnotatedTypeFactory
    
    Parameters:
    
    root - the new compilation unit to use
  - getSupportedMonotonicTypeQualifiers
```
public final Set<Class<? extends Annotation>> getSupportedMonotonicTypeQualifiers()
```
    Returns an immutable set of the monotonic type qualifiers supported by this checker.
    
    Returns:
    
    the monotonic type qualifiers supported this processor, or an empty set if none
    
    See Also:
    
    MonotonicQualifier
  - createTreeAnnotator
```
protected TreeAnnotator createTreeAnnotator()
```
    Returns a TreeAnnotator that adds annotations to a type based on the contents of a tree.
    The default tree annotator is a ListTreeAnnotator of the following:
    1. PropagationTreeAnnotator: Propagates annotations from subtrees
    2. LiteralTreeAnnotator: Adds annotations based on QualifierForLiterals meta-annotations
    3. DependentTypesTreeAnnotator: Adapts dependent annotations based on context
    Subclasses may override this method to specify additional tree annotators, for example:
```
 new ListTreeAnnotator(super.createTreeAnnotator(), new KeyLookupTreeAnnotator(this));
 
```
    Returns:
    
    a tree annotator
  - createTypeAnnotator
```
protected TypeAnnotator createTypeAnnotator()
```
    Returns a DefaultForTypeAnnotator that adds annotations to a type based on the content of the type itself.
    Subclass may override this method. The default type annotator is a ListTypeAnnotator of the following:
    1. IrrelevantTypeAnnotator: Adds top to types not listed in the RelevantJavaTypes annotation on the checker.
    2. PropagationTypeAnnotator: Propagates annotation onto wildcards.
    3. DefaultForTypeAnnotator: Adds annotations based on DefaultFor meta-annotations.
    Returns:
    
    a type annotator
  - createDefaultForUseTypeAnnotator
```
protected DefaultQualifierForUseTypeAnnotator createDefaultForUseTypeAnnotator()
```
    Creates an DefaultQualifierForUseTypeAnnotator.
  - createFlowAnalysis
```
protected FlowAnalysis createFlowAnalysis(List<Pair<VariableElement,Value>> fieldValues)
```
    Returns the appropriate flow analysis class that is used for the org.checkerframework.dataflow analysis.
    This implementation uses the checker naming convention to create the appropriate analysis. If no transfer function is found, it returns an instance of CFAnalysis.
    Subclasses have to override this method to create the appropriate analysis if they do not follow the checker naming convention.
  - createFlowTransferFunction
```
public TransferFunction createFlowTransferFunction(CFAbstractAnalysis<Value,Store,TransferFunction> analysis)
```
    Returns the appropriate transfer function that is used for the org.checkerframework.dataflow analysis.
    This implementation uses the checker naming convention to create the appropriate transfer function. If no transfer function is found, it returns an instance of CFTransfer.
    Subclasses have to override this method to create the appropriate transfer function if they do not follow the checker naming convention.
  - createDependentTypesHelper
```
protected DependentTypesHelper createDependentTypesHelper()
```
    Creates an DependentTypesHelper and returns it.
    
    Returns:
    
    a new DependentTypesHelper
  - getDependentTypesHelper
```
public DependentTypesHelper getDependentTypesHelper()
```
  - fromNewClass
```
public AnnotatedTypeMirror.AnnotatedDeclaredType fromNewClass(NewClassTree newClassTree)
```
    Description copied from class: AnnotatedTypeFactory
    
    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.)
    
    Overrides:
    
    fromNewClass in class AnnotatedTypeFactory
    
    Parameters:
    
    newClassTree - NewClassTree
    
    Returns:
    
    AnnotatedDeclaredType
  - createAndInitQualifierDefaults
```
protected final QualifierDefaults createAndInitQualifierDefaults()
```
    Create QualifierDefaults which handles checker specified defaults, and initialize the created QualifierDefaults. Subclasses should override addCheckedCodeDefaults(QualifierDefaults defs) or addUncheckedCodeDefaults(QualifierDefaults defs) to add more defaults or use different defaults.
    
    Returns:
    
    the QualifierDefaults object
  - createQualifierDefaults
```
protected QualifierDefaults createQualifierDefaults()
```
    Create QualifierDefaults which handles checker specified defaults. Sub-classes override this method to provide a different QualifierDefault implementation.
  - getSortedQualifierNames
```
protected final String getSortedQualifierNames()
```
    Creates and returns a string containing the number of qualifiers and the canonical class names of each qualifier that has been added to this checker's supported qualifier set. The names are alphabetically sorted.
    
    Returns:
    
    a string containing the number of qualifiers and canonical names of each qualifier
  - addCheckedCodeDefaults
```
protected void addCheckedCodeDefaults(QualifierDefaults defs)
```
    Adds default qualifiers for type-checked code by reading DefaultFor and DefaultQualifierInHierarchy meta-annotations. Subclasses may override this method to add defaults that cannot be specified with a DefaultFor or DefaultQualifierInHierarchy meta-annotations.
    
    Parameters:
    
    defs - QualifierDefault object to which defaults are added
  - addCheckedStandardDefaults
```
protected void addCheckedStandardDefaults(QualifierDefaults defs)
```
    Adds the standard CLIMB defaults that do not conflict with previously added defaults.
    
    Parameters:
    
    defs - QualifierDefaults object to which defaults are added
  - addUncheckedCodeDefaults
```
protected void addUncheckedCodeDefaults(QualifierDefaults defs)
```
    Adds default qualifiers for code that is not type-checked by reading @DefaultInUncheckedCodeFor and @DefaultQualifierInHierarchyInUncheckedCode meta-annotations. Then it applies the standard unchecked code defaults, if a default was not specified for a particular location.
    Standard unchecked code default are:
    top: TypeUseLocation.RETURN,TypeUseLocation.FIELD,TypeUseLocation.UPPER_BOUND
    bottom: TypeUseLocation.PARAMETER, TypeUseLocation.LOWER_BOUND
    
    If @DefaultQualifierInHierarchyInUncheckedCode code is not found or a default for TypeUseLocation.Otherwise is not used, the defaults for checked code will be applied to locations without a default for unchecked code.
    Subclasses may override this method to add defaults that cannot be specified with a @DefaultInUncheckedCodeFor or @DefaultQualifierInHierarchyInUncheckedCode meta-annotations or to change the standard defaults.
    
    Parameters:
    
    defs - QualifierDefaults object to which defaults are added
  - addUncheckedStandardDefaults
```
protected void addUncheckedStandardDefaults(QualifierDefaults defs)
```
    Adds standard unchecked defaults that do not conflict with previously added defaults.
    
    Parameters:
    
    defs - QualifierDefaults object to which defaults are added
  - checkForDefaultQualifierInHierarchy
```
protected void checkForDefaultQualifierInHierarchy(QualifierDefaults defs)
```
    Check that a default qualifier (in at least one hierarchy) has been set and issue an error if not.
    
    Parameters:
    
    defs - QualifierDefaults object to which defaults are added
  - createQualifierPolymorphism
```
protected QualifierPolymorphism createQualifierPolymorphism()
```
    Creates the QualifierPolymorphism instance which supports the QualifierPolymorphism mechanism.
    
    Returns:
    
    the QualifierPolymorphism instance to use
  - getQualifierPolymorphism
```
public QualifierPolymorphism getQualifierPolymorphism()
```
    Gives the current QualifierPolymorphism instance which supports the QualifierPolymorphism mechanism.
    
    Returns:
    
    the QualifierPolymorphism instance to use
  - postDirectSuperTypes
```
protected void postDirectSuperTypes(AnnotatedTypeMirror type,
                                    List<? extends AnnotatedTypeMirror> supertypes)
```
    Description copied from class: AnnotatedTypeFactory
    
    A callback method for the AnnotatedTypeFactory subtypes to customize directSuperTypes(). Overriding methods should merely change the annotations on the supertypes, without adding or removing new types.
    The default provided implementation adds type annotations to supertypes. This allows the type and its supertypes to have the qualifiers.
    
    Overrides:
    
    postDirectSuperTypes in class AnnotatedTypeFactory
    
    Parameters:
    
    type - the type whose supertypes are desired
    
    supertypes - the supertypes as specified by the base AnnotatedTypeFactory
  - getResultingTypeOfConstructorMemberReference
```
public AnnotatedTypeMirror getResultingTypeOfConstructorMemberReference(MemberReferenceTree memberReferenceTree,
                                                                        AnnotatedTypeMirror.AnnotatedExecutableType constructorType)
```
    Gets the type of the resulting constructor call of a MemberReferenceTree.
    
    Parameters:
    
    memberReferenceTree - MemberReferenceTree where the member is a constructor
    
    constructorType - AnnotatedExecutableType of the declaration of the constructor
    
    Returns:
    
    AnnotatedTypeMirror of the resulting type of the constructor
  - getAnnotationFromJavaExpressionString
```
public AnnotationMirror getAnnotationFromJavaExpressionString(String expression,
                                                              Tree tree,
                                                              TreePath path,
                                                              Class<? extends Annotation> clazz)
                                                       throws FlowExpressionParseUtil.FlowExpressionParseException
```
    Returns the primary annotation on expression if it were evaluated at path.
    
    Parameters:
    
    expression - a Java expression
    
    tree - current tree
    
    path - location at which expression is evaluated
    
    clazz - class of the annotation
    
    Returns:
    
    the annotation on expression or null if one does not exist
    
    Throws:
    
    FlowExpressionParseUtil.FlowExpressionParseException - thrown if the expression cannot be parsed
  - getAnnotationFromReceiver
```
public AnnotationMirror getAnnotationFromReceiver(FlowExpressions.Receiver receiver,
                                                  Tree tree,
                                                  Class<? extends Annotation> clazz)
```
    Returns the primary annotation on a receiver.
    
    Parameters:
    
    receiver - the receiver for which the annotation is returned
    
    tree - current tree
    
    clazz - the Class of the annotation
    
    Returns:
    
    the annotation on expression or null if one does not exist
  - getReceiverFromJavaExpressionString
```
public FlowExpressions.Receiver getReceiverFromJavaExpressionString(String expression,
                                                                    TreePath currentPath)
                                                             throws FlowExpressionParseUtil.FlowExpressionParseException
```
    Produces the receiver associated with expression on currentPath.
    
    Parameters:
    
    expression - a Java expression
    
    currentPath - location at which expression is evaluated
    
    Throws:
    
    FlowExpressionParseUtil.FlowExpressionParseException - thrown if the expression cannot be parsed
  - getReceiverAndOffsetFromJavaExpressionString
```
public Pair<FlowExpressions.Receiver,String> getReceiverAndOffsetFromJavaExpressionString(String expression,
                                                                                          TreePath currentPath)
                                                                                   throws FlowExpressionParseUtil.FlowExpressionParseException
```
    Produces the receiver and offset associated with an expression. For instance, "n+1" has no associated Receiver, but this method produces a pair of a Receiver (for "n") and an offset ("1").
    
    Parameters:
    
    expression - a Java expression, possibly with a constant offset
    
    currentPath - location at which expression is evaluated
    
    Returns:
    
    receiver and offset for the given expression
    
    Throws:
    
    FlowExpressionParseUtil.FlowExpressionParseException - thrown if the expression cannot be parsed
  - getAnnotationMirrorFromJavaExpressionString
```
public AnnotationMirror getAnnotationMirrorFromJavaExpressionString(String expression,
                                                                    Tree tree,
                                                                    TreePath currentPath)
                                                             throws FlowExpressionParseUtil.FlowExpressionParseException
```
    Returns the annotation mirror from dataflow for expression.
    This will output a different annotation than getAnnotationFromJavaExpressionString(String, Tree, TreePath, Class), because if the specified annotation isn't found in the store, the type from the factory is used.
    
    Parameters:
    
    expression - a Java expression
    
    tree - the tree at the location to parse the expression
    
    currentPath - location at which expression is evaluated
    
    Returns:
    
    an AnnotationMirror representing the type in the store at the given location from this type factory's type system, or null if one is not available
    
    Throws:
    
    FlowExpressionParseUtil.FlowExpressionParseException - thrown if the expression cannot be parsed
  - getRegularExitStore
```
public Store getRegularExitStore(Tree t)
```
    Returns the regular exit store for a method or another code block (such as static initializers).
    
    Returns:
    
    the regular exit store, or null, if there is no such store (because the method cannot exit through the regular exit block).
  - getReturnStatementStores
```
public List<Pair<ReturnNode,TransferResult<Value,Store>>> getReturnStatementStores(MethodTree methodTree)
```
    Returns:
    
    all return node and store pairs for a given method
  - getStoreBefore
```
public Store getStoreBefore(Tree tree)
```
    Returns:
    
    the store immediately before a given Tree.
  - getStoreBefore
```
public Store getStoreBefore(Set<Node> nodes)
```
    Returns:
    
    the store immediately before a given Set of Nodes.
  - getStoreBefore
```
public Store getStoreBefore(Node node)
```
    Returns:
    
    the store immediately before a given Node.
  - getStoreAfter
```
public Store getStoreAfter(Tree tree)
```
    Returns:
    
    the store immediately after a given Tree.
  - getStoreAfter
```
public Store getStoreAfter(Set<Node> nodes)
```
    Returns:
    
    the store immediately after a given set of Nodes.
  - getStoreAfter
```
public Store getStoreAfter(Node node)
```
    Returns:
    
    the store immediately after a given Node.
  - getNodesForTree
```
public Set<Node> getNodesForTree(Tree tree)
```
    Returns:
    
    the Nodes for a given Tree
    
    See Also:
    
    AnalysisResult.getNodesForTree(Tree)
  - getFirstNodeOfKindForTree
```
public <T extends Node> T getFirstNodeOfKindForTree(Tree tree,
                                                    Class<T> kind)
```
    Return the first Node for a given Tree that has class kind.
    You probably don't want to use this function: iterate over the result of getNodesForTree(Tree) yourself or ask for a conservative approximation of the store using getStoreBefore(Tree) or getStoreAfter(Tree). This method is for code that uses a Node in a rather unusual way. Callers should probably be rewritten to not use a Node at all.
    
    Returns:
    
    the first Node for a given Tree that of class kind.
    
    See Also:
    
    getNodesForTree(Tree), getStoreBefore(Tree), getStoreAfter(Tree)
  - getFinalLocalValues
```
public HashMap<Element,Value> getFinalLocalValues()
```
    Returns:
    
    the value of effectively final local variables
  - performFlowAnalysis
```
protected void performFlowAnalysis(ClassTree classTree)
```
    Perform a org.checkerframework.dataflow analysis over a single class tree and its nested classes.
  - analyze
```
protected void analyze(Queue<Pair<ClassTree,Store>> queue,
                       Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue,
                       UnderlyingAST ast,
                       List<Pair<VariableElement,Value>> fieldValues,
                       ClassTree currentClass,
                       boolean isInitializationCode,
                       boolean updateInitializationStore,
                       boolean isStatic,
                       Store capturedStore)
```
    Analyze the AST ast and store the result.
    
    Parameters:
    
    queue - the queue to add more things to scan
    
    fieldValues - the abstract values for all fields of the same class
    
    ast - the AST to analyze
    
    currentClass - the class we are currently looking at
    
    isInitializationCode - are we analyzing a (non-static) initializer block of a class
    
    capturedStore - the input Store to use for captured variables, e.g. in a lambda
  - handleCFGViz
```
protected void handleCFGViz()
```
    Handle the visualization of the CFG, by calling visualizeCFG on the analysis. This method gets invoked in analyze if one of the visualization options is provided.
  - getAnnotatedTypeLhsNoTypeVarDefault
```
public AnnotatedTypeMirror getAnnotatedTypeLhsNoTypeVarDefault(Tree lhsTree)
```
    Returns the type of the left-hand side of an assignment without applying local variable defaults to type variables.
    The type variables that are types of local variables are defaulted to top so that they can be refined by dataflow. When these types are used as context during type argument inference, this default is too conservative. So this method is used instead of getAnnotatedTypeLhs(Tree).
    TypeArgInferenceUtil.assignedToVariable(AnnotatedTypeFactory, Tree) explains why a different type is used.
    
    Parameters:
    
    lhsTree - left-hand side of an assignment
    
    Returns:
    
    AnnotatedTypeMirror of lhsTree
  - getAnnotatedTypeLhs
```
public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree)
```
    Returns the type of a left-hand side of an assignment.
    The default implementation returns the type without considering dataflow type refinement. Subclass can override this method and add additional logic for computing the type of a LHS.
    
    Parameters:
    
    lhsTree - left-hand side of an assignment
    
    Returns:
    
    AnnotatedTypeMirror of lhsTree
  - getAnnotatedTypeVarargsArray
```
public AnnotatedTypeMirror getAnnotatedTypeVarargsArray(Tree tree)
```
    Returns the type of a varargs array of a method invocation or a constructor invocation.
    
    Parameters:
    
    tree - a method invocation or a constructor invocation
    
    Returns:
    
    AnnotatedTypeMirror of varargs array for a method or constructor invocation tree
  - getAnnotatedTypeRhsUnaryAssign
```
public AnnotatedTypeMirror getAnnotatedTypeRhsUnaryAssign(UnaryTree tree)
```
  - constructorFromUse
```
public AnnotatedTypeFactory.ParameterizedExecutableType constructorFromUse(NewClassTree tree)
```
    Description copied from class: AnnotatedTypeFactory
    
    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 AnnotatedTypeFactory.methodFromUse(com.sun.source.tree.MethodInvocationTree). This method only handles constructor invocations in a "new" expression.
    
    Overrides:
    
    constructorFromUse in class AnnotatedTypeFactory
    
    Parameters:
    
    tree - the constructor invocation tree
    
    Returns:
    
    the annotated type of the invoked constructor (as an executable type) and the (inferred) type arguments
  - getMethodReturnType
```
public AnnotatedTypeMirror getMethodReturnType(MethodTree m)
```
    Description copied from class: AnnotatedTypeFactory
    
    Returns the return type of the method m.
    
    Overrides:
    
    getMethodReturnType in class AnnotatedTypeFactory
  - getMethodReturnType
```
public AnnotatedTypeMirror getMethodReturnType(MethodTree m,
                                               ReturnTree r)
```
    Description copied from class: AnnotatedTypeFactory
    
    Returns the return type of the method m at the return statement r.
    
    Overrides:
    
    getMethodReturnType in class AnnotatedTypeFactory
  - addDefaultAnnotations
```
public void addDefaultAnnotations(AnnotatedTypeMirror type)
```
    Description copied from class: AnnotatedTypeFactory
    
    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().)
    
    Overrides:
    
    addDefaultAnnotations in class AnnotatedTypeFactory
    
    Parameters:
    
    type - annotated type to which default annotations are added
  - addComputedTypeAnnotations
```
protected final void addComputedTypeAnnotations(Tree tree,
                                                AnnotatedTypeMirror type)
```
    This method is final; override addComputedTypeAnnotations(Tree, AnnotatedTypeMirror, boolean) instead.
    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 AnnotatedTypeFactory.addComputedTypeAnnotations(Element, AnnotatedTypeMirror).
    
    Overrides:
    
    addComputedTypeAnnotations in class AnnotatedTypeFactory
    
    Parameters:
    
    tree - an AST node
    
    type - the type obtained from tree
  - addComputedTypeAnnotations
```
protected void addComputedTypeAnnotations(Tree tree,
                                          AnnotatedTypeMirror type,
                                          boolean iUseFlow)
```
    Like {#addComputedTypeAnnotations(Tree, AnnotatedTypeMirror)}. Overriding implementations typically simply pass the boolean to calls to super.
  - checkAndPerformFlowAnalysis
```
protected void checkAndPerformFlowAnalysis(Tree tree)
```
    Flow analysis will be performed if all of the following are true.
    - tree is a ClassTree
    - Flow analysis has not already been performed on tree
    Parameters:
    
    tree - the tree to check and possibly perform flow analysis on
  - getInferredValueFor
```
public Value getInferredValueFor(Tree tree)
```
    Returns the inferred value (by the org.checkerframework.dataflow analysis) for a given tree.
  - applyInferredAnnotations
```
protected void applyInferredAnnotations(AnnotatedTypeMirror type,
                                        Value as)
```
    Applies the annotations inferred by the org.checkerframework.dataflow analysis to the type type.
  - addComputedTypeAnnotations
```
public void addComputedTypeAnnotations(Element elt,
                                       AnnotatedTypeMirror type)
```
    Description copied from class: AnnotatedTypeFactory
    
    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 AnnotatedTypeFactory.addComputedTypeAnnotations(Tree, AnnotatedTypeMirror).
    
    Overrides:
    
    addComputedTypeAnnotations in class AnnotatedTypeFactory
    
    Parameters:
    
    elt - an element
    
    type - the type obtained from elt
  - methodFromUse
```
public AnnotatedTypeFactory.ParameterizedExecutableType methodFromUse(MethodInvocationTree tree)
```
    Description copied from class: AnnotatedTypeFactory
    
    Determines the type of the invoked method based on the passed method invocation tree.
    The returned method type has all type variables resolved, whether based on receiver type, passed type parameters if any, and method invocation parameter.
    Subclasses may override this method to customize inference of types or qualifiers based on method invocation parameters.
    As an implementation detail, this method depends on AnnotatedTypes.asMemberOf(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 AnnotatedTypeFactory.constructorFromUse(NewClassTree) is only used for a constructor invocation in a "new" expression.
    
    Overrides:
    
    methodFromUse in class AnnotatedTypeFactory
    
    Parameters:
    
    tree - the method invocation tree
    
    Returns:
    
    the method type being invoked with tree and the (inferred) type arguments
  - typeVariablesFromUse
```
public List<AnnotatedTypeParameterBounds> typeVariablesFromUse(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                                                               TypeElement element)
```
    Description copied from class: AnnotatedTypeFactory
    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.
    Overrides:
    
    typeVariablesFromUse in class AnnotatedTypeFactory
    
    Parameters:
    
    type - the use of the type
    
    element - the corresponding element
    
    Returns:
    
    the adapted bounds of the type parameters
  - getEmptyStore
```
public Store getEmptyStore()
```
  - getTypeFactoryOfSubchecker
```
public <T extends GenericAnnotatedTypeFactory<?,?,?,?>,U extends BaseTypeChecker> T getTypeFactoryOfSubchecker(Class<U> checkerClass)
```
    Returns the AnnotatedTypeFactory of the subchecker and copies the current visitor state to the sub-factory so that the types are computed properly. Because the visitor state is copied, call this method each time a subfactory is needed rather than store the returned subfactory in a field.
    
    See Also:
    
    BaseTypeChecker.getTypeFactoryOfSubchecker(Class)
  - getShouldDefaultTypeVarLocals
```
public boolean getShouldDefaultTypeVarLocals()
```
    Should the local variable default annotation be applied to type variables?
    It is initialized to true if data flow is used by the checker. It is set to false when getting the assignment context for type argument inference.
    
    Returns:
    
    shouldDefaultTypeVarLocals
    
    See Also:
    
    getAnnotatedTypeLhsNoTypeVarDefault(com.sun.source.tree.Tree)
  - createCFGVisualizer
```
protected CFGVisualizer<Value,Store,TransferFunction> createCFGVisualizer()
```
  - getCFGVisualizer
```
public CFGVisualizer<Value,Store,TransferFunction> getCFGVisualizer()
```
    The CFGVisualizer to be used by all CFAbstractAnalysis instances.
  - addAnnotationsFromDefaultQualifierForUse
```
protected void addAnnotationsFromDefaultQualifierForUse(@Nullable Element element,
                                                        AnnotatedTypeMirror type)
```
    Adds default qualifiers bases on the underlying type of type to type. If element is a local variable, then the defaults are not added.
    
    Parameters:
    
    element - possibly null element whose type is type
    
    type - the type to which defaults are added

Class GenericAnnotatedTypeFactory<Value extends CFAbstractValue<Value>,Store extends CFAbstractStore<Value,Store>,TransferFunction extends CFAbstractTransfer<Value,Store,TransferFunction>,FlowAnalysis extends CFAbstractAnalysis<Value,Store,TransferFunction>>

Nested Class Summary

Nested classes/interfaces inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory

Field Summary

Fields inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory

Constructor Summary

Method Summary

Methods inherited from class org.checkerframework.framework.type.AnnotatedTypeFactory

Methods inherited from class java.lang.Object

Field Detail

flowByDefault

typeAnnotator

treeAnnotator

poly

defaults

dependentTypesHelper

emptyStore

analysis

transfer

initializationStore

initializationStaticStore

flowResultAnalysisCaches

scannedClasses

flowResult

regularExitStores

returnStatementStores

methodInvocationStores

cfgVisualizer

Constructor Detail

GenericAnnotatedTypeFactory

GenericAnnotatedTypeFactory

Method Detail

postInit

preProcessClassTree

setRoot

getSupportedMonotonicTypeQualifiers

createTreeAnnotator

createTypeAnnotator

createDefaultForUseTypeAnnotator

createFlowAnalysis

createFlowTransferFunction

createDependentTypesHelper

getDependentTypesHelper

fromNewClass

createAndInitQualifierDefaults

createQualifierDefaults

getSortedQualifierNames

addCheckedCodeDefaults

addCheckedStandardDefaults

addUncheckedCodeDefaults

addUncheckedStandardDefaults

checkForDefaultQualifierInHierarchy

createQualifierPolymorphism

getQualifierPolymorphism

postDirectSuperTypes

getResultingTypeOfConstructorMemberReference

getAnnotationFromJavaExpressionString

getAnnotationFromReceiver

getReceiverFromJavaExpressionString

getReceiverAndOffsetFromJavaExpressionString

getAnnotationMirrorFromJavaExpressionString

getRegularExitStore

getReturnStatementStores

getStoreBefore

getStoreBefore

getStoreBefore

getStoreAfter

getStoreAfter

getStoreAfter

getNodesForTree

getFirstNodeOfKindForTree

getFinalLocalValues

performFlowAnalysis

analyze

handleCFGViz

getAnnotatedTypeLhsNoTypeVarDefault

getAnnotatedTypeLhs

getAnnotatedTypeVarargsArray

getAnnotatedTypeRhsUnaryAssign

constructorFromUse