AnnotatedTypeMirror

@NonNull java.lang.Object
- checkers.types.AnnotatedTypeMirror

Direct Known Subclasses:

AnnotatedTypeMirror.AnnotatedArrayType, AnnotatedTypeMirror.AnnotatedDeclaredType, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedNoType, AnnotatedTypeMirror.AnnotatedNullType, AnnotatedTypeMirror.AnnotatedPrimitiveType, AnnotatedTypeMirror.AnnotatedTypeVariable, AnnotatedTypeMirror.AnnotatedWildcardType
```
public abstract class AnnotatedTypeMirror
extends @NonNull Object
```
Represents an annotated type in the Java programming language. Types include primitive types, declared types (class and interface types), array types, type variables, and the null type. Also represented are wildcard type arguments, the signature and return types of executables, and pseudo-types corresponding to packages and to the keyword void.
Types should be compared using the utility methods in AnnotatedTypes. There is no guarantee that any particular type will always be represented by the same object.
To implement operations based on the class of an AnnotatedTypeMirror object, either use a visitor or use the result of the getKind() method.

Since:

1.6

See Also:
TypeMirror

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`AnnotatedTypeMirror.AnnotatedArrayType` Represents Array types in java.
`static class`	`AnnotatedTypeMirror.AnnotatedDeclaredType` Represents a declared type (whether class or interface).
`static class`	`AnnotatedTypeMirror.AnnotatedExecutableType` Represents a type of an executable.
`static class`	`AnnotatedTypeMirror.AnnotatedNoType` A pseudo-type used where no actual type is appropriate.
`static class`	`AnnotatedTypeMirror.AnnotatedNullType` Represents the null type.
`static class`	`AnnotatedTypeMirror.AnnotatedPrimitiveType` Represents a primitive type.
`static interface`	`AnnotatedTypeMirror.AnnotatedReferenceType`
`static class`	`AnnotatedTypeMirror.AnnotatedTypeVariable` Represents a type variable.
`static class`	`AnnotatedTypeMirror.AnnotatedWildcardType` Represents a wildcard type argument.

Field Summary

Fields
Modifier and Type	Field and Description
`protected TypeMirror`	`actualType` Actual type wrapped with this AnnotatedTypeMirror
`protected AnnotationUtils`	`annotationFactory` The factory to use for lazily creating annotations.
`protected Set<@Nullable AnnotationMirror>`	`annotations` The annotations on this type.
`protected @Nullable Element`	`element` the Element associated with this instance value, if one exists
`protected @Mutable AnnotatedTypeMirror`	`enclosingType` The enclosing Type
`protected ProcessingEnvironment`	`env` Processing Environment of the current round
`protected AnnotatedTypeFactory`	`typeFactory` The factory to use for lazily creating annotated types.
`int`	`uid`

Method Summary

Methods
Modifier and Type	Method and Description
`abstract <R extends @NonNull Object,P extends @NonNull Object> R`	`accept(AnnotatedTypeVisitor<R,P> v, P p)` Applies a visitor to this type.
`void`	`addAnnotation(@Nullable AnnotationMirror a)` Adds an annotation to this type.
`void`	`addAnnotation(Class<? extends Annotation> a)` Adds an annotation to this type.
`void`	`addAnnotations(Iterable<? extends @Nullable AnnotationMirror> annotations)` Adds multiple annotations to this type.
`void`	`clearAnnotations()` Removes all annotations on this type.
`protected @Mutable AnnotatedTypeMirror`	`copyFields(@Mutable AnnotatedTypeMirror type, boolean annotation)` Copy the fields on this type onto the passed type.
`static @Mutable AnnotatedTypeMirror`	`createType(TypeMirror type, ProcessingEnvironment env, AnnotatedTypeFactory typeFactory)` Creates the appropriate AnnotatedTypeMirror specific wrapper for the provided type
`protected static AnnotatedTypeMirror.AnnotatedDeclaredType`	`createTypeOfObject(AnnotatedTypeFactory typeFactory)`
`List<? extends @Mutable AnnotatedTypeMirror>`	`directSuperTypes()`
`protected List<AnnotatedTypeMirror.AnnotatedDeclaredType>`	`directSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type)`
`boolean`	`equals(@NonNull Object o)`
`protected static @ReadOnly String`	`formatAnnotationString(ProcessingEnvironment env, Collection<? extends @Nullable AnnotationMirror> lst, boolean printInvisible)`
`@Nullable AnnotationMirror`	`getAnnotation(Class<? extends Annotation> anno)` Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
`@Nullable AnnotationMirror`	`getAnnotation(@Nullable Name annotationName)` Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
`@Nullable AnnotationMirror`	`getAnnotation(@ReadOnly String annotationName)` Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
`@Nullable AnnotationMirror`	`getAnnotationInHierarchy(@Nullable AnnotationMirror p)` Returns an annotation from the given sub-hierarchy, if such an annotation targets this type; otherwise returns null.
`Set<@Nullable AnnotationMirror>`	`getAnnotations()` Returns the annotations on this type.
`abstract @Mutable AnnotatedTypeMirror`	`getCopy(boolean copyAnnotations)` Returns a shallow copy of this type.
`Set<@Nullable AnnotationMirror>`	`getEffectiveAnnotations()` Returns the "effective" annotations on this type, i.e.
`@Nullable Element`	`getElement()` Returns the element associated with the value the type represent, if any.
`@Mutable AnnotatedTypeMirror`	`getEnclosingType()` Returns the enclosing type, as in the type of `A` in the type `A.B`.
`@Mutable AnnotatedTypeMirror`	`getErased()` Returns the erasure type of the this type, according to JLS specifications.
`Set<@Nullable AnnotationMirror>`	`getExplicitAnnotations()` Returns the set of explicitly written annotations supported by this checker.
`TypeKind`	`getKind()` Returns the `kind` of this type
`TypeMirror`	`getUnderlyingType()` Returns the underlying unannotated Java type, which this wraps
`boolean`	`hasAnnotation(@Nullable AnnotationMirror a)` Determines whether this type contains the given annotation.
`boolean`	`hasAnnotation(Class<? extends Annotation> a)` Determines whether this type contains an annotation with the same annotation type as a particular annotation.
`boolean`	`hasAnnotationRelaxed(@Nullable AnnotationMirror a)` Determines whether this type contains an annotation with the same annotation type as a particular annotation.
`boolean`	`hasEffectiveAnnotation(@Nullable AnnotationMirror a)` A version of hasAnnotation that considers annotations on the upper bound of wildcards and type variables.
`boolean`	`hasEffectiveAnnotationRelaxed(@Nullable AnnotationMirror a)` A version of hasAnnotationRelaxed that considers annotations on the upper bound of wildcards and type variables.
`boolean`	`hasExplicitAnnotation(@Nullable AnnotationMirror a)` Determines whether this type contains the given annotation explicitly written at declaration.
`boolean`	`hasExplicitAnnotation(Class<? extends Annotation> a)` Determines whether this type contains an explictly written annotation with the same annotation type as a particular annotation.
`boolean`	`hasExplicitAnnotationRelaxed(@Nullable AnnotationMirror a)` A version of hasAnnotationRelaxed that only considers annotations that are explicitly written on the type.
`int`	`hashCode()`
`boolean`	`isAnnotated()` Returns true if an annotation targets this type location.
`boolean`	`isAnnotatedInHierarchy(@Nullable AnnotationMirror p)` Returns true if an annotation from the given sub-hierarchy targets this type.
`static boolean`	`isUnqualified(@Nullable AnnotationMirror anno)`
`boolean`	`removeAnnotation(@Nullable AnnotationMirror a)` Removes an annotation from the type.
`boolean`	`removeAnnotation(Class<? extends Annotation> a)`
`boolean`	`removeAnnotationInHierarchy(@Nullable AnnotationMirror a)` Remove any annotation that is in the same qualifier hierarchy as the parameter.
`boolean`	`removeAnnotations(Iterable<? extends @Nullable AnnotationMirror> annotations)` Removes multiple annotations from the type.
`void`	`removeUnqualified()` Remove an Unqualified annotation if it exists.
`void`	`replaceAnnotation(@Nullable AnnotationMirror a)` Adds an annotation to this type, removing any existing annotation from the same qualifier hierarchy first.
`void`	`replaceAnnotations(Iterable<? extends @Nullable AnnotationMirror> replAnnos)` Adds multiple annotations to this type, removing any existing annotations from the same qualifier hierarchy first.
`@Mutable AnnotatedTypeMirror`	`substitute(Map<? extends @Mutable AnnotatedTypeMirror,? extends @Mutable AnnotatedTypeMirror> mappings)` Return a copy of this, with the given substitutions performed.
`@ReadOnly String`	`toString()`
`@ReadOnly String`	`toString(boolean invisible)` A version of toString() that optionally outputs all type qualifiers, including @InvisibleQualifier's.
`@ReadOnly String`	`toStringDebug()`

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

- Field Detail
  - env
```
protected final ProcessingEnvironment env
```
    Processing Environment of the current round
  - annotationFactory
```
protected final AnnotationUtils annotationFactory
```
    The factory to use for lazily creating annotations.
  - typeFactory
```
protected final AnnotatedTypeFactory typeFactory
```
    The factory to use for lazily creating annotated types.
  - actualType
```
protected final TypeMirror actualType
```
    Actual type wrapped with this AnnotatedTypeMirror
  - element
```
protected @Nullable Element element
```
    the Element associated with this instance value, if one exists
  - enclosingType
```
protected @Mutable AnnotatedTypeMirror enclosingType
```
    The enclosing Type
  - annotations
```
protected final Set<@Nullable AnnotationMirror> annotations
```
    The annotations on this type.
  - uid
```
public int uid
```
- Method Detail
  - createType
```
public static @Mutable AnnotatedTypeMirror createType(TypeMirror type,
                                      ProcessingEnvironment env,
                                      AnnotatedTypeFactory typeFactory)
```
    Creates the appropriate AnnotatedTypeMirror specific wrapper for the provided type
    
    Parameters:
    type -
    env -
    typeFactory -
    
    Returns:
    [to document]
  - directSuperTypes
```
public List<? extends @Mutable AnnotatedTypeMirror> directSuperTypes()
```
  - equals
```
public boolean equals(@NonNull Object o)
```
    Overrides:
    
    equals in class @NonNull Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class @NonNull Object
  - accept
```
public abstract <R extends @NonNull Object,P extends @NonNull Object> R accept(AnnotatedTypeVisitor<R,P> v,
                                                             P p)
```
    Applies a visitor to this type.
    
    Type Parameters:
    R - the return type of the visitor's methods
    P - the type of the additional parameter to the visitor's methods
    Parameters:
    v - the visitor operating on this type
    p - additional parameter to the visitor
    
    Returns:
    a visitor-specified result
  - getKind
```
public TypeKind getKind()
```
    Returns the kind of this type
    
    Returns:
    the kind of this type
  - getUnderlyingType
```
public TypeMirror getUnderlyingType()
```
    Returns the underlying unannotated Java type, which this wraps
    
    Returns:
    the underlying type
  - getEnclosingType
```
public @Mutable AnnotatedTypeMirror getEnclosingType()
```
    Returns the enclosing type, as in the type of A in the type A.B.
    
    Returns:
    enclosingType the enclosing type
  - isAnnotated
```
public boolean isAnnotated()
```
    Returns true if an annotation targets this type location. It doesn't account for annotations in deep types (type arguments, array components, etc).
  - isAnnotatedInHierarchy
```
public boolean isAnnotatedInHierarchy(@Nullable AnnotationMirror p)
```
    Returns true if an annotation from the given sub-hierarchy targets this type. It doesn't account for annotations in deep types (type arguments, array components, etc).
    
    Parameters:
    p - The qualifier hierarchy to check for.
    
    Returns:
    True iff an annotation from the same hierarchy as p is present.
  - getAnnotationInHierarchy
```
public @Nullable AnnotationMirror getAnnotationInHierarchy(@Nullable AnnotationMirror p)
```
    Returns an annotation from the given sub-hierarchy, if such an annotation targets this type; otherwise returns null. It doesn't account for annotations in deep types (type arguments, array components, etc).
    
    Parameters:
    p - The qualifier hierarchy to check for.
    
    Returns:
    An annotation from the same hierarchy as p if present.
  - getAnnotations
```
public Set<@Nullable AnnotationMirror> getAnnotations()
```
    Returns the annotations on this type. It does not include annotations in deep types (type arguments, array components, etc).
    
    Returns:
    a set of the annotations on this
  - getEffectiveAnnotations
```
public Set<@Nullable AnnotationMirror> getEffectiveAnnotations()
```
    Returns the "effective" annotations on this type, i.e. the annotations on the type itself, or on the upper/extends bound of a type variable/wildcard.
    
    Returns:
    a set of the annotations on this
  - getAnnotation
```
public @Nullable AnnotationMirror getAnnotation(@ReadOnly String annotationName)
```
    Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
    
    Parameters:
    annotationName -
    
    Returns:
    the annotation mirror for annotationName
  - getAnnotation
```
public @Nullable AnnotationMirror getAnnotation(@Nullable Name annotationName)
```
    Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
    
    Parameters:
    annotationName -
    
    Returns:
    the annotation mirror for annotationName
  - getAnnotation
```
public @Nullable AnnotationMirror getAnnotation(Class<? extends Annotation> anno)
```
    Returns the actual annotation mirror used to annotate this type, whose name equals the passed annotationName if one exists, null otherwise.
    
    Parameters:
    anno - annotation class
    
    Returns:
    the annotation mirror for anno
  - getExplicitAnnotations
```
public Set<@Nullable AnnotationMirror> getExplicitAnnotations()
```
    Returns the set of explicitly written annotations supported by this checker. This is useful to check the validity of annotations explicitly present on a type, as flow inference might add annotations that were not previously present.
    
    Returns:
    The set of explicitly written annotations supported by this checker.
  - hasAnnotation
```
public boolean hasAnnotation(@Nullable AnnotationMirror a)
```
    Determines whether this type contains the given annotation. This method considers the annotation's values, that is, if the type is "@A("s") @B(3) Object" a call with "@A("t") or "@A" will return false, whereas a call with "@B(3)" will return true. In contrast to hasAnnotationRelaxed(AnnotationMirror) this method also compares annotation values.
    
    Parameters:
    a - the annotation to check for
    
    Returns:
    true iff the type contains the annotation a
    See Also:
    hasAnnotationRelaxed(AnnotationMirror)
  - hasEffectiveAnnotation
```
public boolean hasEffectiveAnnotation(@Nullable AnnotationMirror a)
```
    A version of hasAnnotation that considers annotations on the upper bound of wildcards and type variables.
    
    See Also:
    hasAnnotation(AnnotationMirror)
  - hasExplicitAnnotation
```
public boolean hasExplicitAnnotation(@Nullable AnnotationMirror a)
```
    Determines whether this type contains the given annotation explicitly written at declaration. This method considers the annotation's values, that is, if the type is "@A("s") @B(3) Object" a call with "@A("t") or "@A" will return false, whereas a call with "@B(3)" will return true. In contrast to hasExplicitAnnotationRelaxed(AnnotationMirror) this method also compares annotation values.
    
    Parameters:
    a - the annotation to check for
    
    Returns:
    true iff the annotation a is explicitly written on the type
    See Also:
    hasExplicitAnnotationRelaxed(AnnotationMirror)
  - hasAnnotationRelaxed
```
public boolean hasAnnotationRelaxed(@Nullable AnnotationMirror a)
```
    Determines whether this type contains an annotation with the same annotation type as a particular annotation. This method does not consider an annotation's values, that is, if the type is "@A("s") @B(3) Object" a call with "@A("t"), "@A", or "@B" will return true.
    
    Parameters:
    a - the annotation to check for
    
    Returns:
    true iff the type contains an annotation with the same type as the annotation given by a
    See Also:
    hasAnnotation(AnnotationMirror)
  - hasEffectiveAnnotationRelaxed
```
public boolean hasEffectiveAnnotationRelaxed(@Nullable AnnotationMirror a)
```
    A version of hasAnnotationRelaxed that considers annotations on the upper bound of wildcards and type variables.
    
    See Also:
    hasAnnotationRelaxed(AnnotationMirror)
  - hasExplicitAnnotationRelaxed
```
public boolean hasExplicitAnnotationRelaxed(@Nullable AnnotationMirror a)
```
    A version of hasAnnotationRelaxed that only considers annotations that are explicitly written on the type.
    
    See Also:
    hasAnnotationRelaxed(AnnotationMirror)
  - hasAnnotation
```
public boolean hasAnnotation(Class<? extends Annotation> a)
```
    Determines whether this type contains an annotation with the same annotation type as a particular annotation. This method does not consider an annotation's values.
    
    Parameters:
    a - the class of annotation to check for
    
    Returns:
    true iff the type contains an annotation with the same type as the annotation given by a
  - hasExplicitAnnotation
```
public boolean hasExplicitAnnotation(Class<? extends Annotation> a)
```
    Determines whether this type contains an explictly written annotation with the same annotation type as a particular annotation. This method does not consider an annotation's values.
    
    Parameters:
    a - the class of annotation to check for
    
    Returns:
    true iff the type contains an explicitly written annotation with the same type as the annotation given by a
  - addAnnotation
```
public void addAnnotation(@Nullable AnnotationMirror a)
```
    Adds an annotation to this type. If the annotation does not have the TypeQualifier meta-annotation, this method has no effect.
    
    Parameters:
    a - the annotation to add
  - replaceAnnotation
```
public void replaceAnnotation(@Nullable AnnotationMirror a)
```
    Adds an annotation to this type, removing any existing annotation from the same qualifier hierarchy first.
    
    Parameters:
    a - the annotation to add
  - addAnnotation
```
public void addAnnotation(Class<? extends Annotation> a)
```
    Adds an annotation to this type. If the annotation does not have the TypeQualifier meta-annotation, this method has no effect.
    
    Parameters:
    a - the class of the annotation to add
  - addAnnotations
```
public void addAnnotations(Iterable<? extends @Nullable AnnotationMirror> annotations)
```
    Adds multiple annotations to this type.
    
    Parameters:
    annotations - the annotations to add
  - replaceAnnotations
```
public void replaceAnnotations(Iterable<? extends @Nullable AnnotationMirror> replAnnos)
```
    Adds multiple annotations to this type, removing any existing annotations from the same qualifier hierarchy first.
    
    Parameters:
    replAnnos - the annotations to replace
  - removeAnnotation
```
public boolean removeAnnotation(@Nullable AnnotationMirror a)
```
    Removes an annotation from the type.
    
    Parameters:
    a - the annotation to remove
    
    Returns:
    true if the annotation was removed, false if the type's annotations were unchanged
  - removeAnnotation
```
public boolean removeAnnotation(Class<? extends Annotation> a)
```
  - removeAnnotationInHierarchy
```
public boolean removeAnnotationInHierarchy(@Nullable AnnotationMirror a)
```
    Remove any annotation that is in the same qualifier hierarchy as the parameter.
    
    Parameters:
    a - An annotation from the same qualifier hierarchy
    
    Returns:
    If an annotation was removed
  - removeUnqualified
```
public void removeUnqualified()
```
    Remove an Unqualified annotation if it exists. This might be a good thing to do before adding a new annotation to a type.
  - removeAnnotations
```
public boolean removeAnnotations(Iterable<? extends @Nullable AnnotationMirror> annotations)
```
    Removes multiple annotations from the type.
    
    Parameters:
    annotations - the annotations to remove
    
    Returns:
    true if at least one annotation was removed, false if the type's annotations were unchanged
  - clearAnnotations
```
public void clearAnnotations()
```
    Removes all annotations on this type. Make sure to add an annotation again, e.g. Unqualified.
  - isUnqualified
```
public static boolean isUnqualified(@Nullable AnnotationMirror anno)
```
  - formatAnnotationString
```
protected static final @ReadOnly String formatAnnotationString(ProcessingEnvironment env,
                                      Collection<? extends @Nullable AnnotationMirror> lst,
                                      boolean printInvisible)
```
  - toString
```
public final @ReadOnly String toString()
```
    Overrides:
    
    toString in class @NonNull Object
  - toString
```
public @ReadOnly String toString(boolean invisible)
```
    A version of toString() that optionally outputs all type qualifiers, including @InvisibleQualifier's.
    
    Parameters:
    invisible - Whether to always output invisible qualifiers.
    
    Returns:
    A string representation of the current type containing all qualifiers.
  - toStringDebug
```
public @ReadOnly String toStringDebug()
```
  - getElement
```
public @Nullable Element getElement()
```
    Returns the element associated with the value the type represent, if any. I.e. For 'Integer i;' the element would be for 'i' not 'Integer'
    
    Returns:
    the Element of the value of this type, if one exists
  - getErased
```
public @Mutable AnnotatedTypeMirror getErased()
```
    Returns the erasure type of the this type, according to JLS specifications.
    
    Returns:
    the erasure of this
  - copyFields
```
protected @Mutable AnnotatedTypeMirror copyFields(@Mutable AnnotatedTypeMirror type,
                                      boolean annotation)
```
    Copy the fields on this type onto the passed type. This method needs to be overridden by any subclass of AnnotatedTypeMirror. TODO: None of the subtypes in this compilation unit override this method, however. Is this documentation inconsistent? Or should we add these implementations? The separation between copyFields and getCopy is unclear.
    
    Parameters:
    type - an empty type where fields of this are copied to
    annotation - whether annotations are copied or not
  - getCopy
```
public abstract @Mutable AnnotatedTypeMirror getCopy(boolean copyAnnotations)
```
    Returns a shallow copy of this type.
    
    Parameters:
    copyAnnotations - whether copy should have annotations
  - createTypeOfObject
```
protected static AnnotatedTypeMirror.AnnotatedDeclaredType createTypeOfObject(AnnotatedTypeFactory typeFactory)
```
  - substitute
```
public @Mutable AnnotatedTypeMirror substitute(Map<? extends @Mutable AnnotatedTypeMirror,? extends @Mutable AnnotatedTypeMirror> mappings)
```
    Return a copy of this, with the given substitutions performed.
    
    Parameters:
    mappings -
  - directSuperTypes
```
protected final List<AnnotatedTypeMirror.AnnotatedDeclaredType> directSuperTypes(AnnotatedTypeMirror.AnnotatedDeclaredType type)
```

Class AnnotatedTypeMirror

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

env

annotationFactory

typeFactory

actualType

element

enclosingType

annotations

uid

Method Detail

createType

directSuperTypes

equals

hashCode

accept

getKind

getUnderlyingType

getEnclosingType

isAnnotated

isAnnotatedInHierarchy

getAnnotationInHierarchy

getAnnotations

getEffectiveAnnotations

getAnnotation

getAnnotation

getAnnotation

getExplicitAnnotations

hasAnnotation

hasEffectiveAnnotation

hasExplicitAnnotation

hasAnnotationRelaxed

hasEffectiveAnnotationRelaxed

hasExplicitAnnotationRelaxed

hasAnnotation

hasExplicitAnnotation

addAnnotation

replaceAnnotation

addAnnotation

addAnnotations

replaceAnnotations

removeAnnotation

removeAnnotation

removeAnnotationInHierarchy

removeUnqualified

removeAnnotations

clearAnnotations

isUnqualified

formatAnnotationString

toString

toString

toStringDebug

getElement

getErased

copyFields

getCopy

createTypeOfObject

substitute

directSuperTypes