QualifierHierarchy (checker-framework 2.9.0 API)

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

Direct Known Subclasses:

MultiGraphQualifierHierarchy
```
public abstract class QualifierHierarchy
extends Object
```
Represents a type qualifier hierarchy.
All method parameter annotations need to be type qualifiers recognized within this hierarchy.
This assumes that any particular annotated type in a program is annotated with at least one qualifier from the hierarchy.

Constructor Summary

Constructors
Constructor and Description

QualifierHierarchy()

Constructors
Constructor and Description
`QualifierHierarchy()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`canHaveEmptyAnnotationSet(AnnotatedTypeMirror type)` Returns true if and only if the given type can have empty annotation sets (and thus the *TypeVariable methods need to be used).
`AnnotationMirror`	`findAnnotationInHierarchy(Collection<? extends AnnotationMirror> annos, AnnotationMirror top)` Returns the annotation in annos that is in the hierarchy for which annotationMirror is top.
`AnnotationMirror`	`findAnnotationInSameHierarchy(Collection<? extends AnnotationMirror> annos, AnnotationMirror annotationMirror)` Returns the annotation in annos that is in the same hierarchy as annotationMirror.
`abstract AnnotationMirror`	`getBottomAnnotation(AnnotationMirror start)` Return the bottom for the given qualifier, that is, the qualifier that is a subtype of start but no further subtypes exist.
`abstract Set<? extends AnnotationMirror>`	`getBottomAnnotations()`
`abstract AnnotationMirror`	`getPolymorphicAnnotation(AnnotationMirror start)`
`abstract AnnotationMirror`	`getTopAnnotation(AnnotationMirror start)` Return the top qualifier for the given qualifier, that is, the qualifier that is a supertype of start but no further supertypes exist.
`abstract Set<? extends AnnotationMirror>`	`getTopAnnotations()`
`abstract Set<? extends AnnotationMirror>`	`getTypeQualifiers()` Returns all type qualifiers in this type qualifier hierarchy.
`int`	`getWidth()` Returns the width of this hierarchy, i.e.
`AnnotationMirror`	`greatestLowerBound(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, AnnotationMirror a1, AnnotationMirror a2)` Returns the greatest lower bound for the qualifiers a1 and a2.
`abstract AnnotationMirror`	`greatestLowerBound(AnnotationMirror a1, AnnotationMirror a2)` Returns the greatest lower bound for the qualifiers a1 and a2.
`Set<? extends AnnotationMirror>`	`greatestLowerBounds(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, Collection<? extends AnnotationMirror> annos1, Collection<AnnotationMirror> annos2)` Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2.
`Set<? extends AnnotationMirror>`	`greatestLowerBounds(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2)` Returns the greatest lower bound of two types.
`Set<? extends AnnotationMirror>`	`greatestLowerBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2)` Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2.
`abstract AnnotationMirror`	`greatestLowerBoundTypeVariable(AnnotationMirror a1, AnnotationMirror a2)` Returns the greatest lower bound for the qualifiers a1 and a2.
`boolean`	`isSubtype(AnnotatedTypeMirror subType, AnnotatedTypeMirror superType, AnnotationMirror subAnno, AnnotationMirror superAnno)` Tests whether `subAnno` is a sub-qualifier of `superAnno`, according to the type qualifier hierarchy.
`boolean`	`isSubtype(AnnotatedTypeMirror subType, AnnotatedTypeMirror superType, Collection<? extends AnnotationMirror> subs, Collection<AnnotationMirror> supers)` Tests whether there is any annotation in `supers` that is a super qualifier of some annotation in `subs`.
`abstract boolean`	`isSubtype(AnnotationMirror rhs, AnnotationMirror lhs)` Tests whether rhs is equal to or a sub-qualifier of lhs, according to the type qualifier hierarchy.
`abstract boolean`	`isSubtype(Collection<? extends AnnotationMirror> rhs, Collection<? extends AnnotationMirror> lhs)` Tests whether there is any annotation in lhs that is a super qualifier of some annotation in rhs.
`abstract boolean`	`isSubtypeTypeVariable(AnnotationMirror subAnno, AnnotationMirror superAnno)` Tests whether `subAnno` is a sub-qualifier of `superAnno`, according to the type qualifier hierarchy.
`abstract boolean`	`isSubtypeTypeVariable(Collection<? extends AnnotationMirror> subAnnos, Collection<? extends AnnotationMirror> superAnnos)` Tests whether there is any annotation in superAnnos that is a super qualifier of some annotation in subAnnos.
`boolean`	`isValid()` Determine whether the instance is valid.
`AnnotationMirror`	`leastUpperBound(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, AnnotationMirror a1, AnnotationMirror a2)` Returns the least upper bound for the qualifiers a1 and a2.
`abstract AnnotationMirror`	`leastUpperBound(AnnotationMirror a1, AnnotationMirror a2)` Returns the least upper bound for the qualifiers a1 and a2.
`Set<? extends AnnotationMirror>`	`leastUpperBounds(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, Collection<? extends AnnotationMirror> annos1, Collection<AnnotationMirror> annos2)` Returns the type qualifiers that are the least upper bound of the qualifiers in annos1 and annos2.
`Set<? extends AnnotationMirror>`	`leastUpperBounds(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2)` Returns the least upper bound of two types.
`Set<? extends AnnotationMirror>`	`leastUpperBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2)` Returns the type qualifiers that are the least upper bound of the qualifiers in annos1 and annos2.
`abstract AnnotationMirror`	`leastUpperBoundTypeVariable(AnnotationMirror a1, AnnotationMirror a2)` Returns the least upper bound for the qualifiers a1 and a2.
`int`	`numberOfIterationsBeforeWidening()` Returns the number of iterations dataflow should perform before `widenedUpperBound(AnnotationMirror, AnnotationMirror)` is called or -1 if it should never be called.
`protected Collection<? extends AnnotationMirror>`	`replacePolyAll(Collection<? extends AnnotationMirror> annos)` Returns a new set that is the passed set, but PolyAll has been replaced by a polymorphic qualifiers, for hierarchies that do not have an annotation in the set.
`<T> boolean`	`updateMappingToMutableSet(Map<T,Set<AnnotationMirror>> map, T key, AnnotationMirror newQual)` Update a mapping from some key to a set of AnnotationMirrors.
`AnnotationMirror`	`widenedUpperBound(AnnotationMirror newQualifier, AnnotationMirror previousQualifier)` If the type hierarchy has an infinite ascending chain, then the dataflow analysis might never reach a fixed point.

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

- Constructor Detail
  - QualifierHierarchy
```
public QualifierHierarchy()
```
- Method Detail
  - isValid
```
public boolean isValid()
```
    Determine whether the instance is valid.
    
    Returns:
    
    whether the instance is valid
  - getWidth
```
public int getWidth()
```
    Returns the width of this hierarchy, i.e. the expected number of annotations on any valid type.
  - getTopAnnotations
```
public abstract Set<? extends AnnotationMirror> getTopAnnotations()
```
    Returns:
    
    the top (ultimate super) type qualifiers in the type system
  - getTopAnnotation
```
public abstract AnnotationMirror getTopAnnotation(AnnotationMirror start)
```
    Return the top qualifier for the given qualifier, that is, the qualifier that is a supertype of start but no further supertypes exist.
  - getBottomAnnotation
```
public abstract AnnotationMirror getBottomAnnotation(AnnotationMirror start)
```
    Return the bottom for the given qualifier, that is, the qualifier that is a subtype of start but no further subtypes exist.
  - getBottomAnnotations
```
public abstract Set<? extends AnnotationMirror> getBottomAnnotations()
```
    Returns:
    
    the bottom type qualifier in the hierarchy
  - getPolymorphicAnnotation
```
public abstract AnnotationMirror getPolymorphicAnnotation(AnnotationMirror start)
```
    Parameters:
    
    start - any qualifier from the type hierarchy
    
    Returns:
    
    the polymorphic qualifier for that hierarchy or null if there is no polymorphic qualifier in that hierarchy
  - getTypeQualifiers
```
public abstract Set<? extends AnnotationMirror> getTypeQualifiers()
```
    Returns all type qualifiers in this type qualifier hierarchy.
    
    Returns:
    
    the fully qualified name represented in this hierarchy
  - isSubtype
```
public abstract boolean isSubtype(AnnotationMirror rhs,
                                  AnnotationMirror lhs)
```
    Tests whether rhs is equal to or a sub-qualifier of lhs, according to the type qualifier hierarchy. This checks only the qualifiers, not the Java type.
    
    Returns:
    
    true iff rhs is a sub qualifier of lhs
  - isSubtype
```
public abstract boolean isSubtype(Collection<? extends AnnotationMirror> rhs,
                                  Collection<? extends AnnotationMirror> lhs)
```
    Tests whether there is any annotation in lhs that is a super qualifier of some annotation in rhs. lhs and rhs contain only the annotations, not the Java type.
    
    Returns:
    
    true iff an annotation in lhs is a super of one in rhs
  - leastUpperBound
```
public abstract AnnotationMirror leastUpperBound(AnnotationMirror a1,
                                                 AnnotationMirror a2)
```
    Returns the least upper bound for the qualifiers a1 and a2.
    Examples:
    - For NonNull, leastUpperBound('Nullable', 'NonNull') ⇒ Nullable
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    Returns:
    
    the least restrictive qualifiers for both types
  - numberOfIterationsBeforeWidening
```
public int numberOfIterationsBeforeWidening()
```
    Returns the number of iterations dataflow should perform before widenedUpperBound(AnnotationMirror, AnnotationMirror) is called or -1 if it should never be called.
    Subclasses overriding this method should return some positive number or -1.
    
    Returns:
    
    the number of iterations dataflow should perform before widenedUpperBound(AnnotationMirror, AnnotationMirror) is called or -1 if it should never be called.
  - widenedUpperBound
```
public AnnotationMirror widenedUpperBound(AnnotationMirror newQualifier,
                                          AnnotationMirror previousQualifier)
```
    If the type hierarchy has an infinite ascending chain, then the dataflow analysis might never reach a fixed point. To prevent this, implement this method such that it returns an upper bound for the two qualifiers that is a super type and not equal to the least upper bound. If this method is implemented, also override numberOfIterationsBeforeWidening() and change its return to a positive number.
    newQualifier is newest qualifier dataflow computed for some expression and previousQualifier is the qualifier dataflow computed on the last iteration.
    If the type hierarchy has no infinite ascending chain, returns the least upper bound of the two annotations.
    
    Parameters:
    
    newQualifier - new qualifier dataflow computed for some expression
    
    previousQualifier - the previous qualifier dataflow computed on the last iteration
    
    Returns:
    
    an upper bound that is wider than the least upper bound of newQualifier and previousQualifier (or the lub if the type hierarchy does not require this)
  - greatestLowerBound
```
public abstract AnnotationMirror greatestLowerBound(AnnotationMirror a1,
                                                    AnnotationMirror a2)
```
    Returns the greatest lower bound for the qualifiers a1 and a2.
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    
    Parameters:
    
    a1 - first annotation
    
    a2 - second annotation
    
    Returns:
    
    greatest lower bound of the two annotations
  - leastUpperBounds
```
public Set<? extends AnnotationMirror> leastUpperBounds(Collection<? extends AnnotationMirror> annos1,
                                                        Collection<? extends AnnotationMirror> annos2)
```
    Returns the least upper bound of two types. Each type is represented as a set of type qualifiers, as is the result.
    Annos1 and annos2 must have the same size, and each annotation in them must be from a different type hierarchy.
    This is necessary for determining the type of a conditional expression (?:), where the type of the expression is the least upper bound of the true and false clauses.
    
    Parameters:
    
    annos1 - first collection of qualifiers
    
    annos2 - second collection of qualifiers
    
    Returns:
    
    pairwise least upper bounds of elements of the input collections (which need not be sorted in the same order)
  - replacePolyAll
```
protected Collection<? extends AnnotationMirror> replacePolyAll(Collection<? extends AnnotationMirror> annos)
```
    Returns a new set that is the passed set, but PolyAll has been replaced by a polymorphic qualifiers, for hierarchies that do not have an annotation in the set.
    
    Parameters:
    
    annos - set of annotations
    
    Returns:
    
    a new set with same annotations as anno, but PolyAll has been replaced with polymorphic qualifiers
  - greatestLowerBounds
```
public Set<? extends AnnotationMirror> greatestLowerBounds(Collection<? extends AnnotationMirror> annos1,
                                                           Collection<? extends AnnotationMirror> annos2)
```
    Returns the greatest lower bound of two types. Each type is represented as a set of type qualifiers, as is the result.
    Annos1 and annos2 must have the same size, and each annotation in them must be from a different type hierarchy.
    
    Parameters:
    
    annos1 - first collection of qualifiers
    
    annos2 - second collection of qualifiers
    
    Returns:
    
    pairwise greatest lower bounds of elements of the input collections (which need not be sorted in the same order)
  - isSubtypeTypeVariable
```
public abstract boolean isSubtypeTypeVariable(AnnotationMirror subAnno,
                                              AnnotationMirror superAnno)
```
    Tests whether subAnno is a sub-qualifier of superAnno, according to the type qualifier hierarchy. This checks only the qualifiers, not the Java type.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    
    Returns:
    
    true iff subAnno is a sub qualifier of superAnno
  - isSubtypeTypeVariable
```
public abstract boolean isSubtypeTypeVariable(Collection<? extends AnnotationMirror> subAnnos,
                                              Collection<? extends AnnotationMirror> superAnnos)
```
    Tests whether there is any annotation in superAnnos that is a super qualifier of some annotation in subAnnos. superAnnos and subAnnos contain only the annotations, not the Java type.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    
    Returns:
    
    true iff an annotation in superAnnos is a super of one in subAnnos
  - leastUpperBoundTypeVariable
```
public abstract AnnotationMirror leastUpperBoundTypeVariable(AnnotationMirror a1,
                                                             AnnotationMirror a2)
```
    Returns the least upper bound for the qualifiers a1 and a2.
    Examples:
    - For NonNull, leastUpperBound('Nullable', 'NonNull') → Nullable
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    Returns:
    
    the least restrictive qualifiers for both types
  - greatestLowerBoundTypeVariable
```
public abstract AnnotationMirror greatestLowerBoundTypeVariable(AnnotationMirror a1,
                                                                AnnotationMirror a2)
```
    Returns the greatest lower bound for the qualifiers a1 and a2.
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    
    Parameters:
    
    a1 - first annotation
    
    a2 - second annotation
    
    Returns:
    
    greatest lower bound of the two annotations
  - leastUpperBoundsTypeVariable
```
public Set<? extends AnnotationMirror> leastUpperBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1,
                                                                    Collection<? extends AnnotationMirror> annos2)
```
    Returns the type qualifiers that are the least upper bound of the qualifiers in annos1 and annos2.
    This is necessary for determining the type of a conditional expression (?:), where the type of the expression is the least upper bound of the true and false clauses.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    
    Returns:
    
    the least upper bound of annos1 and annos2
  - greatestLowerBoundsTypeVariable
```
public Set<? extends AnnotationMirror> greatestLowerBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1,
                                                                       Collection<? extends AnnotationMirror> annos2)
```
    Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2.
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful value (namely, no annotation).
    
    Parameters:
    
    annos1 - first collection of qualifiers
    
    annos2 - second collection of qualifiers
    
    Returns:
    
    greatest lower bound of the two collections of qualifiers
  - canHaveEmptyAnnotationSet
```
public static boolean canHaveEmptyAnnotationSet(AnnotatedTypeMirror type)
```
    Returns true if and only if the given type can have empty annotation sets (and thus the *TypeVariable methods need to be used).
  - isSubtype
```
public boolean isSubtype(AnnotatedTypeMirror subType,
                         AnnotatedTypeMirror superType,
                         AnnotationMirror subAnno,
                         AnnotationMirror superAnno)
```
    Tests whether subAnno is a sub-qualifier of superAnno, according to the type qualifier hierarchy. This checks only the qualifiers, not the Java type.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    
    Returns:
    
    true iff subAnno is a sub qualifier of superAnno
  - isSubtype
```
public boolean isSubtype(AnnotatedTypeMirror subType,
                         AnnotatedTypeMirror superType,
                         Collection<? extends AnnotationMirror> subs,
                         Collection<AnnotationMirror> supers)
```
    Tests whether there is any annotation in supers that is a super qualifier of some annotation in subs. supers and subs contain only the annotations, not the Java type.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    
    Returns:
    
    true iff an annotation in supers is a super of one in subs
  - leastUpperBound
```
public AnnotationMirror leastUpperBound(AnnotatedTypeMirror type1,
                                        AnnotatedTypeMirror type2,
                                        AnnotationMirror a1,
                                        AnnotationMirror a2)
```
    Returns the least upper bound for the qualifiers a1 and a2.
    Examples:
    - For NonNull, leastUpperBound('Nullable', 'NonNull') → Nullable
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    Returns:
    
    the least restrictive qualifiers for both types
  - greatestLowerBound
```
public AnnotationMirror greatestLowerBound(AnnotatedTypeMirror type1,
                                           AnnotatedTypeMirror type2,
                                           AnnotationMirror a1,
                                           AnnotationMirror a2)
```
    Returns the greatest lower bound for the qualifiers a1 and a2.
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    
    Parameters:
    
    a1 - first annotation
    
    a2 - second annotation
    
    Returns:
    
    greatest lower bound of the two annotations
  - leastUpperBounds
```
public Set<? extends AnnotationMirror> leastUpperBounds(AnnotatedTypeMirror type1,
                                                        AnnotatedTypeMirror type2,
                                                        Collection<? extends AnnotationMirror> annos1,
                                                        Collection<AnnotationMirror> annos2)
```
    Returns the type qualifiers that are the least upper bound of the qualifiers in annos1 and annos2.
    This is necessary for determining the type of a conditional expression (?:), where the type of the expression is the least upper bound of the true and false clauses.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    
    Returns:
    
    the least upper bound of annos1 and annos2
  - greatestLowerBounds
```
public Set<? extends AnnotationMirror> greatestLowerBounds(AnnotatedTypeMirror type1,
                                                           AnnotatedTypeMirror type2,
                                                           Collection<? extends AnnotationMirror> annos1,
                                                           Collection<AnnotationMirror> annos2)
```
    Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2.
    The two qualifiers have to be from the same qualifier hierarchy. Otherwise, null will be returned.
    This method takes an annotated type to decide if the type variable version of the method should be invoked, or if the normal version is sufficient (which provides more strict checks).
    
    Parameters:
    
    annos1 - first collection of qualifiers
    
    annos2 - second collection of qualifiers
    
    Returns:
    
    greatest lower bound of the two collections of qualifiers
  - findAnnotationInSameHierarchy
```
public AnnotationMirror findAnnotationInSameHierarchy(Collection<? extends AnnotationMirror> annos,
                                                      AnnotationMirror annotationMirror)
```
    Returns the annotation in annos that is in the same hierarchy as annotationMirror.
    If the annotation in the hierarchy is PolyAll, then the polymorphic qualifier in the hierarchy is returned instead of PolyAll.
    
    Parameters:
    
    annos - set of annotations to search
    
    annotationMirror - annotation that is in the same hierarchy as the returned annotation
    
    Returns:
    
    annotation in the same hierarchy as annotationMirror, or null if one is not found
  - findAnnotationInHierarchy
```
public AnnotationMirror findAnnotationInHierarchy(Collection<? extends AnnotationMirror> annos,
                                                  AnnotationMirror top)
```
    Returns the annotation in annos that is in the hierarchy for which annotationMirror is top.
    If the annotation in the hierarchy is PolyAll, then the polymorphic qualifier in the hierarchy is returned instead of PolyAll.
    
    Parameters:
    
    annos - set of annotations to search
    
    top - the top annotation in the hierarchy to which the returned annotation belongs
    
    Returns:
    
    annotation in the same hierarchy as annotationMirror, or null if one is not found
  - updateMappingToMutableSet
```
public <T> boolean updateMappingToMutableSet(Map<T,Set<AnnotationMirror>> map,
                                             T key,
                                             AnnotationMirror newQual)
```
    Update a mapping from some key to a set of AnnotationMirrors. If the key already exists in the mapping and the new qualifier is in the same qualifier hierarchy as any of the existing qualifiers, do nothing and return false. If the key already exists in the mapping and the new qualifier is not in the same qualifier hierarchy as any of the existing qualifiers, add the qualifier to the existing set and return true. If the key does not exist in the mapping, add the new qualifier as a singleton set and return true.
    
    Parameters:
    
    map - the mapping to modify
    
    key - the key to update
    
    newQual - the value to add
    
    Returns:
    
    whether there was a qualifier hierarchy collision

Class QualifierHierarchy

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QualifierHierarchy

Method Detail

isValid

getWidth

getTopAnnotations

getTopAnnotation

getBottomAnnotation

getBottomAnnotations

getPolymorphicAnnotation

getTypeQualifiers

isSubtype

isSubtype

leastUpperBound

numberOfIterationsBeforeWidening

widenedUpperBound

greatestLowerBound

leastUpperBounds

replacePolyAll

greatestLowerBounds

isSubtypeTypeVariable

isSubtypeTypeVariable

leastUpperBoundTypeVariable

greatestLowerBoundTypeVariable

leastUpperBoundsTypeVariable

greatestLowerBoundsTypeVariable

canHaveEmptyAnnotationSet

isSubtype

isSubtype

leastUpperBound

greatestLowerBound

leastUpperBounds

greatestLowerBounds

findAnnotationInSameHierarchy

findAnnotationInHierarchy

updateMappingToMutableSet