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
`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`

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)`
`TypeState`	`getAssignableTypes(boolean includeNull)` Returns the assignable types.
`AnalysisObject`	`getCachedConstantObject(PointsToAnalysis 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()`
`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).
`Set<AnalysisType>`	`getSubTypes()` Get the immediate subtypes, including this type itself.
`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()`
`boolean`	`registerAsAllocated(org.graalvm.compiler.graph.Node node)`
`void`	`registerAsAssignable(BigBang bb)` Register the type as assignable with all its super types.
`boolean`	`registerAsInHeap()`
`boolean`	`registerAsReachable()`
`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(jdk.vm.ci.meta.ResolvedJavaType accessingClass)`
`AnalysisMethod`	`resolveConcreteMethod(jdk.vm.ci.meta.ResolvedJavaMethod method)` Wrapper for resolveConcreteMethod() without 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(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 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
```
  - 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
```
- 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(PointsToAnalysis bb,
                                              jdk.vm.ci.meta.JavaConstant constant)
```
  - 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()
```
  - registerAsAllocated
```
public boolean registerAsAllocated(org.graalvm.compiler.graph.Node node)
```
    Parameters:
    
    node - For future use and debugging
  - 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()
```
  - 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,
                                        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()
```
  - 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
  - getSubTypes
```
public Set<AnalysisType> getSubTypes()
```
    Get the immediate subtypes, including this type itself.
  - 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,
                                            jdk.vm.ci.meta.ResolvedJavaType callerType)
```
    Specified by:
    
    resolveConcreteMethod in interface jdk.vm.ci.meta.ResolvedJavaType
  - resolveConcreteMethod
```
public AnalysisMethod resolveConcreteMethod(jdk.vm.ci.meta.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 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

assignableTypesState

assignableTypesNonNullState

instantiatedTypes

instantiatedTypesNonNull

Method Detail

getArrayClass

cleanupAfterAnalysis

getId

getContextInsensitiveAnalysisObject

getUniqueConstantObject

getCachedConstantObject

getTypeFlow

getAssignableTypes

verifyAssignableTypes

registerAsInHeap

registerAsAllocated

registerAsAssignable

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

getSubTypes

findLeastCommonAncestor

findLeafConcreteSubtype

getComponentType

getElementalType

hasSubTypes

resolveMethod

resolveConcreteMethod

resolveConcreteMethod

findUniqueConcreteMethod

findInstanceFieldWithOffset

clearInstanceFieldsCache

getInstanceFields

getStaticFields

getAnnotations

getDeclaredAnnotations