Package spoon.reflect.declaration

Interface CtTypeInformation

All Known Subinterfaces:
CtAnnotationType<T>, CtArrayTypeReference<T>, CtClass<T>, CtEnum<T>, CtInterface<T>, CtIntersectionTypeReference<T>, CtRecord, CtType<T>, CtTypeParameter, CtTypeParameterReference, CtTypeReference<T>, CtWildcardReference
All Known Implementing Classes:
CtAnnotationTypeImpl, CtArrayTypeReferenceImpl, CtClassImpl, CtEnumImpl, CtInterfaceImpl, CtIntersectionTypeReferenceImpl, CtRecordImpl, CtTypeImpl, CtTypeParameterImpl, CtTypeParameterReferenceImpl, CtTypeReferenceImpl, CtWildcardReferenceImpl
public interface CtTypeInformation
Returns information that can be obtained both at compile-time and run-time For CtElement, the compile-time information is given For CtTypeReference, the runtime information is given (using the Reflection API)

  • Method Details

    • getSuperInterfaces

      Set<CtTypeReference<?>> getSuperInterfaces()
      Returns the interface types directly implemented by this class or extended by this interface.

    • getQualifiedName

      String getQualifiedName()
      Returns the fully qualified name of this type declaration.

    • getModifiers

      Set<ModifierKind> getModifiers()
      Gets modifiers of this type.

    • isPrimitive

      boolean isPrimitive()
      Return true if the referenced type is a primitive type (int, double, boolean...).

    • isAnonymous

      boolean isAnonymous()
      Return true if the referenced type is a anonymous type

    • isLocalType

      boolean isLocalType()
      Return true if the referenced type is declared in an executable. e.g. a type declared in a method or a lambda. This corresponds to isLocalClass of java.lang.Class. 
           // Type declared in a method.
     public void make() {
         class Cook {
         }
     }
     // Type declared in a lambda.
     s -> {
         class Cook {
         }
     }

    • isClass

      boolean isClass()
      Returns true if this type is a class. Returns false for others (enum, interface, generics, annotation).

    • isInterface

      boolean isInterface()
      Returns true if this type is an interface.

    • isEnum

      boolean isEnum()
      Returns true if this type is an enum.

    • isAnnotationType

      boolean isAnnotationType()
      Returns true if this type is an annotation type.

    • isGenerics

      boolean isGenerics()
      Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly. Direct: "T foo" isGenerics returns true. Indirect: List<T>, or Set<List<T>> isGenerics returns true

    • isParameterized

      boolean isParameterized()
      Returns true if it has any type parameter (generic or not).

    • isSubtypeOf

      boolean isSubtypeOf​(CtTypeReference<?> type)
      Returns true if the referenced type is a sub-type of the given type. Returns true is type is self, it means: typeX.isSubtypeOf(typeX) is true too

    • getSuperclass

      CtTypeReference<?> getSuperclass()
      Returns the class type directly extended by this class. getSuperClass().getDeclaration()/getTypeDeclaration() returns the corresponding CtType (if in the source folder of Spoon).
      Returns:
      the class type directly extended by this class, or null if there is none or if the super class is not in the classpath (in noclasspath mode)

    • getDeclaredFields

      Collection<CtFieldReference<?>> getDeclaredFields()
      Gets the fields declared by this type.

    • getAllFields

      Collection<CtFieldReference<?>> getAllFields()
      Gets the fields declared by this type and by all its supertypes if applicable.

    • getDeclaredField

      CtFieldReference<?> getDeclaredField​(String name)
      Gets a field from its name.
      Returns:
      null if does not exit

    • getDeclaredOrInheritedField

      CtFieldReference<?> getDeclaredOrInheritedField​(String fieldName)
      Gets a field from this type or any super type or any implemented interface by field name.
      Returns:
      null if does not exit

    • getDeclaredExecutables

      Collection<CtExecutableReference<?>> getDeclaredExecutables()
      Gets the executables declared by this type if applicable.

    • getAllExecutables

      Collection<CtExecutableReference<?>> getAllExecutables()
      Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable. This method returns:
      • static, instance and default methods
      • constructors
      If a method is overridden twice in the hierarchy, it counts for two different elements. The method can be abstract.

    • getTypeErasure

      CtTypeReference<?> getTypeErasure()
      Returns:
      the type erasure, which is computed by the java compiler to ensure that no new classes are created for parametrized types so that generics incur no runtime overhead. See https://docs.oracle.com/javase/tutorial/java/generics/erasure.html

    • isArray

      boolean isArray()
      Returns:
      true if this represents an array e.g. Object[] or int[]