CFAbstractValue

java.lang.Object
- org.checkerframework.framework.flow.CFAbstractValue<V>

All Implemented Interfaces:

AbstractValue<V>

Direct Known Subclasses:

CFValue, KeyForValue, NullnessValue
```
public abstract class CFAbstractValue<V extends CFAbstractValue<V>>
extends java.lang.Object
implements AbstractValue<V>
```
An implementation of an abstract value used by the Checker Framework org.checkerframework.dataflow analysis.
A value holds a set of annotations and a type mirror. The set of annotations represents the primary annotation on a type; therefore, the set of annotations must have an annotation for each hierarchy unless the type mirror is a type variable or a wildcard that extends a type variable. Both type variables and wildcards may be missing a primary annotation. For this set of annotations, there is an additional constraint that only wildcards that extend type variables can be missing annotations.
In order to compute leastUpperBound(CFAbstractValue) and mostSpecific(CFAbstractValue, CFAbstractValue), the case where one value has an annotation in a hierarchy and the other does not must be handled. For type variables, the AnnotatedTypeMirror.AnnotatedTypeVariable for the declaration of the type variable is used. The AnnotatedTypeMirror.AnnotatedTypeVariable is computed using the type mirror. For wildcards, it is not always possible to get the AnnotatedTypeMirror.AnnotatedWildcardType for the type mirror. However, a CFAbstractValue's type mirror is only a wildcard if the type of some expression is a wildcard. The type of an expression is only a wildcard because the Checker Framework does not implement capture conversion. For these uses of uncaptured wildcards, only the primary annotation on the upper bound is ever used. So, the set of annotations represents the primary annotation on the wildcard's upper bound. If that upper bound is a type variable, then the set of annotations could be missing an annotation in a hierarchy.

Author:

Stefan Heule

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`CFAbstractValue.AnnotationSetAndTypeMirrorVisitor` Iterates through two sets of AnnotationMirrors by hierarchy and calls one of three methods depending on whether an annotation exists for the hierarchy in each set.

Field Summary

Fields
Modifier and Type	Field and Description
`protected CFAbstractAnalysis<V,?,?>`	`analysis` The analysis class this value belongs to.
`protected java.util.Set<javax.lang.model.element.AnnotationMirror>`	`annotations`
`protected javax.lang.model.type.TypeMirror`	`underlyingType`

Constructor Summary

Constructors
Constructor and Description
`CFAbstractValue(CFAbstractAnalysis<V,?,?> analysis, java.util.Set<javax.lang.model.element.AnnotationMirror> annotations, javax.lang.model.type.TypeMirror underlyingType)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`canBeMissingAnnotations()` Returns whether or not the set of annotations can be missing an annotation for any hierarchy
`boolean`	`equals(java.lang.Object obj)`
`java.util.Set<javax.lang.model.element.AnnotationMirror>`	`getAnnotations()` Returns a set of annotations.
`javax.lang.model.type.TypeMirror`	`getUnderlyingType()`
`int`	`hashCode()`
`V`	`leastUpperBound(V other)` Compute the least upper bound of two stores.
`V`	`mostSpecific(V other, V backup)` Returns the more specific version of two values `this` and `other`.
`java.lang.String`	`toString()`
`static boolean`	`validateSet(java.util.Set<javax.lang.model.element.AnnotationMirror> annos, javax.lang.model.type.TypeMirror typeMirror, QualifierHierarchy hierarchy)`
`V`	`widenUpperBound(V other)`

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

- Field Detail
  - analysis
```
protected final CFAbstractAnalysis<V extends CFAbstractValue<V>,?,?> analysis
```
    The analysis class this value belongs to.
  - underlyingType
```
protected final javax.lang.model.type.TypeMirror underlyingType
```
  - annotations
```
protected final java.util.Set<javax.lang.model.element.AnnotationMirror> annotations
```
- Constructor Detail
  - CFAbstractValue
```
public CFAbstractValue(CFAbstractAnalysis<V,?,?> analysis,
                       java.util.Set<javax.lang.model.element.AnnotationMirror> annotations,
                       javax.lang.model.type.TypeMirror underlyingType)
```
- Method Detail
  - validateSet
```
public static boolean validateSet(java.util.Set<javax.lang.model.element.AnnotationMirror> annos,
                                  javax.lang.model.type.TypeMirror typeMirror,
                                  QualifierHierarchy hierarchy)
```
  - canBeMissingAnnotations
```
public boolean canBeMissingAnnotations()
```
    Returns whether or not the set of annotations can be missing an annotation for any hierarchy
    
    Returns:
    
    whether or not the set of annotations can be missing an annotation
  - getAnnotations
```
@Pure
public java.util.Set<javax.lang.model.element.AnnotationMirror> getAnnotations()
```
    Returns a set of annotations. If canBeMissingAnnotations() returns true, then the set of annotations may not have an annotation for every hierarchy.
    
    Returns:
    
    returns a set of annotations
  - getUnderlyingType
```
@Pure
public javax.lang.model.type.TypeMirror getUnderlyingType()
```
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
@Pure
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
@SideEffectFree
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    the string representation as a comma-separated list
  - mostSpecific
```
public V mostSpecific(V other,
                      V backup)
```
    Returns the more specific version of two values this and other. If they do not contain information for all hierarchies, then it is possible that information from both this and other are taken.
    If neither of the two is more specific for one of the hierarchies (i.e., if the two are incomparable as determined by QualifierHierarchy.isSubtype(AnnotationMirror, AnnotationMirror), then the respective value from backup is used.
  - leastUpperBound
```
public V leastUpperBound(V other)
```
    Description copied from interface: AbstractValue
    Compute the least upper bound of two stores.
    Important: This method must fulfill the following contract:
    - Does not change this.
    - Does not change other.
    - Returns a fresh object which is not aliased yet.
    - Returns an object of the same (dynamic) type as this, even if the signature is more permissive.
    - Is commutative.
    Specified by:
    
    leastUpperBound in interface AbstractValue<V extends CFAbstractValue<V>>
  - widenUpperBound
```
public V widenUpperBound(V other)
```

Class CFAbstractValue<V extends CFAbstractValue<V>>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

analysis

underlyingType

annotations

Constructor Detail

CFAbstractValue

Method Detail

validateSet

canBeMissingAnnotations

getAnnotations

getUnderlyingType

equals

hashCode

toString

mostSpecific

leastUpperBound

widenUpperBound