Package org.checkerframework.framework.type

Class AnnotatedTypeMirror

java.lang.Object
org.checkerframework.framework.type.AnnotatedTypeMirror
All Implemented Interfaces:
org.plumelib.util.DeepCopyable<AnnotatedTypeMirror>
Direct Known Subclasses:
AnnotatedTypeMirror.AnnotatedArrayType, AnnotatedTypeMirror.AnnotatedDeclaredType, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedIntersectionType, AnnotatedTypeMirror.AnnotatedNoType, AnnotatedTypeMirror.AnnotatedNullType, AnnotatedTypeMirror.AnnotatedPrimitiveType, AnnotatedTypeMirror.AnnotatedTypeVariable, AnnotatedTypeMirror.AnnotatedUnionType, AnnotatedTypeMirror.AnnotatedWildcardType
public abstract class AnnotatedTypeMirror extends Object implements org.plumelib.util.DeepCopyable<AnnotatedTypeMirror>
Represents an annotated type in the Java programming language, including:
  • standard types: primitive types, declared types (class and interface types), array types, type variables, and the null type
  • wildcard type arguments
  • executable types (their signature and return types)
  • pseudo-types corresponding to packages and to the keyword void

To implement operations based on the class of an AnnotatedTypeMirror object, either use a visitor or use the result of the getKind() method.

This class is mutable.

See Also:

  • Field Details

    • EQUALITY_COMPARER

      protected static final EqualityAtmComparer EQUALITY_COMPARER
      An EqualityAtmComparer.

    • HASHCODE_VISITOR

      protected static final HashcodeAtmVisitor HASHCODE_VISITOR
      A HashcodeAtmVisitor.

    • atypeFactory

      protected final AnnotatedTypeFactory atypeFactory
      The factory to use for lazily creating annotated types.

    • underlyingType

      protected final TypeMirror underlyingType
      The actual type wrapped by this AnnotatedTypeMirror.

    • primaryAnnotations

      protected final AnnotationMirrorSet primaryAnnotations
      The annotations on this type.

  • Method Details

    • createType

      public static AnnotatedTypeMirror createType(TypeMirror type, AnnotatedTypeFactory atypeFactory, boolean isDeclaration)
      Creates an AnnotatedTypeMirror for the provided type. The result contains no annotations.
      Parameters:
      type - the underlying type for the resulting AnnotatedTypeMirror
      atypeFactory - the type factory that will build the result
      isDeclaration - true if the result should represent a declaration, rather than a use, of a type
      Returns:
      an AnnotatedTypeMirror whose underlying type is type

    • equals

      public final boolean equals(@Nullable Object o)
      Overrides:
      equals in class Object

    • hashCode

      @Pure public final int hashCode()
      Overrides:
      hashCode in class Object

    • accept

      public abstract <R, P> 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

    • getPrimitiveKind

      public @Nullable TypeKind getPrimitiveKind()
      Given a primitive type, return its kind. Given a boxed primitive type, return the corresponding primitive type kind. Otherwise, return null.
      Returns:
      a primitive type kind if this is a primitive type or boxed primitive type; otherwise null

    • getUnderlyingType

      public TypeMirror getUnderlyingType()
      Returns the underlying unannotated Java type, which this wraps.
      Returns:
      the underlying type

    • isDeclaration

      public boolean isDeclaration()
      Returns true if this type mirror represents a declaration, rather than a use, of a type.

      For example, class List<T> { ... } declares a new type List<T>, while List<Integer> is a use of the type.

      Returns:
      true if this represents a declaration

    • asUse

      public AnnotatedTypeMirror asUse()

    • hasPrimaryAnnotationInHierarchy

      public boolean hasPrimaryAnnotationInHierarchy(AnnotationMirror annotation)
      Returns true if this type has a primary annotation in the same hierarchy as annotation.
      Parameters:
      annotation - the qualifier hierarchy to check for
      Returns:
      true iff this type has a primary annotation in the same hierarchy as annotation.

    • getPrimaryAnnotationInHierarchy

      public @Nullable AnnotationMirror getPrimaryAnnotationInHierarchy(AnnotationMirror annotation)
      Returns the primary annotation on this type that is in the same hierarchy as annotation. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, null may be returned when the upper bound may have an annotation with that class, so getEffectiveAnnotationInHierarchy(AnnotationMirror) should be called instead.
      Parameters:
      annotation - an annotation in the qualifier hierarchy to check for
      Returns:
      the annotation mirror whose class is named annoNAme or null

    • getEffectiveAnnotationInHierarchy

      public @Nullable AnnotationMirror getEffectiveAnnotationInHierarchy(AnnotationMirror annotation)
      Returns the "effective" annotation from the same hierarchy as annotation, otherwise returns null.

      An effective annotation is the annotation on the type itself, or on the upper/extends bound of a type variable/wildcard (recursively, until a class type is reached).

      Parameters:
      annotation - an annotation in the qualifier hierarchy to check for
      Returns:
      an annotation from the same hierarchy as annotation if present

    • getPrimaryAnnotations

      public final AnnotationMirrorSet getPrimaryAnnotations()
      Returns the primary annotations on this type. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, the returned annotations may be empty or missing annotations in hierarchies, so getEffectiveAnnotations() should be called instead.

      It does not include annotations in deep types (type arguments, array components, etc).

      To get the single primary annotation in a particular hierarchy, use getPrimaryAnnotationInHierarchy(javax.lang.model.element.AnnotationMirror). If there is only one hierarchy, you can use getPrimaryAnnotation().

      Returns:
      an unmodifiable set of the annotations on this

    • getPrimaryAnnotationsField

      protected final AnnotationMirrorSet getPrimaryAnnotationsField()
      Returns the annotations on this type; mutations affect this object, because the return type is an alias of the annotations field. It does not include annotations in deep types (type arguments, array components, etc).

      The returned set should not be modified, but for efficiency reasons modification is not prevented. Modifications might break invariants.

      Returns:
      the set of the annotations on this; mutations affect this object

    • getPrimaryAnnotation

      public final @Nullable AnnotationMirror getPrimaryAnnotation()
      Returns the single primary annotations on this type. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, the returned annotations may be empty or missing annotations in hierarchies, so getEffectiveAnnotation() should be called instead.

      This method requires that there is only a single hierarchy. Therefore, it is equivalent to getPrimaryAnnotationInHierarchy(javax.lang.model.element.AnnotationMirror).

      Returns:
      the annotation on this, or null if none (which can only happen if this is a type variable or wildcard)
      See Also:

    • getEffectiveAnnotations

      public AnnotationMirrorSet 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 (recursively, until a class type is reached). If this is fully-annotated, the returned set will contain one annotation per hierarchy.
      Returns:
      a set of the annotations on this

    • getEffectiveAnnotation

      public final AnnotationMirror getEffectiveAnnotation()
      Returns the single "effective" annotation on this type, i.e. the annotations on the type itself, or on the upper/extends bound of a type variable/wildcard (recursively, until a class type is reached). If this is fully-annotated, this method will not return null

      This method requires that there is only a single hierarchy. Therefore, it is equivalent to getEffectiveAnnotationInHierarchy(AnnotationMirror).

      Returns:
      a set of the annotations on this

    • getPrimaryAnnotation

      public @Nullable AnnotationMirror getPrimaryAnnotation(Class<? extends Annotation> annoClass)
      Returns the primary annotation on this type whose class is annoClass. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, null may be returned when the upper bound may have an annotation with that class, so getEffectiveAnnotation(Class) should be called instead.
      Parameters:
      annoClass - annotation class
      Returns:
      the annotation mirror whose class is annoClass or null

    • getPrimaryAnnotation

      public @Nullable AnnotationMirror getPrimaryAnnotation(String annoName)
      Returns the primary annotations on this type whose annotation class name annoName. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, null may be returned when the upper bound may have an annotation with that class, so getEffectiveAnnotation(Class) should be called instead.
      Parameters:
      annoName - annotation class name
      Returns:
      the annotation mirror whose class is named annoName or null

    • getExplicitAnnotations

      public AnnotationMirrorSet getExplicitAnnotations()
      Returns the set of explicitly written annotations on this type that are 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. Note that since AnnotatedTypeMirror instances are created for type uses, this method will return explicit annotations in type use locations but will not return explicit annotations that had an impact on defaulting, such as an explicit annotation on a class declaration. For example, given:

      @MyExplicitAnno class MyClass {}; MyClass myClassInstance;

      the result of calling atypeFactory.getAnnotatedType(variableTreeForMyClassInstance).getExplicitAnnotations()

      will not contain @MyExplicitAnno.

      Returns:
      the set of explicitly written annotations on this type that are supported by this checker

    • hasPrimaryAnnotation

      public boolean hasPrimaryAnnotation(AnnotationMirror a)
      Returns true if this type has a primary annotation that is the same as a.

      This method considers the annotation's values. If the type is @A("s") @B(3) Object, then a call with @A("t") or @A will return false, whereas a call with @B(3) will return true.

      In contrast to hasPrimaryAnnotationRelaxed(AnnotationMirror) this method also compares annotation values.

      Parameters:
      a - the annotation to check for
      Returns:
      true iff this type has a primary annotation that is the same as a
      See Also:

    • hasPrimaryAnnotation

      public boolean hasPrimaryAnnotation(Class<? extends Annotation> a)
      Returns true if this type has a primary annotation that has the same annotation type as a. 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

    • getEffectiveAnnotation

      public @Nullable AnnotationMirror getEffectiveAnnotation(Class<? extends Annotation> annoClass)
      Returns the "effective" annotation on this type with the class annoClass or null if this type does not have one.

      An effective annotation is the annotation on the type itself, or on the upper/extends bound of a type variable/wildcard (recursively, until a class type is reached).

      Parameters:
      annoClass - annotation class
      Returns:
      the effective annotation with the same class as annoClass

    • hasEffectiveAnnotation

      public boolean hasEffectiveAnnotation(Class<? extends Annotation> a)
      A version of hasPrimaryAnnotation(Class) that considers annotations on the upper bound of wildcards and type variables.

    • hasEffectiveAnnotation

      public boolean hasEffectiveAnnotation(AnnotationMirror a)
      A version of hasPrimaryAnnotation(AnnotationMirror) that considers annotations on the upper bound of wildcards and type variables.

    • hasExplicitAnnotation

      public boolean hasExplicitAnnotation(AnnotationMirror a)
      Returns true if this type contains the given annotation explicitly written at declaration. This method considers the annotation's values. 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.

      See the documentation for getExplicitAnnotations() for details on which explicit annotations are not included.

      Parameters:
      a - the annotation to check for
      Returns:
      true iff the annotation a is explicitly written on the type
      See Also:

    • hasPrimaryAnnotationRelaxed

      public boolean hasPrimaryAnnotationRelaxed(AnnotationMirror a)
      Returns true if this type has a primary annotation that has the same annotation class as a.

      This method does not consider an annotation's values. If the type is @A("s") @B(3) Object, then a call with @A("t"), @A, or @B will return true.

      Parameters:
      a - the annotation to check for
      Returns:
      true iff the type has a primary annotation with the same type as a
      See Also:

    • hasEffectiveAnnotationRelaxed

      public boolean hasEffectiveAnnotationRelaxed(AnnotationMirror a)
      A version of hasPrimaryAnnotationRelaxed(AnnotationMirror) that considers annotations on the upper bound of wildcards and type variables.

    • hasExplicitAnnotationRelaxed

      public boolean hasExplicitAnnotationRelaxed(AnnotationMirror a)
      A version of hasPrimaryAnnotationRelaxed(AnnotationMirror) that only considers annotations that are explicitly written on the type.

      See the documentation for getExplicitAnnotations() for details on which explicit annotations are not included.

    • hasExplicitAnnotation

      public boolean hasExplicitAnnotation(Class<? extends Annotation> a)
      Returns true if this type contains an explicitly written annotation with the same annotation type as a particular annotation. This method does not consider an annotation's values.

      See the documentation for getExplicitAnnotations() for details on which explicit annotations are not included.

      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
      See Also:

    • addAnnotation

      public void addAnnotation(AnnotationMirror annotation)
      Adds the canonical version of annotation as a primary annotation of this type and, in the case of AnnotatedTypeMirror.AnnotatedTypeVariables, AnnotatedTypeMirror.AnnotatedWildcardTypes, and AnnotatedTypeMirror.AnnotatedIntersectionTypes, adds it to all bounds. (The canonical version is found via AnnotatedTypeFactory.canonicalAnnotation(javax.lang.model.element.AnnotationMirror).) If the canonical version of annotation is not a supported qualifier, then no annotation is added. If this type already has annotation in the same hierarchy as annotation, the behavior of this method is undefined.
      Parameters:
      annotation - the annotation to add

    • replaceAnnotation

      public void replaceAnnotation(AnnotationMirror a)
      Adds an annotation to this type, removing any existing primary annotations from the same qualifier hierarchy first.
      Parameters:
      a - the annotation to add

    • addAnnotation

      @Deprecated public void addAnnotation(Class<? extends Annotation> a)
      Deprecated.
      This method creates a new AnnotationMirror every time it is called. Instead of calling this method, store the AnnotationMirror in a field and use addAnnotation(AnnotationMirror) instead.
      Adds an annotation to this type.
      Parameters:
      a - the class of the annotation to add

    • addAnnotations

      public void addAnnotations(Iterable<? extends AnnotationMirror> annotations)
      Adds the canonical version of all annotations as primary annotations of this type and, in the case of AnnotatedTypeMirror.AnnotatedTypeVariables, AnnotatedTypeMirror.AnnotatedWildcardTypes, and AnnotatedTypeMirror.AnnotatedIntersectionTypes, adds them to all bounds. (The canonical version is found via AnnotatedTypeFactory.canonicalAnnotation(javax.lang.model.element.AnnotationMirror).) If the canonical version of an annotation is not a supported qualifier, then that annotation is not add added. If this type already has annotation in the same hierarchy as any of the annotations, the behavior of this method is undefined.
      Parameters:
      annotations - the annotations to add

    • addMissingAnnotations

      public void addMissingAnnotations(Iterable<? extends AnnotationMirror> annotations)
      Adds only the annotations in annotations that the type does not already have a primary annotation in the same hierarchy.

      The canonical version of the annotations are added as primary annotations of this type and, in the case of AnnotatedTypeMirror.AnnotatedTypeVariables, AnnotatedTypeMirror.AnnotatedWildcardTypes, and AnnotatedTypeMirror.AnnotatedIntersectionTypes, adds them to all bounds. (The canonical version is found via AnnotatedTypeFactory.canonicalAnnotation(javax.lang.model.element.AnnotationMirror).) If the canonical version of an annotation is not a supported qualifier, then that annotation is not add added.

      Parameters:
      annotations - the annotations to add

    • addMissingAnnotation

      public void addMissingAnnotation(AnnotationMirror annotation)
      Add annotation if the type does not already have a primary annotation in the same hierarchy.

      The canonical version of the annotation is added as a primary annotation of this type and (in the case of AnnotatedTypeMirror.AnnotatedTypeVariables, AnnotatedTypeMirror.AnnotatedWildcardTypes, and AnnotatedTypeMirror.AnnotatedIntersectionTypes) added to all bounds. (The canonical version is found via AnnotatedTypeFactory.canonicalAnnotation(javax.lang.model.element.AnnotationMirror).) If the canonical version of an annotation is not a supported qualifier, then that annotation is not add added.

      Parameters:
      annotation - the annotations to add

    • replaceAnnotations

      public void replaceAnnotations(Iterable<? extends AnnotationMirror> replAnnos)
      Adds multiple annotations to this type, removing any existing primary annotations from the same qualifier hierarchy first.
      Parameters:
      replAnnos - the annotations to replace

    • removePrimaryAnnotation

      public boolean removePrimaryAnnotation(AnnotationMirror a)
      Removes a primary 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

    • removePrimaryAnnotationByClass

      public boolean removePrimaryAnnotationByClass(Class<? extends Annotation> a)
      Removes a primary annotation of the given class from the type.
      Parameters:
      a - the class of the annotation to remove
      Returns:
      true if the annotation was removed, false if the type's annotations were unchanged

    • removePrimaryAnnotationInHierarchy

      public boolean removePrimaryAnnotationInHierarchy(AnnotationMirror a)
      Remove any primary 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

    • removeNonTopAnnotationInHierarchy

      @Deprecated public boolean removeNonTopAnnotationInHierarchy(AnnotationMirror a)
      Deprecated.
      This will be removed in a future release
      Remove an annotation that is in the same qualifier hierarchy as the parameter, unless it's the top annotation.
      Parameters:
      a - an annotation from the same qualifier hierarchy
      Returns:
      if an annotation was removed

    • removePrimaryAnnotations

      public boolean removePrimaryAnnotations(Iterable<? extends AnnotationMirror> annotations)
      Removes multiple primary 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

    • clearPrimaryAnnotations

      public void clearPrimaryAnnotations()
      Removes all primary annotations on this type.

    • toString

      @SideEffectFree public final String toString()
      Overrides:
      toString in class Object

    • toString

      @SideEffectFree public final String toString(boolean verbose)

    • getErased

      public AnnotatedTypeMirror getErased()
      Returns the erasure type of this type, according to JLS specifications.
      Returns:
      the erasure of this AnnotatedTypeMirror, this is always a copy even if the erasure and the original type are equivalent
      See Also:

    • deepCopy

      public abstract AnnotatedTypeMirror deepCopy(boolean copyAnnotations)
      Returns a deep copy of this type. A deep copy implies that each component type is copied recursively and the returned type refers to those copies in its component locations.

      Note: deepCopy provides two important properties in the returned copy:

      1. Structure preservation -- The exact structure of the original AnnotatedTypeMirror is preserved in the copy including all component types.
      2. Annotation preservation -- All of the annotations from the original AnnotatedTypeMirror and its components have been copied to the new type.
      If copyAnnotations is set to false, the second property, Annotation preservation, is removed. This is useful for cases in which the user may want to copy the structure of a type exactly but NOT its annotations.
      Returns:
      a deep copy

    • deepCopy

      public abstract AnnotatedTypeMirror deepCopy()
      Returns a deep copy of this type with annotations.

      Each subclass implements this method with the subclass return type. The method body must always be a call to deepCopy(true).

      Specified by:
      deepCopy in interface org.plumelib.util.DeepCopyable<AnnotatedTypeMirror>
      Returns:
      a deep copy of this type with annotations
      See Also:

    • shallowCopy

      public abstract AnnotatedTypeMirror shallowCopy(boolean copyAnnotations)
      Returns a shallow copy of this type. A shallow copy implies that each component type in the output copy refers to the same object as the object being copied.
      Parameters:
      copyAnnotations - whether copy should have annotations, i.e. whether field annotations should be copied.

    • shallowCopy

      public abstract AnnotatedTypeMirror shallowCopy()
      Returns a shallow copy of this type with annotations.

      Each subclass implements this method with the subclass return type. The method body must always be a call to shallowCopy(true).

      Returns:
      a shallow copy of this type with annotations
      See Also:

    • containsCapturedTypes

      public boolean containsCapturedTypes()
      Whether this contains any captured type variables.
      Returns:
      whether the type contains any captured type variables

    • createTypeOfObject

      protected static AnnotatedTypeMirror.AnnotatedDeclaredType createTypeOfObject(AnnotatedTypeFactory atypeFactory)
      Create an AnnotatedTypeMirror.AnnotatedDeclaredType with the underlying type of Object. It includes any annotations placed by AnnotatedTypeFactory.fromElement(Element).
      Parameters:
      atypeFactory - type factory to use
      Returns:
      AnnotatedDeclaredType for Object

    • createTypeOfRecord

      protected static AnnotatedTypeMirror.AnnotatedDeclaredType createTypeOfRecord(AnnotatedTypeFactory atypeFactory)
      Create an AnnotatedTypeMirror.AnnotatedDeclaredType with the underlying type of java.lang.Record. It includes any annotations placed by AnnotatedTypeFactory.fromElement(Element).
      Parameters:
      atypeFactory - type factory to use
      Returns:
      AnnotatedDeclaredType for Record

    • getUnderlyingTypeHashCode

      public int getUnderlyingTypeHashCode()
      Returns the result of calling underlyingType.toString().hashcode(). This method saves the result in a field so that it isn't recomputed each time.
      Returns:
      the result of calling underlyingType.toString().hashcode()

    • directSupertypes

      public List<? extends AnnotatedTypeMirror> directSupertypes()
      This method returns a list of AnnotatedTypeMirrors where the Java type of each ATM is an immediate supertype (class or interface) of the Java type of this. The interface types, if any, appear at the end of the list. If the directSuperType has type arguments, then the annotations on those type arguments are taken with proper translation from the declaration of the Java type of this.

      For example, 

       class B<T> { ... } 
 class A extends B<@NonNull String> { ... } 
 @Nullable A a;
      The direct supertype of the ATM @Nullable A is @Nullable B<@NonNull String>.

      An example with more complex type arguments: 

       class D<Q,R> { ... } 
 class A<T,S> extends D<S,T> { ... } 
 @Nullable A<@NonNull String, @NonNull Object> a;
      The direct supertype of the ATM @Nullable A<@NonNull String, @NonNull Object> is @Nullable B<@NonNull Object, @NonNull String>.

      An example with more than one direct supertype: 

       class B<T> implements List<Integer> { ... } 
 class A extends B<@NonNull String> implements List<Integer> { ... } 
 @Nullable A a;
      The direct supertypes of the ATM @Nullable A are @Nullable B <@NonNull String> and @Nullable List<@NonNull Integer>.
      Returns:
      the immediate supertypes of this
      See Also:

    • clearAnnotations

      @Deprecated public void clearAnnotations()
      Deprecated.
      use clearPrimaryAnnotations()
      Removes all primary annotations on this type. Make sure to add an annotation after calling this method.

      This method should only be used in very specific situations. For individual type systems, it is generally better to use removePrimaryAnnotation(AnnotationMirror) and similar methods.

    • getAnnotation

      @Deprecated public final @Nullable AnnotationMirror getAnnotation()
      Deprecated.
      use getPrimaryAnnotation() ()}
      Returns the single annotation on this type. It does not include annotations in deep types (type arguments, array components, etc).

      This method requires that there is only a single hierarchy. Therefore, it is equivalent to getPrimaryAnnotationInHierarchy(javax.lang.model.element.AnnotationMirror).

      Returns:
      the annotation on this, or null if none (which can only happen if this is a type variable or wildcard)
      See Also:

    • getAnnotation

      @Deprecated public @Nullable AnnotationMirror getAnnotation(Class<? extends Annotation> annoClass)
      Deprecated.
      use getPrimaryAnnotation(Class)
      Returns the annotation mirror used to annotate this type, whose Class equals the passed annoClass if one exists, null otherwise.
      Parameters:
      annoClass - annotation class
      Returns:
      the annotation mirror for anno

    • getAnnotation

      @Deprecated public @Nullable AnnotationMirror getAnnotation(String annoName)
      Deprecated.
      use getPrimaryAnnotation(String)
      Returns the annotation mirror used to annotate this type, whose name equals the passed annoName if one exists, null otherwise.
      Parameters:
      annoName - annotation name
      Returns:
      the annotation mirror for annoName

    • getAnnotationInHierarchy

      @Deprecated public @Nullable AnnotationMirror getAnnotationInHierarchy(AnnotationMirror p)
      Deprecated.
      use getPrimaryAnnotationInHierarchy(AnnotationMirror)
      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).

      If there is only one hierarchy, you can use getPrimaryAnnotation() instead.

      May return null if the receiver is a type variable or a wildcard without a primary annotation, or if the receiver is not yet fully annotated.

      Parameters:
      p - the qualifier hierarchy to check for
      Returns:
      an annotation from the same hierarchy as p if present

    • getAnnotations

      @Deprecated public final AnnotationMirrorSet getAnnotations()
      Deprecated.
      use getPrimaryAnnotations()
      Returns the primary annotations on this type. For AnnotatedTypeMirror.AnnotatedTypeVariables and AnnotatedTypeMirror.AnnotatedWildcardTypes, the returned annotations may be empty or missing annotations in hierarchies, so getEffectiveAnnotations() should be called instead.

      It does not include annotations in deep types (type arguments, array components, etc).

      To get the single primary annotation in a particular hierarchy, use getPrimaryAnnotationInHierarchy(javax.lang.model.element.AnnotationMirror). If there is only one hierarchy, you can use getPrimaryAnnotation().

      Returns:
      an unmodifiable set of the annotations on this

    • getAnnotationsField

      @Deprecated protected final AnnotationMirrorSet getAnnotationsField()
      Deprecated.
      use getPrimaryAnnotationsField()
      Returns the annotations on this type; mutations affect this object, because the return type is an alias of the annotations field. It does not include annotations in deep types (type arguments, array components, etc).

      The returned set should not be modified, but for efficiency reasons modification is not prevented. Modifications might break invariants.

      Returns:
      the set of the annotations on this; mutations affect this object

    • hasAnnotation

      @Deprecated public boolean hasAnnotation(AnnotationMirror a)
      Deprecated.
      use hasPrimaryAnnotation(AnnotationMirror)
      Returns true if this type contains the given annotation. This method considers the annotation's values. If the type is @A("s") @B(3) Object, then a call with @A("t") or @A will return false, whereas a call with @B(3) will return true.

      In contrast to hasPrimaryAnnotationRelaxed(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:

    • hasAnnotation

      @Deprecated public boolean hasAnnotation(Class<? extends Annotation> a)
      Deprecated.
      use hasPrimaryAnnotation(AnnotationMirror)
      Returns true if 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

    • hasAnnotationInHierarchy

      @Deprecated public boolean hasAnnotationInHierarchy(AnnotationMirror p)
      Deprecated.
      use hasPrimaryAnnotationInHierarchy(AnnotationMirror)
      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

    • hasAnnotationRelaxed

      @Deprecated public boolean hasAnnotationRelaxed(AnnotationMirror a)
      Deprecated.
      use hasPrimaryAnnotationRelaxed(AnnotationMirror)
      Returns true if this type contains an annotation with the same annotation type as a particular annotation. This method does not consider an annotation's values. If the type is @A("s") @B(3) Object, then 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:

    • removeAnnotation

      @Deprecated public boolean removeAnnotation(AnnotationMirror a)
      Deprecated.
      use removePrimaryAnnotation(AnnotationMirror)
      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

    • removeAnnotationByClass

      @Deprecated public boolean removeAnnotationByClass(Class<? extends Annotation> a)
      Deprecated.
      use removePrimaryAnnotationByClass(java.lang.Class<? extends java.lang.annotation.Annotation>)
      Removes an annotation of the given class from the type.
      Parameters:
      a - the class of the annotation to remove
      Returns:
      true if the annotation was removed, false if the type's annotations were unchanged

    • removeAnnotationInHierarchy

      @Deprecated public boolean removeAnnotationInHierarchy(AnnotationMirror a)
      Deprecated.
      use removePrimaryAnnotationInHierarchy(AnnotationMirror)
      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

    • isAnnotatedInHierarchy

      @Deprecated public boolean isAnnotatedInHierarchy(AnnotationMirror annotation)
      Deprecated.
      use hasPrimaryAnnotationInHierarchy(AnnotationMirror)
      Returns true if this type has a primary annotation in the same hierarchy as annotation.
      Parameters:
      annotation - the qualifier hierarchy to check for
      Returns:
      true iff this type has a primary annotation in the same hierarchy as annotation.