Package org.checkerframework.framework.type

Class AnnotatedTypeMirror.AnnotatedDeclaredType

java.lang.Object
org.checkerframework.framework.type.AnnotatedTypeMirror
org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType
All Implemented Interfaces:
org.plumelib.util.DeepCopyable<AnnotatedTypeMirror>
Enclosing class:
AnnotatedTypeMirror
public static class AnnotatedTypeMirror.AnnotatedDeclaredType extends AnnotatedTypeMirror
Represents a declared type (whether class or interface).

  • Field Details

  • Method Details

    • isDeclaration

      public boolean isDeclaration()
      Description copied from class: AnnotatedTypeMirror
      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.

      Overrides:
      isDeclaration in class AnnotatedTypeMirror
      Returns:
      true if this represents a declaration

    • deepCopy

      public AnnotatedTypeMirror.AnnotatedDeclaredType deepCopy(boolean copyAnnotations)
      Description copied from class: AnnotatedTypeMirror
      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.
      Specified by:
      deepCopy in class AnnotatedTypeMirror
      Returns:
      a deep copy

    • deepCopy

      public AnnotatedTypeMirror.AnnotatedDeclaredType deepCopy()
      Description copied from class: AnnotatedTypeMirror
      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>
      Specified by:
      deepCopy in class AnnotatedTypeMirror
      Returns:
      a deep copy of this type with annotations
      See Also:

    • asUse

      public AnnotatedTypeMirror.AnnotatedDeclaredType asUse()
      Overrides:
      asUse in class AnnotatedTypeMirror

    • accept

      public <R, P> R accept(AnnotatedTypeVisitor<R,P> v, P p)
      Description copied from class: AnnotatedTypeMirror
      Applies a visitor to this type.
      Specified by:
      accept in class AnnotatedTypeMirror
      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

    • setTypeArguments

      public void setTypeArguments(List<? extends AnnotatedTypeMirror> ts)
      Sets the type arguments on this type.
      Parameters:
      ts - a list of type arguments to be captured by this method

    • getTypeArguments

      public List<AnnotatedTypeMirror> getTypeArguments()
      Returns the type argument for this type.
      Returns:
      the type argument for this type

    • isUnderlyingTypeRaw

      public boolean isUnderlyingTypeRaw()
      Returns true if the underlying type is raw. The receiver of this method is not raw, however; its annotated type arguments have been inferred.
      Returns:
      true iff the type was raw

    • wasRaw

      @Deprecated public boolean wasRaw()
      Deprecated.
      Use isUnderlyingTypeRaw() instead
      Returns true if the underlying type is raw. The receiver of this method is not raw, however; its annotated type arguments have been inferred.
      Returns:
      true iff the type was raw

    • setIsUnderlyingTypeRaw

      protected void setIsUnderlyingTypeRaw()
      Set the isUnderlyingTypeRaw flag to true. This should only be necessary when determining the supertypes of a raw type.

    • setWasRaw

      @Deprecated protected void setWasRaw()
      Deprecated.
      Use setIsUnderlyingTypeRaw() instead
      Set the isUnderlyingTypeRaw flag to true. This should only be necessary when determining the supertypes of a raw type.

    • getUnderlyingType

      public DeclaredType getUnderlyingType()
      Description copied from class: AnnotatedTypeMirror
      Returns the underlying unannotated Java type, which this wraps.
      Overrides:
      getUnderlyingType in class AnnotatedTypeMirror
      Returns:
      the underlying type

    • directSupertypes

      public List<AnnotatedTypeMirror.AnnotatedDeclaredType> directSupertypes()
      Description copied from class: AnnotatedTypeMirror
      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>.
      Overrides:
      directSupertypes in class AnnotatedTypeMirror
      Returns:
      the immediate supertypes of this
      See Also:

    • shallowCopy

      public AnnotatedTypeMirror.AnnotatedDeclaredType shallowCopy()
      Description copied from class: AnnotatedTypeMirror
      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).

      Specified by:
      shallowCopy in class AnnotatedTypeMirror
      Returns:
      a shallow copy of this type with annotations
      See Also:

    • shallowCopy

      public AnnotatedTypeMirror.AnnotatedDeclaredType shallowCopy(boolean copyAnnotations)
      Description copied from class: AnnotatedTypeMirror
      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.
      Specified by:
      shallowCopy in class AnnotatedTypeMirror
      Parameters:
      copyAnnotations - whether copy should have annotations, i.e. whether field annotations should be copied.

    • getErased

      public AnnotatedTypeMirror.AnnotatedDeclaredType getErased()
      Return the declared type with its type arguments removed. This also replaces the underlying type with its erasure.
      Overrides:
      getErased in class AnnotatedTypeMirror
      Returns:
      a fresh copy of the declared type with no type arguments
      See Also:

    • setEnclosingType

      public void setEnclosingType(@Nullable AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType)
      Sets the enclosing type.
      Parameters:
      enclosingType - the new enclosing type

    • getEnclosingType

      public @Nullable AnnotatedTypeMirror.AnnotatedDeclaredType getEnclosingType()
      Returns the enclosing type, as in the type of A in the type A.B. May return null.
      Returns:
      enclosingType the enclosing type, or null if this is a top-level type