HotSpotResolvedPrimitiveType (Graal OpenJDK Project Documentation)

java.lang.Object
- jdk.internal.jvmci.hotspot.HotSpotJavaType
- - jdk.internal.jvmci.hotspot.HotSpotResolvedJavaType
  - - jdk.internal.jvmci.hotspot.HotSpotResolvedPrimitiveType

All Implemented Interfaces:

HotSpotProxified, JavaType, ModifiersProvider, ResolvedJavaType, TrustedInterface
```
public final class HotSpotResolvedPrimitiveType
extends HotSpotResolvedJavaType
implements HotSpotProxified
```
Implementation of JavaType for primitive HotSpot types.

Field Summary

Fields
Modifier and Type Field and Description

private Kind kind
- Fields inherited from interface jdk.internal.jvmci.meta.ModifiersProvider
  ANNOTATION, BRIDGE, ENUM, MANDATED, SYNTHETIC, VARARGS

Fields
Modifier and Type	Field and Description
`private Kind`	`kind`

Constructor Summary

Constructors
Constructor and Description

HotSpotResolvedPrimitiveType(Kind kind)
Creates the JVMCI mirror for a primitive Kind.

Constructors
Constructor and Description
`HotSpotResolvedPrimitiveType(Kind kind)` Creates the JVMCI mirror for a primitive `Kind`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ResolvedJavaType`	`asExactType()` Returns this type if it is an exact type otherwise returns null.
`ResolvedJavaField`	`findInstanceFieldWithOffset(long offset, Kind expectedType)` Returns the instance field of this class (or one of its super classes) at the given offset, or `null` if there is no such field.
`Assumptions.AssumptionResult<ResolvedJavaType>`	`findLeafConcreteSubtype()` Attempts to get a leaf concrete subclass of this type.
`ResolvedJavaType`	`findLeastCommonAncestor(ResolvedJavaType otherType)` Walks the class hierarchy upwards and returns the least common class that is a superclass of both the current and the given type.
`Assumptions.AssumptionResult<ResolvedJavaMethod>`	`findUniqueConcreteMethod(ResolvedJavaMethod method)` Given a `ResolvedJavaMethod` A, returns a concrete `ResolvedJavaMethod` B that is the only possible unique target for a virtual call on A().
`<T extends Annotation> T`	`getAnnotation(Class<T> annotationClass)` Returns the annotation for the specified type of this class, if such an annotation is present.
`HotSpotResolvedObjectTypeImpl`	`getArrayClass()` Gets the array class type representing an array with elements of this type.
`URL`	`getClassFilePath()` Returns the class file path - if available - of this type, or `null`.
`ResolvedJavaMethod`	`getClassInitializer()` Returns the `<clinit>` method for this class if there is one.
`ResolvedJavaType`	`getComponentType()` For array types, gets the type of the components, or `null` if this is not an array type.
`ResolvedJavaMethod[]`	`getDeclaredConstructors()` Returns an array reflecting all the constructors declared by this type.
`ResolvedJavaMethod[]`	`getDeclaredMethods()` Returns an array reflecting all the methods declared by this type.
`ResolvedJavaType`	`getElementalType()` Gets the elemental type for this given type.
`ResolvedJavaType`	`getEnclosingType()` Returns the enclosing type of this type, if it exists, or `null`.
`ResolvedJavaField[]`	`getInstanceFields(boolean includeSuperclasses)` Returns the instance fields of this class, including internal fields.
`ResolvedJavaType[]`	`getInterfaces()` Gets the interfaces implemented or extended by this type.
`JavaConstant`	`getJavaClass()` Gets the runtime representation of the Java class object of this type.
`Kind`	`getKind()` Gets the kind of this type.
`int`	`getModifiers()` Returns the Java Virtual Machine modifiers for this element.
`JavaConstant`	`getObjectHub()` Gets the runtime representation of the "hub" of this type--that is, the closest part of the type representation which is typically stored in the object header.
`ResolvedJavaType`	`getSingleImplementor()` Gets the single implementor of this type.
`String`	`getSourceFileName()` Returns name of source file of this type.
`ResolvedJavaField[]`	`getStaticFields()` Returns the static fields of this class, including internal fields.
`ResolvedJavaType`	`getSuperclass()` Gets the super class of this type.
`Assumptions.AssumptionResult<Boolean>`	`hasFinalizableSubclass()` Checks whether this type has any finalizable subclasses so far.
`boolean`	`hasFinalizer()` Checks whether this type has a finalizer method.
`void`	`initialize()` Initializes this type.
`boolean`	`isArray()` Checks whether this type is an array class.
`boolean`	`isAssignableFrom(ResolvedJavaType other)` Determines if this type is either the same as, or is a superclass or superinterface of, the type represented by the specified parameter.
`boolean`	`isInitialized()` Checks whether this type is initialized.
`boolean`	`isInstance(JavaConstant obj)` Checks whether the specified object is an instance of this type.
`boolean`	`isInstanceClass()` Checks whether this type is an instance class.
`boolean`	`isInterface()` Checks whether this type is an interface.
`boolean`	`isJavaLangObject()` Returns true if this type is exactly the type `Object`.
`boolean`	`isLinked()` Checks whether this type is linked and verified.
`boolean`	`isLocal()` Returns `true` if the type is a local type.
`boolean`	`isMember()` Returns `true` if the type is a member type.
`boolean`	`isPrimitive()` Checks whether this type is primitive.
`boolean`	`isTrustedInterfaceType()` Returns true if this type represents an interface and it should be trusted even in places where the JVM verifier would not give any guarantees other than `Object`.
`Class<?>`	`mirror()`
`ResolvedJavaType`	`resolve(ResolvedJavaType accessingClass)` Resolves this type to a `ResolvedJavaType`.
`ResolvedJavaMethod`	`resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJavaType callerType)` Resolves the method implementation for virtual dispatches on objects of this dynamic type.
`ResolvedJavaMethod`	`resolveMethod(ResolvedJavaMethod method, ResolvedJavaType callerType)` Resolves the method implementation for virtual dispatches on objects of this dynamic type.
`String`	`toString()`

Methods inherited from class jdk.internal.jvmci.hotspot.HotSpotResolvedJavaType
equals, fromClass, hashCode

Methods inherited from class jdk.internal.jvmci.hotspot.HotSpotJavaType
getName

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

Methods inherited from interface jdk.internal.jvmci.meta.ResolvedJavaType
findMethod, isLeaf

Methods inherited from interface jdk.internal.jvmci.meta.JavaType
getName, getUnqualifiedName, toClassName, toJavaName, toJavaName

Methods inherited from interface jdk.internal.jvmci.meta.ModifiersProvider
isAbstract, isConcrete, isFinalFlagSet, isNative, isPackagePrivate, isPrivate, isProtected, isPublic, isStatic, isStrict, isSynchronized, isTransient, isVolatile, jvmClassModifiers, jvmFieldModifiers, jvmMethodModifiers

- Field Detail
  - kind
```
private final Kind kind
```
- Constructor Detail
  - HotSpotResolvedPrimitiveType
```
public HotSpotResolvedPrimitiveType(Kind kind)
```
    Creates the JVMCI mirror for a primitive Kind.
    NOTE: Creating an instance of this class does not install the mirror for the Class type. Use HotSpotResolvedJavaType.fromClass(Class) instead.
    
    Parameters:
    
    kind - the Kind to create the mirror for
- Method Detail
  - getModifiers
```
public int getModifiers()
```
    Description copied from interface: ResolvedJavaType
    
    Returns the Java Virtual Machine modifiers for this element. Note that this can differ from standard Java Reflection modifiers. For example at the JVM level, classes ( ResolvedJavaType) can not be private or protected.
    Only the flags specified in the JVM specification will be included in the returned mask. This method is identical to Class.getModifiers() in terms of the value return for this type.
    
    Specified by:
    
    getModifiers in interface ModifiersProvider
    
    Specified by:
    
    getModifiers in interface ResolvedJavaType
  - getArrayClass
```
public HotSpotResolvedObjectTypeImpl getArrayClass()
```
    Description copied from interface: JavaType
    
    Gets the array class type representing an array with elements of this type.
    
    Specified by:
    
    getArrayClass in interface JavaType
    
    Specified by:
    
    getArrayClass in interface ResolvedJavaType
  - getElementalType
```
public ResolvedJavaType getElementalType()
```
    Description copied from interface: JavaType
    
    Gets the elemental type for this given type. The elemental type is the corresponding zero dimensional type of an array type. For example, the elemental type of int[][][] is int. A non-array type is its own elemental type.
    
    Specified by:
    
    getElementalType in interface JavaType
    
    Specified by:
    
    getElementalType in interface ResolvedJavaType
  - getComponentType
```
public ResolvedJavaType getComponentType()
```
    Description copied from interface: JavaType
    
    For array types, gets the type of the components, or null if this is not an array type. This method is analogous to Class.getComponentType().
    
    Specified by:
    
    getComponentType in interface JavaType
    
    Specified by:
    
    getComponentType in interface ResolvedJavaType
  - asExactType
```
public ResolvedJavaType asExactType()
```
    Description copied from interface: ResolvedJavaType
    
    Returns this type if it is an exact type otherwise returns null. This type is exact if it is void, primitive, final, or an array of a final or primitive type.
    
    Specified by:
    
    asExactType in interface ResolvedJavaType
    
    Returns:
    
    this type if it is exact; null otherwise
  - getSuperclass
```
public ResolvedJavaType getSuperclass()
```
    Description copied from interface: ResolvedJavaType
    
    Gets the super class of this type. If this type represents either the Object class, an interface, a primitive type, or void, then null is returned. If this object represents an array class then the type object representing the Object class is returned.
    
    Specified by:
    
    getSuperclass in interface ResolvedJavaType
  - getInterfaces
```
public ResolvedJavaType[] getInterfaces()
```
    Description copied from interface: ResolvedJavaType
    
    Gets the interfaces implemented or extended by this type. This method is analogous to Class.getInterfaces() and as such, only returns the interfaces directly implemented or extended by this type.
    
    Specified by:
    
    getInterfaces in interface ResolvedJavaType
  - getSingleImplementor
```
public ResolvedJavaType getSingleImplementor()
```
    Description copied from interface: ResolvedJavaType
    
    Gets the single implementor of this type. Calling this method on a non-interface type causes an exception.
    If the compiler uses the result of this method for its compilation, the usage must be guarded because the verifier can not guarantee that the assigned type really implements this interface. Additionally, class loading can invalidate the result of this method.
    
    Specified by:
    
    getSingleImplementor in interface ResolvedJavaType
    
    Returns:
    
    null if there is no implementor, the implementor if there is only one, or this if there are more than one.
  - findLeastCommonAncestor
```
public ResolvedJavaType findLeastCommonAncestor(ResolvedJavaType otherType)
```
    Description copied from interface: ResolvedJavaType
    
    Walks the class hierarchy upwards and returns the least common class that is a superclass of both the current and the given type.
    
    Specified by:
    
    findLeastCommonAncestor in interface ResolvedJavaType
    
    Returns:
    
    the least common type that is a super type of both the current and the given type, or null if primitive types are involved.
  - getObjectHub
```
public JavaConstant getObjectHub()
```
    Description copied from interface: ResolvedJavaType
    
    Gets the runtime representation of the "hub" of this type--that is, the closest part of the type representation which is typically stored in the object header.
    
    Specified by:
    
    getObjectHub in interface ResolvedJavaType
  - getJavaClass
```
public JavaConstant getJavaClass()
```
    Description copied from interface: ResolvedJavaType
    
    Gets the runtime representation of the Java class object of this type.
    
    Specified by:
    
    getJavaClass in interface ResolvedJavaType
  - hasFinalizableSubclass
```
public Assumptions.AssumptionResult<Boolean> hasFinalizableSubclass()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type has any finalizable subclasses so far. Any decisions based on this information require the registration of a dependency, since this information may change.
    
    Specified by:
    
    hasFinalizableSubclass in interface ResolvedJavaType
    
    Returns:
    
    true if this class has any subclasses with finalizers
  - hasFinalizer
```
public boolean hasFinalizer()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type has a finalizer method.
    
    Specified by:
    
    hasFinalizer in interface ResolvedJavaType
    
    Returns:
    
    true if this class has a finalizer
  - isArray
```
public boolean isArray()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is an array class.
    
    Specified by:
    
    isArray in interface ResolvedJavaType
    
    Returns:
    
    true if this type is an array class
  - isPrimitive
```
public boolean isPrimitive()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is primitive.
    
    Specified by:
    
    isPrimitive in interface ResolvedJavaType
    
    Returns:
    
    true if this type is primitive
  - isInitialized
```
public boolean isInitialized()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is initialized. If a type is initialized it implies that it was linked and that the static initializer has run.
    
    Specified by:
    
    isInitialized in interface ResolvedJavaType
    
    Returns:
    
    true if this type is initialized
  - isLinked
```
public boolean isLinked()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is linked and verified. When a type is linked the static initializer has not necessarily run. An initialized type is always linked.
    
    Specified by:
    
    isLinked in interface ResolvedJavaType
    
    Returns:
    
    true if this type is linked
  - isInstance
```
public boolean isInstance(JavaConstant obj)
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether the specified object is an instance of this type.
    
    Specified by:
    
    isInstance in interface ResolvedJavaType
    
    Parameters:
    
    obj - the object to test
    
    Returns:
    
    true if the object is an instance of this type
  - isInstanceClass
```
public boolean isInstanceClass()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is an instance class.
    
    Specified by:
    
    isInstanceClass in interface ResolvedJavaType
    
    Returns:
    
    true if this type is an instance class
  - isInterface
```
public boolean isInterface()
```
    Description copied from interface: ResolvedJavaType
    
    Checks whether this type is an interface.
    
    Specified by:
    
    isInterface in interface ModifiersProvider
    
    Specified by:
    
    isInterface in interface ResolvedJavaType
    
    Returns:
    
    true if this type is an interface
    
    See Also:
    
    Modifier.isInterface(int)
  - isAssignableFrom
```
public boolean isAssignableFrom(ResolvedJavaType other)
```
    Description copied from interface: ResolvedJavaType
    
    Determines if this type is either the same as, or is a superclass or superinterface of, the type represented by the specified parameter. This method is identical to Class.isAssignableFrom(Class) in terms of the value return for this type.
    
    Specified by:
    
    isAssignableFrom in interface ResolvedJavaType
  - getKind
```
public Kind getKind()
```
    Description copied from interface: JavaType
    
    Gets the kind of this type.
    
    Specified by:
    
    getKind in interface JavaType
  - isJavaLangObject
```
public boolean isJavaLangObject()
```
    Description copied from interface: ResolvedJavaType
    
    Returns true if this type is exactly the type Object.
    
    Specified by:
    
    isJavaLangObject in interface ResolvedJavaType
  - resolveConcreteMethod
```
public ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method,
                                                ResolvedJavaType callerType)
```
    Description copied from interface: ResolvedJavaType
    
    Resolves the method implementation for virtual dispatches on objects of this dynamic type. This resolution process only searches "up" the class hierarchy of this type. A broader search that also walks "down" the hierarchy is implemented by ResolvedJavaType.findUniqueConcreteMethod(ResolvedJavaMethod).
    
    Specified by:
    
    resolveConcreteMethod in interface ResolvedJavaType
    
    Parameters:
    
    method - the method to select the implementation of
    
    callerType - the caller or context type used to perform access checks
    
    Returns:
    
    the concrete method that would be selected at runtime, or null if there is no concrete implementation of method in this type or any of its superclasses
  - resolveMethod
```
public ResolvedJavaMethod resolveMethod(ResolvedJavaMethod method,
                                        ResolvedJavaType callerType)
```
    Description copied from interface: ResolvedJavaType
    
    Resolves the method implementation for virtual dispatches on objects of this dynamic type. This resolution process only searches "up" the class hierarchy of this type.
    
    Specified by:
    
    resolveMethod in interface ResolvedJavaType
    
    Parameters:
    
    method - the method to select the implementation of
    
    callerType - the caller or context type used to perform access checks
    
    Returns:
    
    the link-time resolved method (might be abstract) or null if it can not be linked
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - findLeafConcreteSubtype
```
public Assumptions.AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype()
```
    Description copied from interface: ResolvedJavaType
    
    Attempts to get a leaf concrete subclass of this type.
    For an array type A, the leaf concrete subclass is A if the elemental type of A is final (which includes primitive types). Otherwise null is returned for A.
    For a non-array type T, the result is the leaf concrete type in the current hierarchy of T.
    A runtime may decide not to manage or walk a large hierarchy and so the result is conservative. That is, a non-null result is guaranteed to be the leaf concrete class in T's hierarchy at the current point in time but a null result does not necessarily imply that there is no leaf concrete class in T's hierarchy.
    If the compiler uses the result of this method for its compilation, it must register the Assumptions.AssumptionResult in its Assumptions because dynamic class loading can invalidate the result of this method.
    
    Specified by:
    
    findLeafConcreteSubtype in interface ResolvedJavaType
    
    Returns:
    
    an Assumptions.AssumptionResult containing the leaf concrete subclass for this type as described above
  - findUniqueConcreteMethod
```
public Assumptions.AssumptionResult<ResolvedJavaMethod> findUniqueConcreteMethod(ResolvedJavaMethod method)
```
    Description copied from interface: ResolvedJavaType
    
    Given a ResolvedJavaMethod A, returns a concrete ResolvedJavaMethod B that is the only possible unique target for a virtual call on A(). Returns null if either no such concrete method or more than one such method exists. Returns the method A if A is a concrete method that is not overridden.
    If the compiler uses the result of this method for its compilation, it must register an assumption because dynamic class loading can invalidate the result of this method.
    
    Specified by:
    
    findUniqueConcreteMethod in interface ResolvedJavaType
    
    Parameters:
    
    method - the method A for which a unique concrete target is searched
    
    Returns:
    
    the unique concrete target or null if no such target exists or assumptions are not supported by this runtime
  - getInstanceFields
```
public ResolvedJavaField[] getInstanceFields(boolean includeSuperclasses)
```
    Description copied from interface: ResolvedJavaType
    
    Returns the instance fields of this class, including internal fields. A zero-length array is returned for array and primitive types. The order of fields returned by this method is stable. That is, for a single JVM execution the same order is returned each time this method is called. It is also the "natural" order, which means that the JVM would expect the fields in this order if no specific order is given.
    
    Specified by:
    
    getInstanceFields in interface ResolvedJavaType
    
    Parameters:
    
    includeSuperclasses - if true, then instance fields for the complete hierarchy of this type are included in the result
    
    Returns:
    
    an array of instance fields
  - getStaticFields
```
public ResolvedJavaField[] getStaticFields()
```
    Description copied from interface: ResolvedJavaType
    
    Returns the static fields of this class, including internal fields. A zero-length array is returned for array and primitive types. The order of fields returned by this method is stable. That is, for a single JVM execution the same order is returned each time this method is called.
    
    Specified by:
    
    getStaticFields in interface ResolvedJavaType
  - getAnnotation
```
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
```
    Description copied from interface: ResolvedJavaType
    
    Returns the annotation for the specified type of this class, if such an annotation is present.
    
    Specified by:
    
    getAnnotation in interface ResolvedJavaType
    
    Parameters:
    
    annotationClass - the Class object corresponding to the annotation type
    
    Returns:
    
    this element's annotation for the specified annotation type if present on this class, else null
  - resolve
```
public ResolvedJavaType resolve(ResolvedJavaType accessingClass)
```
    Description copied from interface: JavaType
    
    Resolves this type to a ResolvedJavaType.
    
    Specified by:
    
    resolve in interface JavaType
    
    Parameters:
    
    accessingClass - the context of resolution (must not be null)
    
    Returns:
    
    the resolved Java type
  - initialize
```
public void initialize()
```
    Description copied from interface: ResolvedJavaType
    
    Initializes this type.
    
    Specified by:
    
    initialize in interface ResolvedJavaType
  - findInstanceFieldWithOffset
```
public ResolvedJavaField findInstanceFieldWithOffset(long offset,
                                                     Kind expectedType)
```
    Description copied from interface: ResolvedJavaType
    
    Returns the instance field of this class (or one of its super classes) at the given offset, or null if there is no such field.
    
    Specified by:
    
    findInstanceFieldWithOffset in interface ResolvedJavaType
    
    Parameters:
    
    offset - the offset of the field to look for
    
    Returns:
    
    the field with the given offset, or null if there is no such field.
  - getSourceFileName
```
public String getSourceFileName()
```
    Description copied from interface: ResolvedJavaType
    
    Returns name of source file of this type.
    
    Specified by:
    
    getSourceFileName in interface ResolvedJavaType
  - mirror
```
public Class<?> mirror()
```
    Specified by:
    
    mirror in class HotSpotResolvedJavaType
  - getClassFilePath
```
public URL getClassFilePath()
```
    Description copied from interface: ResolvedJavaType
    
    Returns the class file path - if available - of this type, or null.
    
    Specified by:
    
    getClassFilePath in interface ResolvedJavaType
  - isLocal
```
public boolean isLocal()
```
    Description copied from interface: ResolvedJavaType
    
    Returns true if the type is a local type.
    
    Specified by:
    
    isLocal in interface ResolvedJavaType
  - isMember
```
public boolean isMember()
```
    Description copied from interface: ResolvedJavaType
    
    Returns true if the type is a member type.
    
    Specified by:
    
    isMember in interface ResolvedJavaType
  - getEnclosingType
```
public ResolvedJavaType getEnclosingType()
```
    Description copied from interface: ResolvedJavaType
    
    Returns the enclosing type of this type, if it exists, or null.
    
    Specified by:
    
    getEnclosingType in interface ResolvedJavaType
  - getDeclaredConstructors
```
public ResolvedJavaMethod[] getDeclaredConstructors()
```
    Description copied from interface: ResolvedJavaType
    
    Returns an array reflecting all the constructors declared by this type. This method is similar to Class.getDeclaredConstructors() in terms of returned constructors.
    
    Specified by:
    
    getDeclaredConstructors in interface ResolvedJavaType
  - getDeclaredMethods
```
public ResolvedJavaMethod[] getDeclaredMethods()
```
    Description copied from interface: ResolvedJavaType
    
    Returns an array reflecting all the methods declared by this type. This method is similar to Class.getDeclaredMethods() in terms of returned methods.
    
    Specified by:
    
    getDeclaredMethods in interface ResolvedJavaType
  - getClassInitializer
```
public ResolvedJavaMethod getClassInitializer()
```
    Description copied from interface: ResolvedJavaType
    
    Returns the <clinit> method for this class if there is one.
    
    Specified by:
    
    getClassInitializer in interface ResolvedJavaType
  - isTrustedInterfaceType
```
public boolean isTrustedInterfaceType()
```
    Description copied from interface: ResolvedJavaType
    
    Returns true if this type represents an interface and it should be trusted even in places where the JVM verifier would not give any guarantees other than Object.
    
    Specified by:
    
    isTrustedInterfaceType in interface ResolvedJavaType

Class HotSpotResolvedPrimitiveType

Field Summary

Fields inherited from interface jdk.internal.jvmci.meta.ModifiersProvider

Constructor Summary

Method Summary

Methods inherited from class jdk.internal.jvmci.hotspot.HotSpotResolvedJavaType

Methods inherited from class jdk.internal.jvmci.hotspot.HotSpotJavaType

Methods inherited from class java.lang.Object

Methods inherited from interface jdk.internal.jvmci.meta.ResolvedJavaType

Methods inherited from interface jdk.internal.jvmci.meta.JavaType

Methods inherited from interface jdk.internal.jvmci.meta.ModifiersProvider

Field Detail

kind

Constructor Detail

HotSpotResolvedPrimitiveType

Method Detail

getModifiers

getArrayClass

getElementalType

getComponentType

asExactType

getSuperclass

getInterfaces

getSingleImplementor

findLeastCommonAncestor

getObjectHub

getJavaClass

hasFinalizableSubclass

hasFinalizer

isArray

isPrimitive

isInitialized

isLinked

isInstance

isInstanceClass

isInterface

isAssignableFrom

getKind

isJavaLangObject

resolveConcreteMethod

resolveMethod

toString

findLeafConcreteSubtype

findUniqueConcreteMethod

getInstanceFields

getStaticFields

getAnnotation

resolve

initialize

findInstanceFieldWithOffset

getSourceFileName

mirror

getClassFilePath

isLocal

isMember

getEnclosingType

getDeclaredConstructors

getDeclaredMethods

getClassInitializer

isTrustedInterfaceType