AnalysisType

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

All Implemented Interfaces:

OriginalClassProvider, WrappedElement, WrappedJavaType, Comparable<AnalysisType>, AnnotatedElement

Direct Known Subclasses:

PointsToAnalysisType
```
public abstract class AnalysisType
extends AnalysisElement
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/interfaces inherited from class com.oracle.graal.pointsto.meta.AnalysisElement
  AnalysisElement.ElementNotification, AnalysisElement.MethodOverrideReachableNotification, AnalysisElement.ReachabilityReason, AnalysisElement.ReachabilityTraceBuilder, AnalysisElement.SubtypeReachableNotification

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
`TypeState`	`assignableTypesNonNullState`
`TypeState`	`assignableTypesState` Stores the list of all assignable types for each analysis type.
`AllInstantiatedTypeFlow`	`instantiatedTypes` Type flows containing all the instantiated sub-types.
`AllInstantiatedTypeFlow`	`instantiatedTypesNonNull`
`protected AnalysisUniverse`	`universe`

Constructor Summary

Constructors
Constructor and Description
`AnalysisType(AnalysisUniverse universe, ResolvedJavaType javaType, JavaKind storageKind, AnalysisType objectType, AnalysisType cloneableType)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addAssignableType(BigBang bb, TypeState typeState)`
`void`	`addInstanceFieldsInterceptor(AnalysisType.InstanceFieldsInterceptor interceptor)`
`void`	`cleanupAfterAnalysis()`
`void`	`clearInstanceFieldsCache()`
`int`	`compareTo(AnalysisType other)`
`boolean`	`declaresDefaultMethods()`
`void`	`ensureOnTypeReachableTaskDone()`
`boolean`	`equals(Object obj)`
`ResolvedJavaField`	`findInstanceFieldWithOffset(long offset, JavaKind expectedKind)`
`<any>`	`findLeafConcreteSubtype()`
`AnalysisType`	`findLeastCommonAncestor(ResolvedJavaType otherType)`
`AnalysisMethod`	`findMethod(String name, Signature signature)`
`<any>`	`findUniqueConcreteMethod(ResolvedJavaMethod method)`
`void`	`forAllSuperTypes(Consumer<AnalysisType> superTypeConsumer)` Iterates all super types for this type, where a super type is defined as any type that is assignable from this type, feeding each of them to the consumer.
`protected void`	`forAllSuperTypes(Consumer<AnalysisType> superTypeConsumer, boolean includeThisType)`
`Object`	`getAllocatedReason()`
`Set<AnalysisType>`	`getAllSubtypes()` Collects and returns all subtypes of this type, not only the immediate subtypes, including this type itself, regardless of reachability status.
`AnalysisType`	`getArrayClass()`
`AnalysisType`	`getArrayClass(int dim)`
`int`	`getArrayDimension()`
`TypeState`	`getAssignableTypes(boolean includeNull)` Returns the assignable types.
`AnalysisObject`	`getCachedConstantObject(PointsToAnalysis bb, JavaConstant constant, Function<JavaConstant,AnalysisObject> constantTransformer)`
`AnalysisMethod`	`getClassInitializer()`
`AnalysisType`	`getComponentType()`
`AnalysisObject`	`getContextInsensitiveAnalysisObject()`
`ResolvedJavaMethod[]`	`getDeclaredConstructors()`
`AnalysisMethod[]`	`getDeclaredConstructors(boolean forceLink)`
`ResolvedJavaMethod[]`	`getDeclaredMethods()`
`AnalysisMethod[]`	`getDeclaredMethods(boolean forceLink)`
`AnalysisType`	`getElementalType()`
`AnalysisType`	`getEnclosingType()`
`ResolvedJavaType`	`getHostClass()`
`int`	`getId()`
`Object`	`getInHeapReason()`
`AnalysisFuture<Void>`	`getInitializeMetaDataTask()`
`ResolvedJavaField[]`	`getInstanceFields(boolean includeSuperclasses)` Note that although this returns a ResolvedJavaField[], all instance fields are of type AnalysisField and can be casted to AnalysisField without problem.
`AnalysisType[]`	`getInterfaces()`
`Class<?>`	`getJavaClass()`
`JavaKind`	`getJavaKind()`
`int`	`getModifiers()`
`String`	`getName()`
`TypeData`	`getOrComputeData()`
`Set<AnalysisElement.MethodOverrideReachableNotification>`	`getOverrideReachabilityNotifications(AnalysisMethod method)`
`boolean`	`getReachabilityListenerNotified()`
`Object`	`getReachableReason()`
`ResolvedJavaType`	`getSingleImplementor()`
`String`	`getSourceFileName()`
`ResolvedJavaField[]`	`getStaticFields()` Note that although this returns a ResolvedJavaField[], all instance fields are of type AnalysisField and can be casted to AnalysisField without problem.
`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).
`Set<AnalysisType>`	`getSubTypes()` Get the immediate subtypes, including this type itself.
`AnalysisType`	`getSuperclass()`
`AllInstantiatedTypeFlow`	`getTypeFlow(BigBang bb, boolean includeNull)`
`AnalysisObject`	`getUniqueConstantObject()`
`AnalysisUniverse`	`getUniverse()`
`ResolvedJavaType`	`getWrapped()`
`ResolvedJavaType`	`getWrappedWithResolve()`
`boolean`	`hasDefaultMethods()`
`<any>`	`hasFinalizableSubclass()`
`boolean`	`hasFinalizer()`
`int`	`hashCode()`
`boolean`	`hasSubTypes()`
`void`	`initialize()`
`boolean`	`isAllocated()`
`boolean`	`isAnnotation()`
`boolean`	`isAnySubtypeInstantiated()` Returns true if this type or any of its subtypes was marked as instantiated.
`boolean`	`isArray()`
`boolean`	`isAssignableFrom(ResolvedJavaType other)`
`boolean`	`isCloneableWithAllocation()`
`boolean`	`isEnum()`
`boolean`	`isInHeap()`
`boolean`	`isInitialized()`
`boolean`	`isInstance(JavaConstant obj)`
`boolean`	`isInstanceClass()`
`boolean`	`isInstantiated()`
`boolean`	`isInterface()`
`boolean`	`isJavaLangObject()`
`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()`
`protected void`	`notifyInstantiatedCallbacks()`
`protected void`	`onInstantiated(AnalysisType.UsageKind usage)`
`protected void`	`onReachable()`
`boolean`	`registerAsAllocated(Object reason)`
`void`	`registerAsAssignable(BigBang bb)` Register the type as assignable with all its super types.
`boolean`	`registerAsInHeap(Object reason)`
`boolean`	`registerAsReachable(Object reason)`
`void`	`registerInstantiatedCallback(Consumer<org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess> callback)`
`void`	`registerOverrideReachabilityNotification(AnalysisMethod declaredMethod, AnalysisElement.MethodOverrideReachableNotification notification)`
`void`	`registerSubtypeReachabilityNotification(AnalysisElement.SubtypeReachableNotification notification)`
`void`	`registerUnsafeAccessedField(AnalysisField field, com.oracle.svm.util.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(ResolvedJavaType accessingClass)`
`AnalysisMethod`	`resolveConcreteMethod(ResolvedJavaMethod method)` Wrapper for resolveConcreteMethod() without the callerType parameter.
`AnalysisMethod`	`resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJavaType callerType)`
`AnalysisMethod`	`resolveMethod(ResolvedJavaMethod method, ResolvedJavaType callerType)`
`void`	`setReachabilityListenerNotified(boolean reachabilityListenerNotified)`
`String`	`toJavaName()`
`String`	`toJavaName(boolean qualified)`
`String`	`toString()`
`List<AnalysisField>`	`unsafeAccessedFields()`
`List<AnalysisField>`	`unsafeAccessedFields(com.oracle.svm.util.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 boolean`	`verifyAssignableTypes(BigBang bb)`

Methods inherited from class com.oracle.graal.pointsto.meta.AnalysisElement
execute, getAnnotation, getAnnotations, getDeclaredAnnotation, getDeclaredAnnotations, isAnnotationPresent, isTriggered, notifyReachabilityCallback, notifyReachabilityCallbacks, registerReachabilityNotification

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

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

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

- Field Detail
  - universe
```
protected final AnalysisUniverse universe
```
  - assignableTypesState
```
public TypeState assignableTypesState
```
    Stores the list of all assignable types for each analysis type. The assignable list is updated whenever a new subtype is created. This is used to filter the types assignable to a specific type from an input type state.
  - assignableTypesNonNullState
```
public TypeState assignableTypesNonNullState
```
  - instantiatedTypes
```
public AllInstantiatedTypeFlow instantiatedTypes
```
    Type flows containing all the instantiated sub-types. This is a sub set of the all assignable types. These flows are used for uses that need to be notified when a sub-type of a specific type is marked as instantiated, e.g., a saturated field access type flow needs to be notified when a sub-type of its declared type is marked as instantiated.
  - instantiatedTypesNonNull
```
public AllInstantiatedTypeFlow instantiatedTypesNonNull
```
- Constructor Detail
  - AnalysisType
```
public AnalysisType(AnalysisUniverse universe,
                    ResolvedJavaType javaType,
                    JavaKind storageKind,
                    AnalysisType objectType,
                    AnalysisType cloneableType)
```
- Method Detail
  - getArrayClass
```
public AnalysisType getArrayClass(int dim)
```
  - getArrayDimension
```
public int getArrayDimension()
```
  - cleanupAfterAnalysis
```
public void cleanupAfterAnalysis()
```
  - getId
```
public int getId()
```
  - getContextInsensitiveAnalysisObject
```
public AnalysisObject getContextInsensitiveAnalysisObject()
```
  - getUniqueConstantObject
```
public AnalysisObject getUniqueConstantObject()
```
  - getCachedConstantObject
```
public AnalysisObject getCachedConstantObject(PointsToAnalysis bb,
                                              JavaConstant constant,
                                              Function<JavaConstant,AnalysisObject> constantTransformer)
```
  - getTypeFlow
```
public AllInstantiatedTypeFlow getTypeFlow(BigBang bb,
                                           boolean includeNull)
```
  - getAssignableTypes
```
public TypeState getAssignableTypes(boolean includeNull)
```
    Returns the assignable types. Assignable types are updated on analysis type creation. The types in this list are not guaranteed to be instantiated and should only be used for filter operations.
  - verifyAssignableTypes
```
public static boolean verifyAssignableTypes(BigBang bb)
```
  - registerAsInHeap
```
public boolean registerAsInHeap(Object reason)
```
    Parameters:
    
    reason - the BytecodePosition where this type is marked as in-heap, or a ObjectScanner.ScanReason, or a String describing why this type was manually marked as in-heap
  - registerAsAllocated
```
public boolean registerAsAllocated(Object reason)
```
    Parameters:
    
    reason - the BytecodePosition where this type is marked as allocated, or a ObjectScanner.ScanReason, or a String describing why this type was manually marked as allocated
  - onInstantiated
```
protected void onInstantiated(AnalysisType.UsageKind usage)
```
  - registerAsAssignable
```
public void registerAsAssignable(BigBang bb)
```
    Register the type as assignable with all its super types. This is a blocking call to ensure that the type is registered with all its super types before it is propagated by the analysis through type flows.
  - registerAsReachable
```
public boolean registerAsReachable(Object reason)
```
  - onReachable
```
protected void onReachable()
```
    Specified by:
    
    onReachable in class AnalysisElement
  - registerSubtypeReachabilityNotification
```
public void registerSubtypeReachabilityNotification(AnalysisElement.SubtypeReachableNotification notification)
```
  - registerOverrideReachabilityNotification
```
public void registerOverrideReachabilityNotification(AnalysisMethod declaredMethod,
                                                     AnalysisElement.MethodOverrideReachableNotification notification)
```
  - getOverrideReachabilityNotifications
```
public Set<AnalysisElement.MethodOverrideReachableNotification> getOverrideReachabilityNotifications(AnalysisMethod method)
```
  - registerInstantiatedCallback
```
public void registerInstantiatedCallback(Consumer<org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess> callback)
```
  - notifyInstantiatedCallbacks
```
protected void notifyInstantiatedCallbacks()
```
  - forAllSuperTypes
```
public void forAllSuperTypes(Consumer<AnalysisType> superTypeConsumer)
```
    Iterates all super types for this type, where a super type is defined as any type that is assignable from this type, feeding each of them to the consumer. For a class B extends A, the array type A[] is not a superclass of the array type B[]. So there is no strict need to make A[] reachable when B[] is reachable. But it turns out that this is puzzling for users, and there are frameworks that instantiate such arrays programmatically using Array.newInstance(). To reduce the amount of manual configuration that is necessary, we mark all array types of the elemental supertypes and superinterfaces also as reachable. Moreover, even if B extends A doesn't imply that B[] extends A[] it does imply that A[].isAssignableFrom(B[]). NOTE: This method doesn't guarantee that a super type will only be processed once. For example when java.lang.Class is processed its interface java.lang.reflect.AnnotatedElement is reachable directly, but also through java.lang.GenericDeclaration, so it will be processed twice.
  - forAllSuperTypes
```
protected void forAllSuperTypes(Consumer<AnalysisType> superTypeConsumer,
                                boolean includeThisType)
```
  - addAssignableType
```
protected void addAssignableType(BigBang bb,
                                 TypeState typeState)
```
  - getOrComputeData
```
public TypeData getOrComputeData()
```
  - ensureOnTypeReachableTaskDone
```
public void ensureOnTypeReachableTaskDone()
```
  - getInitializeMetaDataTask
```
public AnalysisFuture<Void> getInitializeMetaDataTask()
```
  - 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,
                                        com.oracle.svm.util.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(com.oracle.svm.util.UnsafePartitionKind partitionKind)
```
  - isInstantiated
```
public boolean isInstantiated()
```
  - isAnySubtypeInstantiated
```
public boolean isAnySubtypeInstantiated()
```
    Returns true if this type or any of its subtypes was marked as instantiated.
  - 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()
```
    Specified by:
    
    isReachable in class AnalysisElement
  - getReachableReason
```
public Object getReachableReason()
```
  - getStorageKind
```
public final 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 ResolvedJavaType getWrapped()
```
    Specified by:
    
    getWrapped in interface WrappedElement
    
    Specified by:
    
    getWrapped in interface WrappedJavaType
    
    Specified by:
    
    getWrapped in class AnalysisElement
  - getWrappedWithResolve
```
public ResolvedJavaType getWrappedWithResolve()
```
  - getJavaClass
```
public Class<?> getJavaClass()
```
    Specified by:
    
    getJavaClass in interface OriginalClassProvider
  - getName
```
public final String getName()
```
  - toJavaName
```
public String toJavaName()
```
  - toJavaName
```
public String toJavaName(boolean qualified)
```
  - getJavaKind
```
public final JavaKind getJavaKind()
```
  - resolve
```
public final AnalysisType resolve(ResolvedJavaType accessingClass)
```
  - hasFinalizer
```
public final boolean hasFinalizer()
```
  - hasFinalizableSubclass
```
public final <any> hasFinalizableSubclass()
```
  - isInitialized
```
public final boolean isInitialized()
```
  - initialize
```
public void initialize()
```
  - getArrayClass
```
public final AnalysisType getArrayClass()
```
  - isInterface
```
public boolean isInterface()
```
  - isEnum
```
public boolean isEnum()
```
  - isInstanceClass
```
public boolean isInstanceClass()
```
  - isArray
```
public boolean isArray()
```
  - isJavaLangObject
```
public boolean isJavaLangObject()
```
  - isPrimitive
```
public boolean isPrimitive()
```
  - getModifiers
```
public int getModifiers()
```
  - isAssignableFrom
```
public boolean isAssignableFrom(ResolvedJavaType other)
```
  - isInstance
```
public boolean isInstance(JavaConstant obj)
```
  - getSuperclass
```
public AnalysisType getSuperclass()
```
  - getInterfaces
```
public AnalysisType[] getInterfaces()
```
  - getSingleImplementor
```
public ResolvedJavaType getSingleImplementor()
```
  - getSubTypes
```
public Set<AnalysisType> getSubTypes()
```
    Get the immediate subtypes, including this type itself.
  - getAllSubtypes
```
public Set<AnalysisType> getAllSubtypes()
```
    Collects and returns *all* subtypes of this type, not only the immediate subtypes, including this type itself, regardless of reachability status. To access the immediate subtypes use AnalysisType.getSubTypes(). Since the subtypes are updated continuously as the universe is expanded this method may return different results on each call, until the analysis universe reaches a stable state.
  - findLeastCommonAncestor
```
public AnalysisType findLeastCommonAncestor(ResolvedJavaType otherType)
```
  - findLeafConcreteSubtype
```
public <any> findLeafConcreteSubtype()
```
  - getComponentType
```
public AnalysisType getComponentType()
```
  - getElementalType
```
public AnalysisType getElementalType()
```
  - hasSubTypes
```
public boolean hasSubTypes()
```
  - resolveMethod
```
public AnalysisMethod resolveMethod(ResolvedJavaMethod method,
                                    ResolvedJavaType callerType)
```
  - resolveConcreteMethod
```
public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method,
                                            ResolvedJavaType callerType)
```
  - resolveConcreteMethod
```
public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method)
```
    Wrapper for resolveConcreteMethod() without the callerType parameter. We ignore the callerType parameter and use substMethod.getDeclaringClass() instead since we don't want any access checks in the analysis.
  - findUniqueConcreteMethod
```
public <any> findUniqueConcreteMethod(ResolvedJavaMethod method)
```
  - findInstanceFieldWithOffset
```
public ResolvedJavaField findInstanceFieldWithOffset(long offset,
                                                     JavaKind expectedKind)
```
  - clearInstanceFieldsCache
```
public void clearInstanceFieldsCache()
```
  - getInstanceFields
```
public ResolvedJavaField[] getInstanceFields(boolean includeSuperclasses)
```
    Note that although this returns a ResolvedJavaField[], all instance fields are of type AnalysisField and can be casted to AnalysisField without problem.
  - getStaticFields
```
public ResolvedJavaField[] getStaticFields()
```
    Note that although this returns a ResolvedJavaField[], all instance fields are of type AnalysisField and can be casted to AnalysisField without problem.
  - getSourceFileName
```
public String getSourceFileName()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isLocal
```
public boolean isLocal()
```
  - isMember
```
public boolean isMember()
```
  - getEnclosingType
```
public AnalysisType getEnclosingType()
```
  - getDeclaredMethods
```
public ResolvedJavaMethod[] getDeclaredMethods()
```
  - getDeclaredMethods
```
public AnalysisMethod[] getDeclaredMethods(boolean forceLink)
```
  - getDeclaredConstructors
```
public ResolvedJavaMethod[] getDeclaredConstructors()
```
  - getDeclaredConstructors
```
public AnalysisMethod[] getDeclaredConstructors(boolean forceLink)
```
  - findMethod
```
public AnalysisMethod findMethod(String name,
                                 Signature signature)
```
  - getClassInitializer
```
public AnalysisMethod getClassInitializer()
```
  - isLinked
```
public boolean isLinked()
```
  - isInHeap
```
public boolean isInHeap()
```
  - getInHeapReason
```
public Object getInHeapReason()
```
  - isAllocated
```
public boolean isAllocated()
```
  - getAllocatedReason
```
public Object getAllocatedReason()
```
  - link
```
public void link()
```
  - hasDefaultMethods
```
public boolean hasDefaultMethods()
```
  - declaresDefaultMethods
```
public boolean declaresDefaultMethods()
```
  - isCloneableWithAllocation
```
public boolean isCloneableWithAllocation()
```
  - getHostClass
```
public ResolvedJavaType getHostClass()
```
  - getUniverse
```
public AnalysisUniverse getUniverse()
```
    Specified by:
    
    getUniverse in class AnalysisElement
  - 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

Nested classes/interfaces inherited from class com.oracle.graal.pointsto.meta.AnalysisElement

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.oracle.graal.pointsto.meta.AnalysisElement

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.reflect.AnnotatedElement

Field Detail

universe

assignableTypesState

assignableTypesNonNullState

instantiatedTypes

instantiatedTypesNonNull

Constructor Detail

AnalysisType

Method Detail

getArrayClass

getArrayDimension

cleanupAfterAnalysis

getId

getContextInsensitiveAnalysisObject

getUniqueConstantObject

getCachedConstantObject

getTypeFlow

getAssignableTypes

verifyAssignableTypes

registerAsInHeap

registerAsAllocated

onInstantiated

registerAsAssignable

registerAsReachable

onReachable

registerSubtypeReachabilityNotification

registerOverrideReachabilityNotification

getOverrideReachabilityNotifications

registerInstantiatedCallback

notifyInstantiatedCallbacks

forAllSuperTypes

forAllSuperTypes

addAssignableType

getOrComputeData

ensureOnTypeReachableTaskDone

getInitializeMetaDataTask

getReachabilityListenerNotified

setReachabilityListenerNotified

registerUnsafeFieldsRecomputed

registerUnsafeAccessedField

unsafeAccessedFields

unsafeAccessedFields

isInstantiated

isAnySubtypeInstantiated

unsafeFieldsRecomputed

isReachable

getReachableReason

getStorageKind

isWordType

getWrapped

getWrappedWithResolve

getJavaClass

getName

toJavaName

toJavaName

getJavaKind

resolve

hasFinalizer

hasFinalizableSubclass

isInitialized

initialize

getArrayClass

isInterface

isEnum

isInstanceClass

isArray

isJavaLangObject

isPrimitive

getModifiers

isAssignableFrom