Package org.jboss.jandex

Class Type

  • All Implemented Interfaces:
    Descriptor
    Direct Known Subclasses:
    ArrayType, ClassType, ParameterizedType, PrimitiveType, TypeVariable, TypeVariableReference, UnresolvedTypeVariable, VoidType, WildcardType
    public abstract class Type
extends java.lang.Object
implements Descriptor
    Represents a Java type usage that is specified on methods, fields, classes, annotations, or other types. A type can be any class based type (interface, class, annotation), any primitive, any array, any generic type declaration, or void.

    A type usage may have annotations associated with its declaration. A type is equal to another type if, and only if, it represents the same exact definition including the annotations specific to its usage.

    To reduce memory overhead, type instances are often shared between their enclosing classes.

    • Method Detail

      • create

        public static Type create​(DotName name,
                          Type.Kind kind)
        Creates a type of the specified kind and name in the Class.getName() format. Specifically:
        • if kind is VOID, the name is ignored;
        • if kind is PRIMITIVE, the name must be the corresponding Java keyword (boolean, byte, short, int, long, float, double, char);
        • if kind is CLASS, the name must be a binary name of the class;
        • if kind is ARRAY, the name must consists of one or more [ characters corresponding to the number of dimensions of the array type, followed by the element type as a single-character code for primitive types or Lbinary.name.of.TheClass; for class types (for example, [I for int[] or [[Ljava.lang.String; for String[][]);
        • all other kinds cause an exception.
        Parameters:
        name - the name of type to use or parse; must not be null
        kind - the kind of type to create; must not be null
        Returns:
        the type
        Throws:
        java.lang.IllegalArgumentException - if the kind is not supported

      • createWithAnnotations

        public static Type createWithAnnotations​(DotName name,
                                         Type.Kind kind,
                                         AnnotationInstance[] annotations)
        Creates an instance of specified type with given type annotations. To create the type instance, this method delegates to create(DotName, Kind).
        Parameters:
        name - the name of type to use or parse; must not be null
        kind - the kind of type to create; must not be null
        annotations - the type annotations that should be present on the type instance; may be null
        Returns:
        the annotated type
        Throws:
        java.lang.IllegalArgumentException - if the kind is not supported

      • parse

        public static Type parse​(java.lang.String type)
        Creates a Type by parsing the given string according to the following grammar: 
         Type -> VoidType | PrimitiveType | ReferenceType
 VoidType -> 'void'
 PrimitiveType -> 'boolean' | 'byte' | 'short' | 'int'
                | 'long' | 'float' | 'double' | 'char'
 ReferenceType -> PrimitiveType ('[' ']')+
                | ClassType ('<' TypeArgument (',' TypeArgument)* '>')? ('[' ']')*
 ClassType -> FULLY_QUALIFIED_NAME
 TypeArgument -> ReferenceType | WildcardType
 WildcardType -> '?' | '?' ('extends' | 'super') ReferenceType
        Notice that the resulting type never contains type variables, only "proper" types. Also notice that the grammar above does not support all kinds of nested types; it should be possible to add that later, if there's an actual need.
        Parameters:
        type - the string to parse; must not be null
        Returns:
        the parsed type
        Throws:
        java.lang.IllegalArgumentException - if the string does not conform to the grammar given above
        Since:
        3.2.3

      • name

        public DotName name()
        Returns the name of this type (or its erasure in case of generic types) as a DotName, using the Class.getName() format. Specifically:
        • for primitive types and the void pseudo-type, the corresponding Java keyword is returned (void, boolean, byte, short, int, long, float, double, char);
        • for class types, the binary name of the class is returned;
        • for array types, a string is returned that consists of one or more [ characters corresponding to the number of dimensions of the array type, followed by the element type as a single-character code for primitive types or Lbinary.name.of.TheClass; for class types (for example, [I for int[] or [[Ljava.lang.String; for String[][]);
        • for parameterized types, the binary name of the generic class is returned (for example, java.util.List for List<String>);
        • for type variables, the name of the first bound of the type variable is returned, or java.lang.Object for type variables that have no bound;
        • for wildcard types, the name of the upper bound is returned, or java.lang.Object if the wildcard type does not have an upper bound (for example, java.lang.Number for ? extends Number).
        Returns:
        the name of this type (or its erasure in case of generic types)

      • kind

        public abstract Type.Kind kind()
        Returns the kind of Type this is.
        Returns:
        the kind

      • asClassType

        public ClassType asClassType()
        Casts this type to a ClassType and returns it if the kind is Type.Kind.CLASS. Throws an exception otherwise.
        Returns:
        a ClassType
        Throws:
        java.lang.IllegalArgumentException - if not a class
        Since:
        2.0

      • asParameterizedType

        public ParameterizedType asParameterizedType()
        Casts this type to a ParameterizedType and returns it if the kind is Type.Kind.PARAMETERIZED_TYPE. Throws an exception otherwise.
        Returns:
        a ParameterizedType
        Throws:
        java.lang.IllegalArgumentException - if not a parameterized type
        Since:
        2.0

      • asTypeVariable

        public TypeVariable asTypeVariable()
        Casts this type to a TypeVariable and returns it if the kind is Type.Kind.TYPE_VARIABLE. Throws an exception otherwise.
        Returns:
        a TypeVariable
        Throws:
        java.lang.IllegalArgumentException - if not a type variable
        Since:
        2.0

      • asArrayType

        public ArrayType asArrayType()
        Casts this type to an ArrayType and returns it if the kind is Type.Kind.ARRAY. Throws an exception otherwise.
        Returns:
        an ArrayType
        Throws:
        java.lang.IllegalArgumentException - if not an array type
        Since:
        2.0

      • asWildcardType

        public WildcardType asWildcardType()
        Casts this type to a WildcardType and returns it if the kind is Type.Kind.WILDCARD_TYPE. Throws an exception otherwise.
        Returns:
        a WildcardType
        Throws:
        java.lang.IllegalArgumentException - if not a wildcard type
        Since:
        2.0

      • asPrimitiveType

        public PrimitiveType asPrimitiveType()
        Casts this type to a PrimitiveType and returns it if the kind is Type.Kind.PRIMITIVE. Throws an exception otherwise.
        Returns:
        a PrimitiveType
        Throws:
        java.lang.IllegalArgumentException - if not a primitive type
        Since:
        2.0

      • asVoidType

        public VoidType asVoidType()
        Casts this type to a VoidType and returns it if the kind is Type.Kind.VOID. Throws an exception otherwise.
        Returns:
        a VoidType
        Throws:
        java.lang.IllegalArgumentException - if not a void type
        Since:
        2.0

      • hasAnnotation

        public final boolean hasAnnotation​(DotName name)
        Returns whether an annotation instance with given name is declared on this type usage.
        Parameters:
        name - name of the annotation type to look for, must not be null
        Returns:
        true if the annotation is present, false otherwise
        See Also:
        annotation(DotName)

      • annotation

        public final AnnotationInstance annotation​(DotName name)
        Returns the annotation instance with given name declared on this type usage.

        To allow for Type object reuse, the annotation instances returned by this method have a null annotation target.

        Parameters:
        name - name of the annotation type to look for, must not be null
        Returns:
        the annotation instance, or null if not found

      • annotationsWithRepeatable

        public final java.util.List<AnnotationInstance> annotationsWithRepeatable​(DotName name,
                                                                          IndexView index)
        Returns the annotation instances with given name declared on this type usage.

        If the specified annotation is repeatable, the result also contains all values from the container annotation instance. In this case, the AnnotationInstance.target() returns the target of the container annotation instance.

        To allow for Type object reuse, the annotation instances returned by this method have a null annotation target.

        Parameters:
        name - name of the annotation type, must not be null
        index - index used to obtain the annotation type, must not be null
        Returns:
        immutable list of annotation instances, never null
        Throws:
        java.lang.IllegalArgumentException - if the index is null, if the index does not contain the annotation type or if name does not identify an annotation type
        Since:
        3.0
        See Also:
        annotations()

      • annotations

        public java.util.List<AnnotationInstance> annotations()
        Returns the annotation instances declared on this type usage.

        To allow for Type object reuse, the annotation instances returned by this method have a null annotation target.

        Returns:
        immutable list of annotation instances, never null
        Since:
        2.0

      • withoutAnnotations

        Type withoutAnnotations()
        Returns this type with all type annotations removed. The annotations are removed deeply, that is also on the constituent type in case of arrays, on type arguments in case of parameterized types, on the bound in case of wildcard types, etc.
        Returns:
        this type without type annotations

      • toString

        public java.lang.String toString()
        Returns a string representation for this type. It is similar, yet not identical to a Java source code representation.
        Overrides:
        toString in class java.lang.Object
        Returns:
        the string representation.

      • toString

        java.lang.String toString​(boolean simple)

      • appendAnnotations

        void appendAnnotations​(java.lang.StringBuilder builder)

      • descriptor

        public java.lang.String descriptor​(java.util.function.Function<java.lang.String,​Type> typeVariableSubstitution)
        Returns the bytecode descriptor of this type (or its erasure in case of generic types). Specifically:
        • for primitive types and the void pseudo-type, the single-character descriptor is returned;
        • for class types, the Lbinary/name/of/TheClass; string is returned;
        • for array types, a string is returned that consists of one or more [ characters corresponding to the number of dimensions of the array type, followed by the descriptor of the element type (for example, [I for int[] or [[Ljava/lang/String; for String[][]);
        • for parameterized types, the descriptor of the generic class is returned (for example, Ljava/util/List; for List<String>);
        • for type variables, the descriptor of the first bound of the type variable is returned, or the descriptor of the java.lang.Object class for type variables that have no bound;
        • for wildcard types, the descriptor of the upper bound is returned, or the descriptor of the java.lang.Object class if the wildcard type does not have an upper bound (for example, Ljava/lang/Number; for ? extends Number).
        Descriptors of type variables are substituted for descriptors of types provided by the substitution function typeVariableSubstitution. If the substitution function returns null for some type variable identifier, or if it returns the type variable itself, no substitution happens and the type variable descriptor is used unmodified.

        Note that the return value does not come directly from bytecode. Jandex does not store the descriptor strings. Instead, the return value is reconstructed from the Jandex object model.

        Specified by:
        descriptor in interface Descriptor
        Parameters:
        typeVariableSubstitution - a substitution function from type variable identifiers to types
        Returns:
        the bytecode descriptor of this type (or its erasure in case of generic types)

      • equals

        public boolean equals​(java.lang.Object o)
        Compares this Type with another type. A type is equal to another type if it is of the same kind, and all of their fields are equal. This includes annotations, which must be equal as well.
        Overrides:
        equals in class java.lang.Object
        Parameters:
        o - the type to compare to
        Returns:
        true if equal
        See Also:
        Object.equals(Object)

      • hashCode

        public int hashCode()
        Computes a hash code representing this type.
        Overrides:
        hashCode in class java.lang.Object
        Returns:
        the hash code

      • internEquals

        boolean internEquals​(java.lang.Object o)

      • internHashCode

        int internHashCode()