AnnotatedTypes (checker-framework 2.9.0 API)

java.lang.Object
- org.checkerframework.framework.util.AnnotatedTypes

```
public class AnnotatedTypes
extends Object
```
Utility methods for operating on AnnotatedTypeMirror. This class mimics the class Types.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`areCorrespondingTypeVariables(Elements elements, AnnotatedTypeMirror.AnnotatedTypeVariable type1, AnnotatedTypeMirror.AnnotatedTypeVariable type2)` When overriding a method, you must include the same number of type parameters as the base method.
`static AnnotatedTypeMirror`	`asMemberOf(Types types, AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror t, Element elem)` Returns the type of an element when that element is viewed as a member of, or otherwise directly contained by, a given type.
`static AnnotatedTypeMirror.AnnotatedExecutableType`	`asMemberOf(Types types, AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror t, ExecutableElement elem)`
`static <T extends AnnotatedTypeMirror> T`	`asSuper(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror type, T superType)` Copies annotations from `type` to a copy of `superType` where the type variables of `superType` have been substituted.
`static <T extends AnnotatedTypeMirror> T`	`castedAsSuper(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror subtype, T supertype)` Calls asSuper and casts the result to the same type as the input supertype.
`static boolean`	`containsModifier(AnnotatedTypeMirror type, AnnotationMirror modifier)` Checks whether type contains the given modifier, also recursively in type arguments and arrays.
`static void`	`copyOnlyExplicitConstructorAnnotations(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror.AnnotatedDeclaredType returnType, AnnotatedTypeMirror.AnnotatedExecutableType constructor)` Copies explicit annotations and annotations resulting from resolution of polymorphic qualifiers from `constructor` to `returnType`.
`static List<AnnotatedTypeMirror>`	`expandVarArgs(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror.AnnotatedExecutableType method, List<? extends ExpressionTree> args)` Returns the method parameters for the invoked method, with the same number of arguments passed in the methodInvocation tree.
`static List<AnnotatedTypeMirror>`	`expandVarArgsFromTypes(AnnotatedTypeMirror.AnnotatedExecutableType method, List<AnnotatedTypeMirror> args)`
`static AnnotationMirror`	`findEffectiveAnnotationInHierarchy(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror toSearch, AnnotationMirror top)` When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds.
`static AnnotationMirror`	`findEffectiveAnnotationInHierarchy(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror toSearch, AnnotationMirror top, boolean canBeEmpty)` When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds.
`static Set<AnnotationMirror>`	`findEffectiveAnnotations(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror toSearch)` When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds.
`static Set<AnnotationMirror>`	`findEffectiveLowerBoundAnnotations(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror toSearch)` When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds.
`static Map<TypeVariable,AnnotatedTypeMirror>`	`findTypeArguments(ProcessingEnvironment processingEnv, AnnotatedTypeFactory atypeFactory, ExpressionTree expr, ExecutableElement elt, AnnotatedTypeMirror.AnnotatedExecutableType preType)` Given a method or constructor invocation, return a mapping of the type variables to their type arguments, if any exist.
`static AnnotatedTypeMirror`	`getAnnotatedTypeMirrorOfParameter(AnnotatedTypeMirror.AnnotatedExecutableType methodType, int index)` Given an AnnotatedExecutableType of a method or constructor declaration, get the parameter type expect at the indexth position (unwrapping var args if necessary).
`static List<AnnotatedTypeMirror>`	`getAnnotatedTypes(AnnotatedTypeFactory atypeFactory, List<AnnotatedTypeMirror> paramTypes, List<? extends ExpressionTree> trees)` Return a list of the AnnotatedTypeMirror of the passed expression trees, in the same order as the trees.
`static int`	`getArrayDepth(AnnotatedTypeMirror.AnnotatedArrayType array)` Returns the depth of the array type of the provided array.
`static AnnotatedTypeMirror`	`getIteratedType(ProcessingEnvironment processingEnv, AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror iterableType)` Returns the iterated type of the passed iterable type, and throws `IllegalArgumentException` if the passed type is not iterable.
`static Set<AnnotatedTypeMirror.AnnotatedDeclaredType>`	`getSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type)` Returns all the super types of the given declared type.
`static Set<AnnotationMirror>`	`glbOfBounds(AnnotatedTypeMirror.AnnotatedIntersectionType isect, QualifierHierarchy qualifierHierarchy)` Gets the lowest primary annotation of all bounds in the intersection.
`static boolean`	`hasExplicitExtendsBound(AnnotatedTypeMirror wildcard)` This method identifies wildcard types that have an explicit extends bound.
`static boolean`	`hasExplicitSuperBound(AnnotatedTypeMirror wildcard)` This method identifies wildcard types that have an explicit super bound.
`static boolean`	`hasNoExplicitBound(AnnotatedTypeMirror wildcard)` This method identifies wildcard types that are unbound.
`static boolean`	`hasTypeQualifierElementTypes(ElementType[] elements, Class<?> cls)` Returns true if the given array contains `ElementType.TYPE_USE`, false otherwise.
`static boolean`	`haveSameDeclaration(Types types, AnnotatedTypeMirror.AnnotatedTypeVariable typeVar1, AnnotatedTypeMirror.AnnotatedTypeVariable typeVar2)`
`static boolean`	`implementsAnnotation(AnnotatedTypeMirror atm)`
`static AnnotatedTypeMirror`	`innerMostType(AnnotatedTypeMirror t)`
`static boolean`	`isDeclarationOfJavaLangEnum(Types types, Elements elements, AnnotatedTypeMirror typeMirror)`
`static boolean`	`isEnum(AnnotatedTypeMirror typeMirror)`
`static boolean`	`isExplicitlyExtendsBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)` Returns true if wildcard type was explicitly unbounded.
`static boolean`	`isExplicitlySuperBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)`
`static boolean`	`isJavaLangAnnotation(AnnotatedTypeMirror atm)`
`static boolean`	`isTypeAnnotation(AnnotationMirror anno, Class<?> cls)`
`static boolean`	`isUnboundedOrExtendsBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)` Returns true if this type is extends bounded or unbounded.
`static boolean`	`isUnboundedOrSuperBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)` Returns true if this type is super bounded or unbounded.
`static AnnotatedTypeMirror`	`leastUpperBound(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror type1, AnnotatedTypeMirror type2)` Returns the lub of two annotated types.
`static AnnotatedTypeMirror`	`leastUpperBound(AnnotatedTypeFactory atypeFactory, AnnotatedTypeMirror type1, AnnotatedTypeMirror type2, TypeMirror lubTypeMirror)` Returns the lub, whose underlying type is `lubTypeMirror` of two annotated types.
`static Map<AnnotatedTypeMirror.AnnotatedDeclaredType,ExecutableElement>`	`overriddenMethods(Elements elements, AnnotatedTypeFactory atypeFactory, ExecutableElement method)` A utility method that takes a Method element and returns a set of all elements that this method overrides (as `ExecutableElement`s).
`static Map<AnnotatedTypeMirror.AnnotatedDeclaredType,ExecutableElement>`	`overriddenMethods(Elements elements, ExecutableElement method, Collection<AnnotatedTypeMirror.AnnotatedDeclaredType> supertypes)` A utility method that takes the element for a method and the set of all supertypes of the method's containing class and returns the set of all elements that method overrides (as `ExecutableElement`s).

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

- Method Detail
  - asSuper
```
public static <T extends AnnotatedTypeMirror> T asSuper(AnnotatedTypeFactory atypeFactory,
                                                        AnnotatedTypeMirror type,
                                                        T superType)
```
    Copies annotations from type to a copy of superType where the type variables of superType have been substituted. How the annotations are copied depends on the kinds of AnnotatedTypeMirrors given. Generally, if type and superType are both declared types, asSuper is called recursively on the direct super types, see AnnotatedTypeMirror.directSuperTypes(), of type until type's erased Java type is the same as superType's erased super type. Then type is returned. For compound types, asSuper is called recursively on components.
    Preconditions:
    superType may have annotations, but they are ignored.
    type may not be an instanceof AnnotatedNullType, because if superType is a compound type, the annotations on the component types are undefined.
    The underlying type (ie the Java type) of type should be a subtype (or the same type) of the underlying type of superType. Except for these cases:
    - If type is a primitive, then the boxed type of type must be subtype of superType.
    - If superType is a primitive, then type must be convertible to superType.
    - If superType is a type variable or wildcard without a lower bound, then type must be a subtype of the upper bound of superType. (This relaxed rule is used during type argument inference where the type variable or wildcard is the type argument that was inferred.)
    - If superType is a wildcard with a lower bound, then type must be a subtype of the lower bound of superType.
    Postconditions: type and superType are not modified.
    Parameters:
    
    atypeFactory - AnnotatedTypeFactory
    
    type - type from which to copy annotations
    
    superType - a type whose erased Java type is a supertype of type's erased Java type.
    
    Returns:
    
    superType with annotations copied from type and type variables substituted from type.
  - castedAsSuper
```
public static <T extends AnnotatedTypeMirror> T castedAsSuper(AnnotatedTypeFactory atypeFactory,
                                                              AnnotatedTypeMirror subtype,
                                                              T supertype)
```
    Calls asSuper and casts the result to the same type as the input supertype.
    
    Type Parameters:
    
    T - the type of supertype and return type
    
    Parameters:
    
    subtype - subtype to be transformed to supertype
    
    supertype - supertype that subtype is transformed to
    
    Returns:
    
    subtype as an instance of supertype
  - hasNoExplicitBound
```
public static boolean hasNoExplicitBound(AnnotatedTypeMirror wildcard)
```
    This method identifies wildcard types that are unbound.
  - hasExplicitSuperBound
```
public static boolean hasExplicitSuperBound(AnnotatedTypeMirror wildcard)
```
    This method identifies wildcard types that have an explicit super bound. NOTE: Type.WildcardType.isSuperBound will return true for BOTH unbound and super bound wildcards which necessitates this method
  - hasExplicitExtendsBound
```
public static boolean hasExplicitExtendsBound(AnnotatedTypeMirror wildcard)
```
    This method identifies wildcard types that have an explicit extends bound. NOTE: Type.WildcardType.isExtendsBound will return true for BOTH unbound and extends bound wildcards which necessitates this method
  - asMemberOf
```
public static AnnotatedTypeMirror.AnnotatedExecutableType asMemberOf(Types types,
                                                                     AnnotatedTypeFactory atypeFactory,
                                                                     AnnotatedTypeMirror t,
                                                                     ExecutableElement elem)
```
    See Also:
    
    asMemberOf(Types, AnnotatedTypeFactory, AnnotatedTypeMirror, Element)
  - asMemberOf
```
public static AnnotatedTypeMirror asMemberOf(Types types,
                                             AnnotatedTypeFactory atypeFactory,
                                             AnnotatedTypeMirror t,
                                             Element elem)
```
    Returns the type of an element when that element is viewed as a member of, or otherwise directly contained by, a given type.
    For example, when viewed as a member of the parameterized type Set<@NonNull String>, the Set.add method is an ExecutableType whose parameter is of type @NonNull String.
    The result is customized according to the type system semantics, according to AnnotatedTypeFactory.postAsMemberOf( AnnotatedTypeMirror, AnnotatedTypeMirror, Element).
    Note that this method does not currently return (top level) captured types for type parameters, parameters, and return types. Instead, the original wildcard is returned, or sometimes inferring type arguments will create a wildcard type which is returned. The bounds of an inferred wildcard may itself have captures.
    To prevent unsoundness, the rest of the checker framework must expect wildcard in places where captures should appear (like type arguments). This should just involve the bounds of the wildcard where the bounds of the capture would have been used.
    
    Parameters:
    
    t - a type
    
    elem - an element
  - getIteratedType
```
public static AnnotatedTypeMirror getIteratedType(ProcessingEnvironment processingEnv,
                                                  AnnotatedTypeFactory atypeFactory,
                                                  AnnotatedTypeMirror iterableType)
```
    Returns the iterated type of the passed iterable type, and throws IllegalArgumentException if the passed type is not iterable.
    The iterated type is the component type of an array, and the type argument of Iterable for declared types.
    
    Parameters:
    
    iterableType - the iterable type (either array or declared)
    
    Returns:
    
    the types of elements in the iterable type
  - getSuperTypes
```
public static Set<AnnotatedTypeMirror.AnnotatedDeclaredType> getSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type)
```
    Returns all the super types of the given declared type.
    
    Parameters:
    
    type - a declared type
    
    Returns:
    
    all the supertypes of the given type
  - overriddenMethods
```
public static Map<AnnotatedTypeMirror.AnnotatedDeclaredType,ExecutableElement> overriddenMethods(Elements elements,
                                                                                                 AnnotatedTypeFactory atypeFactory,
                                                                                                 ExecutableElement method)
```
    A utility method that takes a Method element and returns a set of all elements that this method overrides (as ExecutableElements).
    
    Parameters:
    
    method - the overriding method
    
    Returns:
    
    an unmodifiable set of ExecutableElements representing the elements that method overrides
  - overriddenMethods
```
public static Map<AnnotatedTypeMirror.AnnotatedDeclaredType,ExecutableElement> overriddenMethods(Elements elements,
                                                                                                 ExecutableElement method,
                                                                                                 Collection<AnnotatedTypeMirror.AnnotatedDeclaredType> supertypes)
```
    A utility method that takes the element for a method and the set of all supertypes of the method's containing class and returns the set of all elements that method overrides (as ExecutableElements).
    
    Parameters:
    
    method - the overriding method
    
    supertypes - the set of supertypes to check for methods that are overridden by method
    
    Returns:
    
    an unmodified set of ExecutableElements representing the elements that method overrides among supertypes
  - findTypeArguments
```
public static Map<TypeVariable,AnnotatedTypeMirror> findTypeArguments(ProcessingEnvironment processingEnv,
                                                                      AnnotatedTypeFactory atypeFactory,
                                                                      ExpressionTree expr,
                                                                      ExecutableElement elt,
                                                                      AnnotatedTypeMirror.AnnotatedExecutableType preType)
```
    Given a method or constructor invocation, return a mapping of the type variables to their type arguments, if any exist.
    It uses the method or constructor invocation type arguments if they were specified and otherwise it infers them based on the passed arguments or the return type context, according to JLS 15.12.2.
    
    Parameters:
    
    atypeFactory - the annotated type factory
    
    expr - the method or constructor invocation tree; the passed argument has to be a subtype of MethodInvocationTree or NewClassTree
    
    elt - the element corresponding to the tree
    
    preType - the (partially annotated) type corresponding to the tree - the result of AnnotatedTypes.asMemberOf with the receiver and elt.
    
    Returns:
    
    the mapping of the type variables to type arguments for this method or constructor invocation
  - leastUpperBound
```
public static AnnotatedTypeMirror leastUpperBound(AnnotatedTypeFactory atypeFactory,
                                                  AnnotatedTypeMirror type1,
                                                  AnnotatedTypeMirror type2)
```
    Returns the lub of two annotated types.
    
    Parameters:
    
    atypeFactory - AnnotatedTypeFactory
    
    type1 - annotated type
    
    type2 - annotated type
    
    Returns:
    
    the lub of type1 and type2
  - leastUpperBound
```
public static AnnotatedTypeMirror leastUpperBound(AnnotatedTypeFactory atypeFactory,
                                                  AnnotatedTypeMirror type1,
                                                  AnnotatedTypeMirror type2,
                                                  TypeMirror lubTypeMirror)
```
    Returns the lub, whose underlying type is lubTypeMirror of two annotated types.
    
    Parameters:
    
    atypeFactory - AnnotatedTypeFactory
    
    type1 - annotated type whose underlying type must be a subtype or convertible to lubTypeMirror
    
    type2 - annotated type whose underlying type must be a subtype or convertible to lubTypeMirror
    
    lubTypeMirror - underlying type of the returned lub
    
    Returns:
    
    the lub of type1 and type2 with underlying type lubTypeMirror
  - expandVarArgs
```
public static List<AnnotatedTypeMirror> expandVarArgs(AnnotatedTypeFactory atypeFactory,
                                                      AnnotatedTypeMirror.AnnotatedExecutableType method,
                                                      List<? extends ExpressionTree> args)
```
    Returns the method parameters for the invoked method, with the same number of arguments passed in the methodInvocation tree.
    If the invoked method is not a vararg method or it is a vararg method but the invocation passes an array to the vararg parameter, it would simply return the method parameters.
    Otherwise, it would return the list of parameters as if the vararg is expanded to match the size of the passed arguments.
    
    Parameters:
    
    method - the method's type
    
    args - the arguments to the method invocation
    
    Returns:
    
    the types that the method invocation arguments need to be subtype of
  - expandVarArgsFromTypes
```
public static List<AnnotatedTypeMirror> expandVarArgsFromTypes(AnnotatedTypeMirror.AnnotatedExecutableType method,
                                                               List<AnnotatedTypeMirror> args)
```
  - getAnnotatedTypeMirrorOfParameter
```
public static AnnotatedTypeMirror getAnnotatedTypeMirrorOfParameter(AnnotatedTypeMirror.AnnotatedExecutableType methodType,
                                                                    int index)
```
    Given an AnnotatedExecutableType of a method or constructor declaration, get the parameter type expect at the indexth position (unwrapping var args if necessary).
    
    Parameters:
    
    methodType - AnnotatedExecutableType of method or constructor containing parameter to return
    
    index - position of parameter type to return
    
    Returns:
    
    if that parameter is a varArgs, return the component of the var args and NOT the array type. Otherwise, return the exact type of the parameter in the index position.
  - getAnnotatedTypes
```
public static List<AnnotatedTypeMirror> getAnnotatedTypes(AnnotatedTypeFactory atypeFactory,
                                                          List<AnnotatedTypeMirror> paramTypes,
                                                          List<? extends ExpressionTree> trees)
```
    Return a list of the AnnotatedTypeMirror of the passed expression trees, in the same order as the trees.
    
    Parameters:
    
    paramTypes - the parameter types to use as assignment context
    
    trees - the AST nodes
    
    Returns:
    
    a list with the AnnotatedTypeMirror of each tree in trees
  - getArrayDepth
```
public static int getArrayDepth(AnnotatedTypeMirror.AnnotatedArrayType array)
```
    Returns the depth of the array type of the provided array.
    
    Parameters:
    
    array - the type of the array
    
    Returns:
    
    the depth of the provided array
  - innerMostType
```
public static AnnotatedTypeMirror innerMostType(AnnotatedTypeMirror t)
```
  - containsModifier
```
public static boolean containsModifier(AnnotatedTypeMirror type,
                                       AnnotationMirror modifier)
```
    Checks whether type contains the given modifier, also recursively in type arguments and arrays. This method might be easier to implement directly as instance method in AnnotatedTypeMirror; it corresponds to a "deep" version of AnnotatedTypeMirror.hasAnnotation(AnnotationMirror).
    
    Parameters:
    
    type - the type to search
    
    modifier - the modifier to search for
    
    Returns:
    
    whether the type contains the modifier
  - isTypeAnnotation
```
public static boolean isTypeAnnotation(AnnotationMirror anno,
                                       Class<?> cls)
```
  - hasTypeQualifierElementTypes
```
public static boolean hasTypeQualifierElementTypes(ElementType[] elements,
                                                   Class<?> cls)
```
    Returns true if the given array contains ElementType.TYPE_USE, false otherwise.
    
    Parameters:
    
    elements - an array of ElementType values
    
    cls - the annotation class being tested; used for diagnostic messages only
    
    Returns:
    
    true iff the give array contains ElementType.TYPE_USE
    
    Throws:
    
    RuntimeException - if the array contains both ElementType.TYPE_USE and something besides ElementType.TYPE_PARAMETER
  - isJavaLangAnnotation
```
public static boolean isJavaLangAnnotation(AnnotatedTypeMirror atm)
```
    Returns:
    
    true if the underlying type of this atm is a java.lang.annotation.Annotation
  - implementsAnnotation
```
public static boolean implementsAnnotation(AnnotatedTypeMirror atm)
```
    Returns:
    
    true if atm is an Annotation interface, i.e. an implementation of java.lang.annotation.Annotation e.g. @interface MyAnno - implementsAnnotation would return true when called on an AnnotatedDeclaredType representing a use of MyAnno
  - isEnum
```
public static boolean isEnum(AnnotatedTypeMirror typeMirror)
```
  - isDeclarationOfJavaLangEnum
```
public static boolean isDeclarationOfJavaLangEnum(Types types,
                                                  Elements elements,
                                                  AnnotatedTypeMirror typeMirror)
```
  - haveSameDeclaration
```
public static boolean haveSameDeclaration(Types types,
                                          AnnotatedTypeMirror.AnnotatedTypeVariable typeVar1,
                                          AnnotatedTypeMirror.AnnotatedTypeVariable typeVar2)
```
    Returns:
    
    true if the typeVar1 and typeVar2 are two uses of the same type variable
  - areCorrespondingTypeVariables
```
public static boolean areCorrespondingTypeVariables(Elements elements,
                                                    AnnotatedTypeMirror.AnnotatedTypeVariable type1,
                                                    AnnotatedTypeMirror.AnnotatedTypeVariable type2)
```
    When overriding a method, you must include the same number of type parameters as the base method. By index, these parameters are considered equivalent to the type parameters of the overridden method. Necessary conditions: Both type variables are defined in methods One of the two methods overrides the other Within their method declaration, both types have the same type parameter index
    
    Returns:
    
    returns true if type1 and type2 are corresponding type variables (that is, either one "overrides" the other)
  - findEffectiveAnnotationInHierarchy
```
public static AnnotationMirror findEffectiveAnnotationInHierarchy(QualifierHierarchy qualifierHierarchy,
                                                                  AnnotatedTypeMirror toSearch,
                                                                  AnnotationMirror top)
```
    When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds. This method traverses the bounds until it finds a concrete type from which it can pull an annotation.
    
    Parameters:
    
    top - the top of the hierarchy for which you are searching
    
    Returns:
    
    the AnnotationMirror that represents the type of toSearch in the hierarchy of top
  - findEffectiveAnnotationInHierarchy
```
public static AnnotationMirror findEffectiveAnnotationInHierarchy(QualifierHierarchy qualifierHierarchy,
                                                                  AnnotatedTypeMirror toSearch,
                                                                  AnnotationMirror top,
                                                                  boolean canBeEmpty)
```
    When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds. This method traverses the bounds until it finds a concrete type from which it can pull an annotation.
    
    Parameters:
    
    top - the top of the hierarchy for which you are searching
    
    canBeEmpty - whether or not the effective type can have NO annotation in the hierarchy specified by top If this param is false, an exception will be thrown if no annotation is found Otherwise the result is null
    
    Returns:
    
    the AnnotationMirror that represents the type of toSearch in the hierarchy of top
  - findEffectiveLowerBoundAnnotations
```
public static Set<AnnotationMirror> findEffectiveLowerBoundAnnotations(QualifierHierarchy qualifierHierarchy,
                                                                       AnnotatedTypeMirror toSearch)
```
    When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds. This method traverses the lower bounds until it finds a concrete type from which it can pull an annotation. This occurs for every hierarchy in QualifierHierarchy
    
    Returns:
    
    the set of effective annotation mirrors in all hierarchies
  - findEffectiveAnnotations
```
public static Set<AnnotationMirror> findEffectiveAnnotations(QualifierHierarchy qualifierHierarchy,
                                                             AnnotatedTypeMirror toSearch)
```
    When comparing types against the bounds of a type variable, we may encounter other type variables, wildcards, and intersections in those bounds. This method traverses the bounds until it finds a concrete type from which it can pull an annotation. This occurs for every hierarchy in QualifierHierarchy
    
    Returns:
    
    the set of effective annotation mirrors in all hierarchies
  - glbOfBounds
```
public static Set<AnnotationMirror> glbOfBounds(AnnotatedTypeMirror.AnnotatedIntersectionType isect,
                                                QualifierHierarchy qualifierHierarchy)
```
    Gets the lowest primary annotation of all bounds in the intersection.
    
    Parameters:
    
    isect - the intersection for which we are glbing bounds
    
    qualifierHierarchy - the qualifier used to get the hierarchies in which to glb
    
    Returns:
    
    a set of annotations representing the glb of the intersection's bounds
  - isExplicitlySuperBounded
```
public static boolean isExplicitlySuperBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)
```
  - isExplicitlyExtendsBounded
```
public static boolean isExplicitlyExtendsBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)
```
    Returns true if wildcard type was explicitly unbounded.
  - isUnboundedOrSuperBounded
```
public static boolean isUnboundedOrSuperBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)
```
    Returns true if this type is super bounded or unbounded.
  - isUnboundedOrExtendsBounded
```
public static boolean isUnboundedOrExtendsBounded(AnnotatedTypeMirror.AnnotatedWildcardType wildcardType)
```
    Returns true if this type is extends bounded or unbounded.
  - copyOnlyExplicitConstructorAnnotations
```
public static void copyOnlyExplicitConstructorAnnotations(AnnotatedTypeFactory atypeFactory,
                                                          AnnotatedTypeMirror.AnnotatedDeclaredType returnType,
                                                          AnnotatedTypeMirror.AnnotatedExecutableType constructor)
```
    Copies explicit annotations and annotations resulting from resolution of polymorphic qualifiers from constructor to returnType. If returnType has an annotation in the same hierarchy of an annotation to be copied, that annotation is not copied.
    
    Parameters:
    
    atypeFactory - type factory
    
    returnType - return type to copy annotations to
    
    constructor - the ATM for the constructor

Class AnnotatedTypes

Method Summary

Methods inherited from class java.lang.Object

Method Detail

asSuper

castedAsSuper

hasNoExplicitBound

hasExplicitSuperBound

hasExplicitExtendsBound

asMemberOf

asMemberOf

getIteratedType

getSuperTypes

overriddenMethods

overriddenMethods

findTypeArguments

leastUpperBound

leastUpperBound

expandVarArgs

expandVarArgsFromTypes

getAnnotatedTypeMirrorOfParameter

getAnnotatedTypes

getArrayDepth

innerMostType

containsModifier

isTypeAnnotation

hasTypeQualifierElementTypes

isJavaLangAnnotation

implementsAnnotation

isEnum

isDeclarationOfJavaLangEnum

haveSameDeclaration

areCorrespondingTypeVariables

findEffectiveAnnotationInHierarchy

findEffectiveAnnotationInHierarchy

findEffectiveLowerBoundAnnotations

findEffectiveAnnotations

glbOfBounds

isExplicitlySuperBounded

isExplicitlyExtendsBounded

isUnboundedOrSuperBounded

isUnboundedOrExtendsBounded

copyOnlyExplicitConstructorAnnotations