AnalysisType

java.lang.Object
- com.oracle.graal.pointsto.meta.AnalysisType

All Implemented Interfaces:

OriginalClassProvider, WrappedElement, WrappedJavaType, Comparable<AnalysisType>, AnnotatedElement, jdk.vm.ci.meta.JavaType, jdk.vm.ci.meta.ModifiersProvider, jdk.vm.ci.meta.ResolvedJavaType
```
public class AnalysisType
extends Object
implements WrappedJavaType, OriginalClassProvider, Comparable<AnalysisType>
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface AnalysisType.InstanceFieldsInterceptor

static class AnalysisType.UsageKind

Nested Classes
Modifier and Type	Class and Description
`static interface`	`AnalysisType.InstanceFieldsInterceptor`
`static class`	`AnalysisType.UsageKind`

Field Summary

Fields
Modifier and Type Field and Description

AllInstantiatedTypeFlow assignableTypes

AllInstantiatedTypeFlow assignableTypesNonNull

protected AnalysisUniverse universe

Fields
Modifier and Type	Field and Description
`AllInstantiatedTypeFlow`	`assignableTypes`
`AllInstantiatedTypeFlow`	`assignableTypesNonNull`
`protected AnalysisUniverse`	`universe`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addInstanceFieldsInterceptor(AnalysisType.InstanceFieldsInterceptor interceptor)`
`void`	`cleanupAfterAnalysis()`
`void`	`clearInstanceFieldsCache()`
`int`	`compareTo(AnalysisType other)`
`boolean`	`declaresDefaultMethods()`
`void`	`ensureInitialized()`
`boolean`	`equals(Object obj)`
`jdk.vm.ci.meta.ResolvedJavaField`	`findInstanceFieldWithOffset(long offset, jdk.vm.ci.meta.JavaKind expectedKind)`
`jdk.vm.ci.meta.Assumptions.AssumptionResult<jdk.vm.ci.meta.ResolvedJavaType>`	`findLeafConcreteSubtype()`
`AnalysisType`	`findLeastCommonAncestor(jdk.vm.ci.meta.ResolvedJavaType otherType)`
`AnalysisMethod`	`findMethod(String name, jdk.vm.ci.meta.Signature signature)`
`jdk.vm.ci.meta.Assumptions.AssumptionResult<jdk.vm.ci.meta.ResolvedJavaMethod>`	`findUniqueConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method)`
`<T extends Annotation> T`	`getAnnotation(Class<T> annotationClass)`
`Annotation[]`	`getAnnotations()`
`AnalysisType`	`getArrayClass()`
`AnalysisType`	`getArrayClass(int dim)`
`AnalysisObject`	`getCachedConstantObject(BigBang bb, jdk.vm.ci.meta.JavaConstant constant)`
`AnalysisMethod`	`getClassInitializer()`
`AnalysisType`	`getComponentType()`
`AnalysisObject`	`getContextInsensitiveAnalysisObject()`
`Annotation[]`	`getDeclaredAnnotations()`
`AnalysisMethod[]`	`getDeclaredConstructors()`
`AnalysisMethod[]`	`getDeclaredMethods()`
`jdk.vm.ci.meta.ResolvedJavaType`	`getElementalType()`
`AnalysisType`	`getEnclosingType()`
`jdk.vm.ci.meta.ResolvedJavaType`	`getHostClass()`
`int`	`getId()`
`AnalysisField[]`	`getInstanceFields(boolean includeSuperclasses)`
`AnalysisType[]`	`getInterfaces()`
`Class<?>`	`getJavaClass()`
`jdk.vm.ci.meta.JavaKind`	`getJavaKind()`
`int`	`getModifiers()`
`String`	`getName()`
`boolean`	`getReachabilityListenerNotified()`
`List<AnalysisType>`	`getReferencedTypes(BigBang bb)` Returns the list of referenced types, i.e., concrete field types or array elements types discovered by the static analysis.
`jdk.vm.ci.meta.ResolvedJavaType`	`getSingleImplementor()`
`String`	`getSourceFileName()`
`AnalysisField[]`	`getStaticFields()`
`jdk.vm.ci.meta.JavaKind`	`getStorageKind()` The kind of the field in memory (in contrast to `AnalysisType.getJavaKind()`, which is the kind of the field on the Java type system level).
`AnalysisType`	`getSuperclass()`
`AllInstantiatedTypeFlow`	`getTypeFlow(BigBang bb, boolean includeNull)`
`AnalysisObject`	`getUniqueConstantObject()`
`jdk.vm.ci.meta.ResolvedJavaType`	`getWrapped()`
`jdk.vm.ci.meta.ResolvedJavaType`	`getWrappedWithoutResolve()`
`boolean`	`hasDefaultMethods()`
`jdk.vm.ci.meta.Assumptions.AssumptionResult<Boolean>`	`hasFinalizableSubclass()`
`boolean`	`hasFinalizer()`
`int`	`hashCode()`
`boolean`	`hasSubTypes()`
`void`	`initialize()`
`boolean`	`isAnnotation()`
`boolean`	`isArray()`
`boolean`	`isAssignableFrom(jdk.vm.ci.meta.ResolvedJavaType other)`
`boolean`	`isCloneableWithAllocation()`
`boolean`	`isEnum()`
`boolean`	`isInitialized()`
`boolean`	`isInstance(jdk.vm.ci.meta.JavaConstant obj)`
`boolean`	`isInstanceClass()`
`boolean`	`isInstantiated()`
`boolean`	`isInterface()`
`boolean`	`isLinked()`
`boolean`	`isLocal()`
`boolean`	`isMember()`
`boolean`	`isPrimitive()`
`boolean`	`isReachable()`
`boolean`	`isWordType()` Returns true if this type is part of the word type hierarchy, i.e, implements `WordBase`.
`void`	`link()`
`void`	`registerAsAllocated(org.graalvm.compiler.graph.Node node)`
`void`	`registerAsInHeap()`
`void`	`registerAsReachable()`
`void`	`registerUnsafeAccessedField(AnalysisField field, UnsafePartitionKind partitionKind)` Add the field to the collection of unsafe accessed fields declared by this type.
`void`	`registerUnsafeFieldsRecomputed()` Says that all instance fields which hold offsets to unsafe field accesses are already recomputed with the correct values from the substrate object layout and therefore don't need a RecomputeFieldValue annotation.
`AnalysisType`	`resolve(jdk.vm.ci.meta.ResolvedJavaType accessingClass)`
`AnalysisMethod`	`resolveConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method)` Wrapper for resolveConcreteMethod() that ignores the callerType parameter.
`AnalysisMethod`	`resolveConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method, jdk.vm.ci.meta.ResolvedJavaType callerType)`
`AnalysisMethod`	`resolveMethod(jdk.vm.ci.meta.ResolvedJavaMethod method, jdk.vm.ci.meta.ResolvedJavaType callerType)`
`void`	`setReachabilityListenerNotified(boolean reachabilityListenerNotified)`
`String`	`toString()`
`List<AnalysisField>`	`unsafeAccessedFields()`
`List<AnalysisField>`	`unsafeAccessedFields(UnsafePartitionKind partitionKind)`
`boolean`	`unsafeFieldsRecomputed()` Returns true if all instance fields which hold offsets to unsafe field accesses are already recomputed with the correct values from the substrate object layout.
`static void`	`updateAssignableTypes(BigBang bb)`
`static boolean`	`verifyAssignableTypes(BigBang bb)`

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

Methods inherited from interface jdk.vm.ci.meta.ResolvedJavaType
isJavaLangObject, isLeaf, lookupType, resolveField

Methods inherited from interface jdk.vm.ci.meta.JavaType
getUnqualifiedName, toClassName, toJavaName, toJavaName

Methods inherited from interface jdk.vm.ci.meta.ModifiersProvider
isAbstract, isConcrete, isFinalFlagSet, isNative, isPackagePrivate, isPrivate, isProtected, isPublic, isStatic, isStrict, isSynchronized, isTransient, isVolatile

Methods inherited from interface java.lang.reflect.AnnotatedElement
getAnnotationsByType, getDeclaredAnnotation, getDeclaredAnnotationsByType, isAnnotationPresent

Methods inherited from interface com.oracle.graal.pointsto.infrastructure.OriginalClassProvider
getJavaClass

- Field Detail
  - universe
```
protected final AnalysisUniverse universe
```
  - assignableTypes
```
public volatile AllInstantiatedTypeFlow assignableTypes
```
  - assignableTypesNonNull
```
public volatile AllInstantiatedTypeFlow assignableTypesNonNull
```
- Method Detail
  - getArrayClass
```
public AnalysisType getArrayClass(int dim)
```
  - cleanupAfterAnalysis
```
public void cleanupAfterAnalysis()
```
  - getId
```
public int getId()
```
  - getContextInsensitiveAnalysisObject
```
public AnalysisObject getContextInsensitiveAnalysisObject()
```
  - getUniqueConstantObject
```
public AnalysisObject getUniqueConstantObject()
```
  - getCachedConstantObject
```
public AnalysisObject getCachedConstantObject(BigBang bb,
                                              jdk.vm.ci.meta.JavaConstant constant)
```
  - getReferencedTypes
```
public List<AnalysisType> getReferencedTypes(BigBang bb)
```
    Returns the list of referenced types, i.e., concrete field types or array elements types discovered by the static analysis. Since this list is not updated during the analysis, for complete results this should only be called when the base analysis has finished.
  - getTypeFlow
```
public AllInstantiatedTypeFlow getTypeFlow(BigBang bb,
                                           boolean includeNull)
```
  - verifyAssignableTypes
```
public static boolean verifyAssignableTypes(BigBang bb)
```
  - updateAssignableTypes
```
public static void updateAssignableTypes(BigBang bb)
```
  - registerAsInHeap
```
public void registerAsInHeap()
```
  - registerAsAllocated
```
public void registerAsAllocated(org.graalvm.compiler.graph.Node node)
```
    Parameters:
    
    node - For future use and debugging
  - registerAsReachable
```
public void registerAsReachable()
```
  - ensureInitialized
```
public void ensureInitialized()
```
  - getReachabilityListenerNotified
```
public boolean getReachabilityListenerNotified()
```
  - setReachabilityListenerNotified
```
public void setReachabilityListenerNotified(boolean reachabilityListenerNotified)
```
  - registerUnsafeFieldsRecomputed
```
public void registerUnsafeFieldsRecomputed()
```
    Says that all instance fields which hold offsets to unsafe field accesses are already recomputed with the correct values from the substrate object layout and therefore don't need a RecomputeFieldValue annotation.
  - registerUnsafeAccessedField
```
public void registerUnsafeAccessedField(AnalysisField field,
                                        UnsafePartitionKind partitionKind)
```
    Add the field to the collection of unsafe accessed fields declared by this type. A field can potentially be registered as unsafe accessed multiple times, depending on the feature implementation, but we add it to the partition only once, when it is first accessed. This is controlled by the isUnsafeAccessed flag in the AnalysField. Also, a field cannot be part of more than one partitions.
  - unsafeAccessedFields
```
public List<AnalysisField> unsafeAccessedFields()
```
  - unsafeAccessedFields
```
public List<AnalysisField> unsafeAccessedFields(UnsafePartitionKind partitionKind)
```
  - isInstantiated
```
public boolean isInstantiated()
```
  - unsafeFieldsRecomputed
```
public boolean unsafeFieldsRecomputed()
```
    Returns true if all instance fields which hold offsets to unsafe field accesses are already recomputed with the correct values from the substrate object layout. Which means that those fields don't need a RecomputeFieldValue annotation.
  - isReachable
```
public boolean isReachable()
```
  - getStorageKind
```
public final jdk.vm.ci.meta.JavaKind getStorageKind()
```
    The kind of the field in memory (in contrast to AnalysisType.getJavaKind(), which is the kind of the field on the Java type system level). For example word types have a AnalysisType.getJavaKind() of JavaKind.Object, but a primitive AnalysisType.storageKind.
  - isWordType
```
public boolean isWordType()
```
    Returns true if this type is part of the word type hierarchy, i.e, implements WordBase.
  - getWrapped
```
public jdk.vm.ci.meta.ResolvedJavaType getWrapped()
```
    Specified by:
    
    getWrapped in interface WrappedElement
    
    Specified by:
    
    getWrapped in interface WrappedJavaType
  - getWrappedWithoutResolve
```
public jdk.vm.ci.meta.ResolvedJavaType getWrappedWithoutResolve()
```
  - getJavaClass
```
public Class<?> getJavaClass()
```
    Specified by:
    
    getJavaClass in interface OriginalClassProvider
  - getName
```
public final String getName()
```
    Specified by:
    
    getName in interface jdk.vm.ci.meta.JavaType
  - getJavaKind
```
public final jdk.vm.ci.meta.JavaKind getJavaKind()
```
    Specified by:
    
    getJavaKind in interface jdk.vm.ci.meta.JavaType
  - resolve
```
public final AnalysisType resolve(jdk.vm.ci.meta.ResolvedJavaType accessingClass)
```
    Specified by:
    
    resolve in interface jdk.vm.ci.meta.JavaType
  - hasFinalizer
```
public final boolean hasFinalizer()
```
    Specified by:
    
    hasFinalizer in interface jdk.vm.ci.meta.ResolvedJavaType
  - hasFinalizableSubclass
```
public final jdk.vm.ci.meta.Assumptions.AssumptionResult<Boolean> hasFinalizableSubclass()
```
    Specified by:
    
    hasFinalizableSubclass in interface jdk.vm.ci.meta.ResolvedJavaType
  - isInitialized
```
public final boolean isInitialized()
```
    Specified by:
    
    isInitialized in interface jdk.vm.ci.meta.ResolvedJavaType
  - initialize
```
public void initialize()
```
    Specified by:
    
    initialize in interface jdk.vm.ci.meta.ResolvedJavaType
  - getArrayClass
```
public final AnalysisType getArrayClass()
```
    Specified by:
    
    getArrayClass in interface jdk.vm.ci.meta.JavaType
    
    Specified by:
    
    getArrayClass in interface jdk.vm.ci.meta.ResolvedJavaType
  - isInterface
```
public boolean isInterface()
```
    Specified by:
    
    isInterface in interface jdk.vm.ci.meta.ModifiersProvider
    
    Specified by:
    
    isInterface in interface jdk.vm.ci.meta.ResolvedJavaType
  - isEnum
```
public boolean isEnum()
```
    Specified by:
    
    isEnum in interface jdk.vm.ci.meta.ResolvedJavaType
  - isInstanceClass
```
public boolean isInstanceClass()
```
    Specified by:
    
    isInstanceClass in interface jdk.vm.ci.meta.ResolvedJavaType
  - isArray
```
public boolean isArray()
```
    Specified by:
    
    isArray in interface jdk.vm.ci.meta.JavaType
  - isPrimitive
```
public boolean isPrimitive()
```
    Specified by:
    
    isPrimitive in interface jdk.vm.ci.meta.ResolvedJavaType
  - getModifiers
```
public int getModifiers()
```
    Specified by:
    
    getModifiers in interface jdk.vm.ci.meta.ModifiersProvider
  - isAssignableFrom
```
public boolean isAssignableFrom(jdk.vm.ci.meta.ResolvedJavaType other)
```
    Specified by:
    
    isAssignableFrom in interface jdk.vm.ci.meta.ResolvedJavaType
  - isInstance
```
public boolean isInstance(jdk.vm.ci.meta.JavaConstant obj)
```
    Specified by:
    
    isInstance in interface jdk.vm.ci.meta.ResolvedJavaType
  - getSuperclass
```
public AnalysisType getSuperclass()
```
    Specified by:
    
    getSuperclass in interface jdk.vm.ci.meta.ResolvedJavaType
  - getInterfaces
```
public AnalysisType[] getInterfaces()
```
    Specified by:
    
    getInterfaces in interface jdk.vm.ci.meta.ResolvedJavaType
  - getSingleImplementor
```
public jdk.vm.ci.meta.ResolvedJavaType getSingleImplementor()
```
    Specified by:
    
    getSingleImplementor in interface jdk.vm.ci.meta.ResolvedJavaType
  - findLeastCommonAncestor
```
public AnalysisType findLeastCommonAncestor(jdk.vm.ci.meta.ResolvedJavaType otherType)
```
    Specified by:
    
    findLeastCommonAncestor in interface jdk.vm.ci.meta.ResolvedJavaType
  - findLeafConcreteSubtype
```
public jdk.vm.ci.meta.Assumptions.AssumptionResult<jdk.vm.ci.meta.ResolvedJavaType> findLeafConcreteSubtype()
```
    Specified by:
    
    findLeafConcreteSubtype in interface jdk.vm.ci.meta.ResolvedJavaType
  - getComponentType
```
public AnalysisType getComponentType()
```
    Specified by:
    
    getComponentType in interface jdk.vm.ci.meta.JavaType
    
    Specified by:
    
    getComponentType in interface jdk.vm.ci.meta.ResolvedJavaType
  - getElementalType
```
public jdk.vm.ci.meta.ResolvedJavaType getElementalType()
```
    Specified by:
    
    getElementalType in interface jdk.vm.ci.meta.JavaType
    
    Specified by:
    
    getElementalType in interface jdk.vm.ci.meta.ResolvedJavaType
  - hasSubTypes
```
public boolean hasSubTypes()
```
  - resolveMethod
```
public AnalysisMethod resolveMethod(jdk.vm.ci.meta.ResolvedJavaMethod method,
                                    jdk.vm.ci.meta.ResolvedJavaType callerType)
```
    Specified by:
    
    resolveMethod in interface jdk.vm.ci.meta.ResolvedJavaType
  - resolveConcreteMethod
```
public AnalysisMethod resolveConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method)
```
    Wrapper for resolveConcreteMethod() that ignores the callerType parameter. The method that does the resolution, resolveMethod() above, ignores the callerType parameter and uses substMethod.getDeclaringClass() instead since we don't want any access checks in the analysis.
  - resolveConcreteMethod
```
public AnalysisMethod resolveConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method,
                                            jdk.vm.ci.meta.ResolvedJavaType callerType)
```
    Specified by:
    
    resolveConcreteMethod in interface jdk.vm.ci.meta.ResolvedJavaType
  - findUniqueConcreteMethod
```
public jdk.vm.ci.meta.Assumptions.AssumptionResult<jdk.vm.ci.meta.ResolvedJavaMethod> findUniqueConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method)
```
    Specified by:
    
    findUniqueConcreteMethod in interface jdk.vm.ci.meta.ResolvedJavaType
  - findInstanceFieldWithOffset
```
public jdk.vm.ci.meta.ResolvedJavaField findInstanceFieldWithOffset(long offset,
                                                                    jdk.vm.ci.meta.JavaKind expectedKind)
```
    Specified by:
    
    findInstanceFieldWithOffset in interface jdk.vm.ci.meta.ResolvedJavaType
  - clearInstanceFieldsCache
```
public void clearInstanceFieldsCache()
```
  - getInstanceFields
```
public AnalysisField[] getInstanceFields(boolean includeSuperclasses)
```
    Specified by:
    
    getInstanceFields in interface jdk.vm.ci.meta.ResolvedJavaType
  - getStaticFields
```
public AnalysisField[] getStaticFields()
```
    Specified by:
    
    getStaticFields in interface jdk.vm.ci.meta.ResolvedJavaType
  - getAnnotations
```
public Annotation[] getAnnotations()
```
    Specified by:
    
    getAnnotations in interface AnnotatedElement
  - getDeclaredAnnotations
```
public Annotation[] getDeclaredAnnotations()
```
    Specified by:
    
    getDeclaredAnnotations in interface AnnotatedElement
  - getAnnotation
```
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
```
    Specified by:
    
    getAnnotation in interface AnnotatedElement
  - getSourceFileName
```
public String getSourceFileName()
```
    Specified by:
    
    getSourceFileName in interface jdk.vm.ci.meta.ResolvedJavaType
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isLocal
```
public boolean isLocal()
```
    Specified by:
    
    isLocal in interface jdk.vm.ci.meta.ResolvedJavaType
  - isMember
```
public boolean isMember()
```
    Specified by:
    
    isMember in interface jdk.vm.ci.meta.ResolvedJavaType
  - getEnclosingType
```
public AnalysisType getEnclosingType()
```
    Specified by:
    
    getEnclosingType in interface jdk.vm.ci.meta.ResolvedJavaType
  - getDeclaredConstructors
```
public AnalysisMethod[] getDeclaredConstructors()
```
    Specified by:
    
    getDeclaredConstructors in interface jdk.vm.ci.meta.ResolvedJavaType
  - getDeclaredMethods
```
public AnalysisMethod[] getDeclaredMethods()
```
    Specified by:
    
    getDeclaredMethods in interface jdk.vm.ci.meta.ResolvedJavaType
  - findMethod
```
public AnalysisMethod findMethod(String name,
                                 jdk.vm.ci.meta.Signature signature)
```
    Specified by:
    
    findMethod in interface jdk.vm.ci.meta.ResolvedJavaType
  - getClassInitializer
```
public AnalysisMethod getClassInitializer()
```
    Specified by:
    
    getClassInitializer in interface jdk.vm.ci.meta.ResolvedJavaType
  - isLinked
```
public boolean isLinked()
```
    Specified by:
    
    isLinked in interface jdk.vm.ci.meta.ResolvedJavaType
  - link
```
public void link()
```
    Specified by:
    
    link in interface jdk.vm.ci.meta.ResolvedJavaType
  - hasDefaultMethods
```
public boolean hasDefaultMethods()
```
    Specified by:
    
    hasDefaultMethods in interface jdk.vm.ci.meta.ResolvedJavaType
  - declaresDefaultMethods
```
public boolean declaresDefaultMethods()
```
    Specified by:
    
    declaresDefaultMethods in interface jdk.vm.ci.meta.ResolvedJavaType
  - isCloneableWithAllocation
```
public boolean isCloneableWithAllocation()
```
    Specified by:
    
    isCloneableWithAllocation in interface jdk.vm.ci.meta.ResolvedJavaType
  - getHostClass
```
public jdk.vm.ci.meta.ResolvedJavaType getHostClass()
```
    Specified by:
    
    getHostClass in interface jdk.vm.ci.meta.ResolvedJavaType
  - compareTo
```
public int compareTo(AnalysisType other)
```
    Specified by:
    
    compareTo in interface Comparable<AnalysisType>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - isAnnotation
```
public boolean isAnnotation()
```
  - addInstanceFieldsInterceptor
```
public void addInstanceFieldsInterceptor(AnalysisType.InstanceFieldsInterceptor interceptor)
```

Class AnalysisType

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface jdk.vm.ci.meta.ResolvedJavaType

Methods inherited from interface jdk.vm.ci.meta.JavaType

Methods inherited from interface jdk.vm.ci.meta.ModifiersProvider

Methods inherited from interface java.lang.reflect.AnnotatedElement

Methods inherited from interface com.oracle.graal.pointsto.infrastructure.OriginalClassProvider

Field Detail

universe

assignableTypes

assignableTypesNonNull

Method Detail

getArrayClass

cleanupAfterAnalysis

getId

getContextInsensitiveAnalysisObject

getUniqueConstantObject

getCachedConstantObject

getReferencedTypes

getTypeFlow

verifyAssignableTypes

updateAssignableTypes

registerAsInHeap

registerAsAllocated

registerAsReachable

ensureInitialized

getReachabilityListenerNotified

setReachabilityListenerNotified

registerUnsafeFieldsRecomputed

registerUnsafeAccessedField

unsafeAccessedFields

unsafeAccessedFields

isInstantiated

unsafeFieldsRecomputed

isReachable

getStorageKind

isWordType

getWrapped

getWrappedWithoutResolve

getJavaClass

getName

getJavaKind

resolve

hasFinalizer

hasFinalizableSubclass

isInitialized

initialize

getArrayClass

isInterface

isEnum

isInstanceClass

isArray

isPrimitive

getModifiers

isAssignableFrom

isInstance

getSuperclass

getInterfaces

getSingleImplementor

findLeastCommonAncestor

findLeafConcreteSubtype

getComponentType

getElementalType

hasSubTypes

resolveMethod

resolveConcreteMethod

resolveConcreteMethod

findUniqueConcreteMethod

findInstanceFieldWithOffset

clearInstanceFieldsCache

getInstanceFields

getStaticFields

getAnnotations

getDeclaredAnnotations

getAnnotation

getSourceFileName

toString