GenericAnnotatedTypeFactory

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, implicit annotations via ImplicitFor, 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.InheritedFromClassAnnotator

Field Summary

Fields
Modifier and Type	Field and Description
`protected Deque<FlowAnalysis>`	`analyses`
`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 static boolean`	`FLOW_BY_DEFAULT` 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, 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`
`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, fromTreeCache, ignoreUninferredTypeArguments, loader, processingEnv, qualHierarchy, 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`	`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)` Adds implicit annotations to a type obtained from a `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`	`addTypeNameImplicit(Class<?> clazz, AnnotationMirror implicitAnno)`
`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<ClassTree> queue, Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue, UnderlyingAST ast, List<Pair<VariableElement,Value>> fieldValues, ClassTree currentClass, boolean isInitializationCode, boolean updateInitializationStore, boolean isStatic)` Analyze the AST `ast` and store the result.
`protected void`	`analyze(Queue<ClassTree> queue, Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue, UnderlyingAST ast, List<Pair<VariableElement,Value>> fieldValues, ClassTree currentClass, boolean isInitializationCode, boolean updateInitializationStore, boolean isStatic, Store lambdaStore)`
`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: tree is a `ClassTree` Flow analysis has not already been performed on tree
`protected void`	`checkForDefaultQualifierInHierarchy(QualifierDefaults defs)` Check that a default qualifier (in at least one hierarchy) has been set and issue an error if not.
`Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>>`	`constructorFromUse(NewClassTree tree)` Determines the type of the invoked constructor based on the passed new class tree.
`protected CFGVisualizer<Value,Store,TransferFunction>`	`createCFGVisualizer()`
`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 `QualifierPolymorphism` which supports 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 `ImplicitsTypeAnnotator` 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.
`CFGVisualizer<Value,Store,TransferFunction>`	`getCFGVisualizer()` The CFGVisualizer to be used by all CFAbstractAnalysis instances.
`DependentTypesHelper`	`getDependentTypesHelper()`
`Store`	`getEmptyStore()`
`HashMap<Element,Value>`	`getFinalLocalValues()`
`List<Tree>`	`getGeneratedTrees(Tree tree)`
`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`.
`Node`	`getNodeForTree(Tree tree)`
`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(Tree tree)`
`Store`	`getStoreBefore(Node node)`
`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 first analysis.
`Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>>`	`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)` Preforms flow-sensitive type refinement on `classTree` if this type factory is configured to do so.
`void`	`setRoot(@Nullable CompilationUnitTree root)`
`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, aliasedAnnotation, annotateInheritedFromClass, annotateInheritedFromClass, checkInvalidOptionsInferSignatures, createAnnotatedTypeFormatter, createAnnotationFormatter, createQualifierHierarchy, createQualifierHierarchy, createQualifierHierarchy, createQualifierHierarchyFactory, 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, getElementUtils, getEnclosingMethod, getEnclosingType, getFieldInvariantAnnotationTree, getFieldInvariantDeclarationAnnotations, getFieldInvariants, getFnInterfaceFromTree, getFnInterfaceFromTree, getImplicitReceiverType, getNarrowedPrimitive, getPath, getProcessingEnv, getQualifierHierarchy, getReceiverType, getSelfType, getStringType, getSupportedTypeQualifiers, getTreeUtils, getTypeArgumentInference, getTypeHierarchy, getTypeVarSubstitutor, getUnboxedType, getUninferredWildcardType, getVisitorState, getWholeProgramInference, initializeReflectionResolution, isAnyEnclosingThisDeref, isFromByteCode, isFromStubFile, isMostEnclosingThisDeref, isSupportedQualifier, isWithinConstructor, methodFromUse, parseStubFiles, postAsMemberOf, postProcessClassTree, postTypeVarSubstitution, setPathHack, toAnnotatedType, toString, type, widenToUpperBound

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

- Field Detail
  - FLOW_BY_DEFAULT
```
protected static boolean FLOW_BY_DEFAULT
```
    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
  - 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, 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, Map)
  - scannedClasses
```
protected final Map<ClassTree,GenericAnnotatedTypeFactory.ScanState> scannedClasses
```
  - 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.
  - analyses
```
protected final Deque<FlowAnalysis extends CFAbstractAnalysis<Value,Store,TransferFunction>> analyses
```
  - initializationStore
```
protected Store extends CFAbstractStore<Value,Store> initializationStore
```
  - initializationStaticStore
```
protected Store extends CFAbstractStore<Value,Store> initializationStaticStore
```
  - 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)
```
    Preforms 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 preform flow-sensitive type refinement
  - setRoot
```
public void setRoot(@Nullable CompilationUnitTree root)
```
    Overrides:
    
    setRoot in class AnnotatedTypeFactory
  - 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. ImplicitsTreeAnnotator: Adds annotations based on ImplicitFor 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 ImplicitsTypeAnnotator 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. ImplicitsTypeAnnotator: Adds annotations based on ImplicitFor meta-annotations
    Returns:
    
    a type annotator
  - addTypeNameImplicit
```
protected void addTypeNameImplicit(Class<?> clazz,
                                   AnnotationMirror implicitAnno)
```
  - 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. Adds explicit annotations and annotations inherited from class declarations AnnotatedTypeFactory.annotateInheritedFromClass(AnnotatedTypeMirror).
    If the NewClassTree has type arguments, then any explicit (or inherited from class) annotations on those type arguments are included. If the NewClassTree has a diamond operator, then the annotations on the type arguments are inferred using the assignment context.
    (Subclass beside GenericAnnotatedTypeFactory should not override this method.)
    
    Overrides:
    
    fromNewClass in class AnnotatedTypeFactory
    
    Parameters:
    
    newClassTree - NewClassTree
    
    Returns:
    
    AnnotatedDeclaredType
  - createQualifierDefaults
```
protected final QualifierDefaults createQualifierDefaults()
```
    Create QualifierDefaults which handles checker specified defaults. Subclasses should override addCheckedCodeDefaults(QualifierDefaults defs) or addUncheckedCodeDefaults(QualifierDefaults defs) to add more defaults or use different defaults.
    
    Returns:
    
    the QualifierDefaults object
  - 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 QualifierPolymorphism which supports QualifierPolymorphism mechanism
    
    Returns:
    
    the QualifierPolymorphism class
  - 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)
                                           throws FlowExpressionParseUtil.FlowExpressionParseException
```
    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
    
    Throws:
    
    FlowExpressionParseUtil.FlowExpressionParseException - thrown if the expression cannot be parsed
  - 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
  - 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(Node node)
```
    Returns:
    
    the store immediately before a given Node.
  - getStoreAfter
```
public Store getStoreAfter(Tree tree)
```
    Returns:
    
    the store immediately after a given Tree.
  - getNodeForTree
```
public Node getNodeForTree(Tree tree)
```
    Returns:
    
    the Node for a given Tree.
  - getGeneratedTrees
```
public List<Tree> getGeneratedTrees(Tree tree)
```
    Returns:
    
    the generated Trees for a given 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<ClassTree> queue,
                       Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue,
                       UnderlyingAST ast,
                       List<Pair<VariableElement,Value>> fieldValues,
                       ClassTree currentClass,
                       boolean isInitializationCode,
                       boolean updateInitializationStore,
                       boolean isStatic)
```
    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
  - analyze
```
protected void analyze(Queue<ClassTree> queue,
                       Queue<Pair<LambdaExpressionTree,Store>> lambdaQueue,
                       UnderlyingAST ast,
                       List<Pair<VariableElement,Value>> fieldValues,
                       ClassTree currentClass,
                       boolean isInitializationCode,
                       boolean updateInitializationStore,
                       boolean isStatic,
                       Store lambdaStore)
```
  - handleCFGViz
```
protected void handleCFGViz()
```
    Handle the visualization of the CFG, by calling visualizeCFG on the first analysis. This method gets invoked in analyze if on 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 Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>> 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 compute 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.
    Adds implicit annotations to a type obtained from a Tree. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.
    
    Overrides:
    
    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:
    - 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
    
    Adds implicit annotations to a type obtained from a Element. By default, this method does nothing. Subclasses should use this method to implement implicit annotations specific to their type systems.
    
    Overrides:
    
    addComputedTypeAnnotations in class AnnotatedTypeFactory
    
    Parameters:
    
    elt - an element
    
    type - the type obtained from elt
  - methodFromUse
```
public Pair<AnnotatedTypeMirror.AnnotatedExecutableType,List<AnnotatedTypeMirror>> methodFromUse(MethodInvocationTree tree)
```
    Description copied from class: AnnotatedTypeFactory
    
    Determines the type of the invoked method based on the passed method invocation tree.
    The returned method type has all type variables resolved, whether based on receiver type, passed type parameters if any, and method invocation parameter.
    Subclasses may override this method to customize inference of types or qualifiers based on method invocation parameters.
    As an implementation detail, this method depends on AnnotatedTypes.asMemberOf(Types, AnnotatedTypeFactory, AnnotatedTypeMirror, Element), and customization based on receiver type should be in accordance to its specification.
    The return type is a pair of the type of the invoked method and the (inferred) type arguments. Note that neither the explicitly passed nor the inferred type arguments are guaranteed to be subtypes of the corresponding upper bounds. See method BaseTypeVisitor.checkTypeArguments(Tree, List, List, List) for the checks of type argument well-formedness.
    Note that "this" and "super" constructor invocations are also handled by this method. Method 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 factory 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.

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

FLOW_BY_DEFAULT

typeAnnotator

treeAnnotator

poly

defaults

dependentTypesHelper

flowResultAnalysisCaches

scannedClasses

flowResult

regularExitStores

returnStatementStores

methodInvocationStores

analyses

initializationStore

initializationStaticStore

cfgVisualizer

Constructor Detail

GenericAnnotatedTypeFactory

GenericAnnotatedTypeFactory

Method Detail

postInit

preProcessClassTree

setRoot

getSupportedMonotonicTypeQualifiers

createTreeAnnotator

createTypeAnnotator

addTypeNameImplicit

createFlowAnalysis

createFlowTransferFunction

createDependentTypesHelper

getDependentTypesHelper

fromNewClass

createQualifierDefaults

getSortedQualifierNames

addCheckedCodeDefaults

addCheckedStandardDefaults

addUncheckedCodeDefaults

addUncheckedStandardDefaults

checkForDefaultQualifierInHierarchy

createQualifierPolymorphism

postDirectSuperTypes

getResultingTypeOfConstructorMemberReference

getAnnotationFromJavaExpressionString

getAnnotationFromReceiver

getReceiverFromJavaExpressionString

getRegularExitStore

getReturnStatementStores

getStoreBefore

getStoreBefore

getStoreAfter

getNodeForTree

getGeneratedTrees

getFinalLocalValues

performFlowAnalysis

analyze

analyze

handleCFGViz

getAnnotatedTypeLhsNoTypeVarDefault

getAnnotatedTypeLhs

getAnnotatedTypeVarargsArray

getAnnotatedTypeRhsUnaryAssign

constructorFromUse

getMethodReturnType

getMethodReturnType

addDefaultAnnotations

addComputedTypeAnnotations

addComputedTypeAnnotations

checkAndPerformFlowAnalysis

getInferredValueFor

applyInferredAnnotations