org.checkerframework.framework.type

Interface QualifierHierarchy

All Known Implementing Classes:

AccumulationAnnotatedTypeFactory.AccumulationQualifierHierarchy, AliasingAnnotatedTypeFactory.AliasingQualifierHierarchy, ClassValAnnotatedTypeFactory.ClassValQualifierHierarchy, ElementQualifierHierarchy, FenumAnnotatedTypeFactory.FenumQualifierHierarchy, GraphQualifierHierarchy, InitializationAnnotatedTypeFactory.InitializationQualifierHierarchy, MethodValAnnotatedTypeFactory.MethodValQualifierHierarchy, MostlyNoElementQualifierHierarchy, MultiGraphQualifierHierarchy, NoElementQualifierHierarchy, NullnessAnnotatedTypeFactory.NullnessQualifierHierarchy, UnitsAnnotatedTypeFactory.UnitsQualifierHierarchy, UpperBoundAnnotatedTypeFactory.UpperBoundQualifierHierarchy

@AnnotatedFor(value="nullness")
public interface QualifierHierarchy

Represents multiple type qualifier hierarchies. getWidth() gives the number of hierarchies that this object represents. Each hierarchy has its own top and bottom, and subtyping relationships exist only within each hierarchy.

Note the distinction in terminology between a qualifier hierarchy, which has one top and one bottom, and a QualifierHierarchy, which represents multiple qualifier hierarchies.

All type annotations need to be type qualifiers recognized within this hierarchy.

This assumes that every annotated type in a program is annotated with exactly one qualifier from each hierarchy.

Method Summary

Modifier and Type	Method and Description
static void	assertSameSize(Collection<?> c1, Collection<?> c2) Throws an exception if the given collections do not have the same size.
static void	assertSameSize(Collection<?> c1, Collection<?> c2, Collection<?> result) Throws an exception if the result does not have the same size as the inputs (which are assumed to have the same size as one another).
static boolean	canHaveEmptyAnnotationSet(AnnotatedTypeMirror type) Returns true if and only if AnnotatedTypeMirror.getAnnotations() can return a set with fewer qualifiers than the width of the QualifierHierarchy.
default @Nullable AnnotationMirror	findAnnotationInHierarchy(Collection<? extends AnnotationMirror> qualifiers, AnnotationMirror top) Returns the annotation in qualifiers that is in the hierarchy for which top is top.
default @Nullable AnnotationMirror	findAnnotationInSameHierarchy(Collection<? extends AnnotationMirror> qualifiers, AnnotationMirror qualifier) Returns the annotation in qualifiers that is in the same hierarchy as qualifier.
AnnotationMirror	getBottomAnnotation(AnnotationMirror qualifier) Return the bottom for the given qualifier, that is, the qualifier that is a subtype of qualifier but no further subtypes exist.
Set<? extends AnnotationMirror>	getBottomAnnotations() Returns the bottom type qualifiers in the hierarchy.
@Nullable AnnotationMirror	getPolymorphicAnnotation(AnnotationMirror qualifier) Returns the polymorphic qualifier for the hierarchy containing qualifier, or null if there is no polymorphic qualifier in that hierarchy.
AnnotationMirror	getTopAnnotation(AnnotationMirror qualifier) Return the top qualifier for the given qualifier, that is, the qualifier that is a supertype of qualifier but no further supertypes exist.
Set<? extends AnnotationMirror>	getTopAnnotations() Returns the top (ultimate super) type qualifiers in the type system.
default int	getWidth() Returns the width of this hierarchy, i.e.
default @Nullable AnnotationMirror	greatestLowerBound(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, AnnotationMirror a1, AnnotationMirror a2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier
@Nullable AnnotationMirror	greatestLowerBound(AnnotationMirror qualifier1, AnnotationMirror qualifier2) Returns the greatest lower bound for the qualifiers qualifier1 and qualifier2.
default Set<? extends AnnotationMirror>	greatestLowerBounds(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, Collection<? extends AnnotationMirror> annos1, Collection<AnnotationMirror> annos2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier
default Set<? extends AnnotationMirror>	greatestLowerBounds(Collection<? extends AnnotationMirror> qualifiers1, Collection<? extends AnnotationMirror> qualifiers2) Returns the greatest lower bound of the two sets of qualifiers.
default Set<? extends AnnotationMirror>	greatestLowerBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier
default @Nullable AnnotationMirror	greatestLowerBoundTypeVariable(AnnotationMirror a1, AnnotationMirror a2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier
boolean	isPolymorphicQualifier(AnnotationMirror qualifier) Returns true if the qualifier is a polymorphic qualifier; otherwise, returns false.
default boolean	isSubtype(AnnotatedTypeMirror subType, AnnotatedTypeMirror superType, AnnotationMirror subQualifier, AnnotationMirror superQualifier) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).
default boolean	isSubtype(AnnotatedTypeMirror subType, AnnotatedTypeMirror superType, Collection<? extends AnnotationMirror> subs, Collection<AnnotationMirror> supers) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).
boolean	isSubtype(AnnotationMirror subQualifier, AnnotationMirror superQualifier) Tests whether subQualifier is equal to or a sub-qualifier of superQualifier, according to the type qualifier hierarchy.
default boolean	isSubtype(Collection<? extends AnnotationMirror> subQualifiers, Collection<? extends AnnotationMirror> superQualifiers) Tests whether all qualifiers in subQualifiers are a subqualifier or equal to the qualifier in the same hierarchy in superQualifiers.
default boolean	isSubtypeTypeVariable(@Nullable AnnotationMirror subQualifier, @Nullable AnnotationMirror superQualifier) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).
default boolean	isSubtypeTypeVariable(Collection<? extends AnnotationMirror> subAnnos, Collection<? extends AnnotationMirror> superAnnos) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).
default boolean	isValid() Determine whether this is valid.
default @Nullable AnnotationMirror	leastUpperBound(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, AnnotationMirror a1, AnnotationMirror a2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).
@Nullable AnnotationMirror	leastUpperBound(AnnotationMirror qualifier1, AnnotationMirror qualifier2) Returns the least upper bound (LUB) of the qualifiers qualifier1 and qualifier2.
default Set<? extends AnnotationMirror>	leastUpperBounds(AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, Collection<? extends AnnotationMirror> annos1, Collection<AnnotationMirror> annos2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).
default Set<? extends AnnotationMirror>	leastUpperBounds(Collection<? extends AnnotationMirror> qualifiers1, Collection<? extends AnnotationMirror> qualifiers2) Returns the least upper bound of the two sets of qualifiers.
default Set<? extends AnnotationMirror>	leastUpperBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).
default @Nullable AnnotationMirror	leastUpperBoundTypeVariable(AnnotationMirror a1, AnnotationMirror a2) Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).
default int	numberOfIterationsBeforeWidening() Returns the number of iterations dataflow should perform before widenedUpperBound(AnnotationMirror, AnnotationMirror) is called or -1 if it should never be called.
default <T> boolean	updateMappingToMutableSet(Map<T,Set<AnnotationMirror>> map, T key, AnnotationMirror qualifier) Update a mapping from key to a set of AnnotationMirrors.
default AnnotationMirror	widenedUpperBound(AnnotationMirror newQualifier, AnnotationMirror previousQualifier) If the qualifier hierarchy has an infinite ascending chain, then the dataflow analysis might never reach a fixed point.

Method Detail

isValid

default boolean isValid()

Determine whether this is valid.

Returns:

whether this is valid

getWidth

default int getWidth()

Returns the width of this hierarchy, i.e. the expected number of annotations on any valid type.

Returns:

the width of this QualifierHierarchy

getTopAnnotations

Set<? extends AnnotationMirror> getTopAnnotations()

Returns the top (ultimate super) type qualifiers in the type system. The size of this set is equal to getWidth().

Returns:

the top (ultimate super) type qualifiers in the type system

getTopAnnotation

AnnotationMirror getTopAnnotation(AnnotationMirror qualifier)

Return the top qualifier for the given qualifier, that is, the qualifier that is a supertype of qualifier but no further supertypes exist.

Parameters:

qualifier - any qualifier from one of the qualifier hierarchies represented by this

Returns:

the top qualifier of qualifier's hierarchy

getBottomAnnotations

Set<? extends AnnotationMirror> getBottomAnnotations()

Returns the bottom type qualifiers in the hierarchy. The size of this set is equal to getWidth().

Returns:

the bottom type qualifiers in the hierarchy

getBottomAnnotation

AnnotationMirror getBottomAnnotation(AnnotationMirror qualifier)

Return the bottom for the given qualifier, that is, the qualifier that is a subtype of qualifier but no further subtypes exist.

Parameters:

qualifier - any qualifier from one of the qualifier hierarchies represented by this

Returns:

the bottom qualifier of qualifier's hierarchy

getPolymorphicAnnotation

@Nullable AnnotationMirror getPolymorphicAnnotation(AnnotationMirror qualifier)

Returns the polymorphic qualifier for the hierarchy containing qualifier, or null if there is no polymorphic qualifier in that hierarchy.

Parameters:

qualifier - any qualifier from one of the qualifier hierarchies represented by this

Returns:

the polymorphic qualifier for the hierarchy containing qualifier, or null if there is no polymorphic qualifier in that hierarchy

isPolymorphicQualifier

boolean isPolymorphicQualifier(AnnotationMirror qualifier)

Returns true if the qualifier is a polymorphic qualifier; otherwise, returns false.

Parameters:

qualifier - qualifier

Returns:

true if the qualifier is a polymorphic qualifier; otherwise, returns false.

isSubtype

boolean isSubtype(AnnotationMirror subQualifier,
                  AnnotationMirror superQualifier)

Tests whether subQualifier is equal to or a sub-qualifier of superQualifier, according to the type qualifier hierarchy.

Parameters:

subQualifier - possible subqualifier of superQualifier

superQualifier - possible superqualifier of subQualifier

Returns:

true iff subQualifier is a subqualifier of, or equal to, superQualifier

isSubtype

default boolean isSubtype(Collection<? extends AnnotationMirror> subQualifiers,
                          Collection<? extends AnnotationMirror> superQualifiers)

Tests whether all qualifiers in subQualifiers are a subqualifier or equal to the qualifier in the same hierarchy in superQualifiers.

Parameters:

subQualifiers - set of qualifiers; exactly one per hierarchy

superQualifiers - set of qualifiers; exactly one per hierarchy

Returns:

true iff all qualifiers in subQualifiers are a subqualifier or equal to the qualifier in the same hierarchy in superQualifiers

leastUpperBound

@Nullable AnnotationMirror leastUpperBound(AnnotationMirror qualifier1,
                                           AnnotationMirror qualifier2)

Returns the least upper bound (LUB) of the qualifiers qualifier1 and qualifier2. Returns null if the qualifiers are not from the same qualifier hierarchy.

Examples:

• For NonNull, leastUpperBound('Nullable', 'NonNull') ⇒ Nullable

Parameters:

qualifier1 - the first qualifier; may not be in the same hierarchy as qualifier2

qualifier2 - the second qualifier; may not be in the same hierarchy as qualifier1

Returns:

the least upper bound of the qualifiers, or null if the qualifiers are from different hierarchies

leastUpperBounds

default Set<? extends AnnotationMirror> leastUpperBounds(Collection<? extends AnnotationMirror> qualifiers1,
                                                         Collection<? extends AnnotationMirror> qualifiers2)

Returns the least upper bound of the two sets of qualifiers. The result is the lub of the qualifier for the same hierarchy in each set.

Parameters:

qualifiers1 - set of qualifiers; exactly one per hierarchy

qualifiers2 - set of qualifiers; exactly one per hierarchy

Returns:

the least upper bound of the two sets of qualifiers

numberOfIterationsBeforeWidening

default int numberOfIterationsBeforeWidening()

Returns the number of iterations dataflow should perform before widenedUpperBound(AnnotationMirror, AnnotationMirror) is called or -1 if it should never be called.

Returns:

the number of iterations dataflow should perform before widenedUpperBound(AnnotationMirror, AnnotationMirror) is called or -1 if it should never be called.

widenedUpperBound

default AnnotationMirror widenedUpperBound(AnnotationMirror newQualifier,
                                           AnnotationMirror previousQualifier)

If the qualifier 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 strict super type of the least upper bound. If this method is implemented, also override numberOfIterationsBeforeWidening() to return 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 qualifier hierarchy has no infinite ascending chain, returns the least upper bound of the two annotations.

Parameters:

newQualifier - new qualifier dataflow computed for some expression; must be in the same hierarchy as previousQualifier

previousQualifier - the previous qualifier dataflow computed on the last iteration; must be in the same hierarchy as previousQualifier

Returns:

an upper bound that is higher than the least upper bound of newQualifier and previousQualifier (or the lub if the qualifier hierarchy does not require this)

greatestLowerBound

@Nullable AnnotationMirror greatestLowerBound(AnnotationMirror qualifier1,
                                              AnnotationMirror qualifier2)

Returns the greatest lower bound for the qualifiers qualifier1 and qualifier2. Returns null if the qualifiers are not from the same qualifier hierarchy.

Parameters:

qualifier1 - first qualifier

qualifier2 - second qualifier

Returns:

greatest lower bound of the two annotations or null if the two annotations are not from the same hierarchy

greatestLowerBounds

default Set<? extends AnnotationMirror> greatestLowerBounds(Collection<? extends AnnotationMirror> qualifiers1,
                                                            Collection<? extends AnnotationMirror> qualifiers2)

Returns the greatest lower bound of the two sets of qualifiers. The result is the lub of the qualifier for the same hierarchy in each set.

Parameters:

qualifiers1 - set of qualifiers; exactly one per hierarchy

qualifiers2 - set of qualifiers; exactly one per hierarchy

Returns:

the greatest lower bound of the two sets of qualifiers

canHaveEmptyAnnotationSet

static boolean canHaveEmptyAnnotationSet(AnnotatedTypeMirror type)

Returns true if and only if AnnotatedTypeMirror.getAnnotations() can return a set with fewer qualifiers than the width of the QualifierHierarchy.

Parameters:

type - the type to test

Returns:

true if and only if AnnotatedTypeMirror.getAnnotations() can return a set with fewer qualifiers than the width of the QualifierHierarchy

findAnnotationInSameHierarchy

default @Nullable AnnotationMirror findAnnotationInSameHierarchy(Collection<? extends AnnotationMirror> qualifiers,
                                                                 AnnotationMirror qualifier)

Returns the annotation in qualifiers that is in the same hierarchy as qualifier.

The default implementation calls getTopAnnotation(AnnotationMirror) and then calls findAnnotationInHierarchy(Collection, AnnotationMirror). So, if qualifier is a top qualifier, then call findAnnotationInHierarchy(Collection, AnnotationMirror) directly is faster.

Parameters:

qualifiers - set of annotations to search

qualifier - annotation that is in the same hierarchy as the returned annotation

Returns:

annotation in the same hierarchy as qualifier, or null if one is not found

findAnnotationInHierarchy

default @Nullable AnnotationMirror findAnnotationInHierarchy(Collection<? extends AnnotationMirror> qualifiers,
                                                             AnnotationMirror top)

Returns the annotation in qualifiers that is in the hierarchy for which top is top.

Parameters:

qualifiers - 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

default <T> boolean updateMappingToMutableSet(Map<T,Set<AnnotationMirror>> map,
                                              T key,
                                              AnnotationMirror qualifier)

Update a mapping from key to a set of AnnotationMirrors. If key is not already in the map, then put it in the map with a value of a new set containing qualifier. If the map contains key, then add qualifier to the set to which key maps. If that set contains a qualifier in the same hierarchy as qualifier, then don't add it and return false.

Type Parameters:

T - type of the map's keys

Parameters:

map - the mapping to modify

key - the key to update or add

qualifier - the value to update or add

Returns:

true if the update was done; false if there was a qualifier hierarchy collision

assertSameSize

static void assertSameSize(Collection<?> c1,
                           Collection<?> c2)

Throws an exception if the given collections do not have the same size.

Parameters:

c1 - the first collection

c2 - the second collection

assertSameSize

static void assertSameSize(Collection<?> c1,
                           Collection<?> c2,
                           Collection<?> result)

Throws an exception if the result does not have the same size as the inputs (which are assumed to have the same size as one another).

Parameters:

c1 - the first collection

c2 - the second collection

result - the result collection

isSubtypeTypeVariable

@Deprecated
default boolean isSubtypeTypeVariable(@Nullable AnnotationMirror subQualifier,
                                                  @Nullable AnnotationMirror superQualifier)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).

Tests whether subQualifier is a sub-qualifier of, or equal to, superQualifier, according to the type qualifier hierarchy.

This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnotationMirror is a legal argument that represents no annotation.

Parameters:

subQualifier - a qualifier that might be a subtype

superQualifier - a qualifier that might be a subtype

Returns:

true iff subQualifier is a subqualifier of, or equal to, superQualifier

isSubtype

@Deprecated
default boolean isSubtype(AnnotatedTypeMirror subType,
                                      AnnotatedTypeMirror superType,
                                      AnnotationMirror subQualifier,
                                      AnnotationMirror superQualifier)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).

Tests whether subQualifier is a sub-qualifier of, or equal to, superQualifier, 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).

Parameters:

subType - used to decide whether to call isSubtypeTypeVariable

superType - used to decide whether to call isSubtypeTypeVariable

subQualifier - the type qualifier that might be a subtype

superQualifier - the type qualifier that might be a supertype

Returns:

true iff subQualifier is a subqualifier of, or equal to, superQualifier

isSubtype

@Deprecated
default boolean isSubtype(AnnotatedTypeMirror subType,
                                      AnnotatedTypeMirror superType,
                                      Collection<? extends AnnotationMirror> subs,
                                      Collection<AnnotationMirror> supers)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).

Tests whether there is any annotation in supers that is a superqualifier of, or equal to, 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).

Parameters:

subType - used to decide whether to call isSubtypeTypeVariable

superType - used to decide whether to call isSubtypeTypeVariable

subs - the type qualifiers that might be a subtype

supers - the type qualifiers that might be a supertype

Returns:

true iff an annotation in supers is a supertype of, or equal to, one in subs

isSubtypeTypeVariable

@Deprecated
default boolean isSubtypeTypeVariable(Collection<? extends AnnotationMirror> subAnnos,
                                                  Collection<? extends AnnotationMirror> superAnnos)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the subtype relationship between "no qualifier" and a qualifier. Use TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror).

Tests whether there is any annotation in superAnnos that is a superqualifier of or equal to 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, the empty set is a legal argument that represents no annotation.

Parameters:

subAnnos - qualifiers

superAnnos - qualifiers

Returns:

true iff an annotation in superAnnos is a supertype of, or equal to, one in subAnnos

leastUpperBoundTypeVariable

@Deprecated
default @Nullable AnnotationMirror leastUpperBoundTypeVariable(AnnotationMirror a1,
                                                                           AnnotationMirror a2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).

Returns the least upper bound for the qualifiers a1 and a2. Returns null if the qualifiers are not from the same qualifier hierarchy.

Examples:

• For NonNull, leastUpperBound('Nullable', 'NonNull') → Nullable

This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnotationMirror is a legal argument that represents no annotation.

Parameters:

a1 - anno1

a2 - anno2

Returns:

the least restrictive qualifiers for both types

leastUpperBound

@Deprecated
default @Nullable AnnotationMirror leastUpperBound(AnnotatedTypeMirror type1,
                                                               AnnotatedTypeMirror type2,
                                                               AnnotationMirror a1,
                                                               AnnotationMirror a2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).

Returns the least upper bound for the qualifiers a1 and a2. Returns null if the qualifiers are not from the same qualifier hierarchy.

Examples:

• For NonNull, leastUpperBound('Nullable', 'NonNull') → Nullable

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:

type1 - type 1

type2 - type 2

a1 - annotation

a2 - annotation

Returns:

the least restrictive qualifiers for both types

leastUpperBoundsTypeVariable

@Deprecated
default Set<? extends AnnotationMirror> leastUpperBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1,
                                                                                 Collection<? extends AnnotationMirror> annos2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).

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, the empty set is a legal argument that represents no annotation.

Parameters:

annos1 - qualifiers

annos2 - qualifiers

Returns:

the least upper bound of annos1 and annos2

leastUpperBounds

@Deprecated
default Set<? extends AnnotationMirror> leastUpperBounds(AnnotatedTypeMirror type1,
                                                                     AnnotatedTypeMirror type2,
                                                                     Collection<? extends AnnotationMirror> annos1,
                                                                     Collection<AnnotationMirror> annos2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier. Use AnnotatedTypes.leastUpperBound(AnnotatedTypeFactory, AnnotatedTypeMirror, AnnotatedTypeMirror).

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).

Parameters:

type1 - annotated type

type2 - annotated type

annos1 - qualifiers

annos2 - qualifiers

Returns:

the least upper bound of annos1 and annos2

greatestLowerBoundTypeVariable

@Deprecated
default @Nullable AnnotationMirror greatestLowerBoundTypeVariable(AnnotationMirror a1,
                                                                              AnnotationMirror a2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier

Returns the greatest lower bound for the qualifiers a1 and a2. Returns null if the qualifiers are not from the same qualifier hierarchy.

This method works even if the underlying Java type is a type variable. In that case, a 'null' AnnotationMirror is a legal argument that represents no annotation.

Parameters:

a1 - first annotation

a2 - second annotation

Returns:

greatest lower bound of the two annotations

greatestLowerBoundsTypeVariable

@Deprecated
default Set<? extends AnnotationMirror> greatestLowerBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1,
                                                                                    Collection<? extends AnnotationMirror> annos2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier

Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2. Returns null if the qualifiers are not from the same qualifier hierarchy.

This method works even if the underlying Java type is a type variable. In that case, the empty set is a legal argument that represents no annotation.

Parameters:

annos1 - first collection of qualifiers

annos2 - second collection of qualifiers

Returns:

greatest lower bound of the two collections of qualifiers

greatestLowerBound

@Deprecated
default @Nullable AnnotationMirror greatestLowerBound(AnnotatedTypeMirror type1,
                                                                  AnnotatedTypeMirror type2,
                                                                  AnnotationMirror a1,
                                                                  AnnotationMirror a2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier

Returns the greatest lower bound for the qualifiers a1 and a2. Returns null if the qualifiers are not from the same qualifier hierarchy.

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:

type1 - annotated type

type2 - annotated type

a1 - first annotation

a2 - second annotation

Returns:

greatest lower bound of the two annotations

greatestLowerBounds

@Deprecated
default Set<? extends AnnotationMirror> greatestLowerBounds(AnnotatedTypeMirror type1,
                                                                        AnnotatedTypeMirror type2,
                                                                        Collection<? extends AnnotationMirror> annos1,
                                                                        Collection<AnnotationMirror> annos2)

Deprecated. Without the bounds of the type variable, it is not possible to correctly compute the relationship between "no qualifier" and a qualifier

Returns the type qualifiers that are the greatest lower bound of the qualifiers in annos1 and annos2. Returns null if the qualifiers are not from the same qualifier hierarchy.

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:

type1 - annotated type

type2 - annotated type

annos1 - first collection of qualifiers

annos2 - second collection of qualifiers

Returns:

greatest lower bound of the two collections of qualifiers