ResolvedJavaType (Graal OpenJDK Project Documentation)

All Superinterfaces:

JavaType, ModifiersProvider, TrustedInterface

All Known Subinterfaces:

HotSpotResolvedObjectType

All Known Implementing Classes:

HotSpotResolvedJavaType, HotSpotResolvedObjectTypeImpl, HotSpotResolvedPrimitiveType
```
public interface ResolvedJavaType
extends JavaType, ModifiersProvider
```
Represents a resolved Java type. Types include primitives, objects, void, and arrays thereof. Types, like fields and methods, are resolved through constant pools .

Field Summary
- Fields inherited from interface jdk.internal.jvmci.meta.ModifiersProvider
  ANNOTATION, BRIDGE, ENUM, MANDATED, SYNTHETIC, VARARGS

Method Summary

All Methods Instance Methods Abstract Methods Default 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 expectedKind)` 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.
`default ResolvedJavaMethod`	`findMethod(String name, Signature signature)`
`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.
`ResolvedJavaType`	`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.
`default 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.
`int`	`getModifiers()` Returns the Java Virtual Machine modifiers for this element.
`Constant`	`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.
`default boolean`	`isJavaLangObject()` Returns true if this type is exactly the type `Object`.
`default boolean`	`isLeaf()`
`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`.
`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.

Methods inherited from interface jdk.internal.jvmci.meta.JavaType
getKind, getName, getUnqualifiedName, resolve, 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

- Method Detail
  - getJavaClass
```
JavaConstant getJavaClass()
```
    Gets the runtime representation of the Java class object of this type.
  - getObjectHub
```
Constant 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.
  - hasFinalizer
```
boolean hasFinalizer()
```
    Checks whether this type has a finalizer method.
    
    Returns:
    
    true if this class has a finalizer
  - hasFinalizableSubclass
```
Assumptions.AssumptionResult<Boolean> hasFinalizableSubclass()
```
    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.
    
    Returns:
    
    true if this class has any subclasses with finalizers
  - isInterface
```
boolean isInterface()
```
    Checks whether this type is an interface.
    
    Specified by:
    
    isInterface in interface ModifiersProvider
    
    Returns:
    
    true if this type is an interface
    
    See Also:
    
    Modifier.isInterface(int)
  - isInstanceClass
```
boolean isInstanceClass()
```
    Checks whether this type is an instance class.
    
    Returns:
    
    true if this type is an instance class
  - isArray
```
boolean isArray()
```
    Checks whether this type is an array class.
    
    Returns:
    
    true if this type is an array class
  - isPrimitive
```
boolean isPrimitive()
```
    Checks whether this type is primitive.
    
    Returns:
    
    true if this type is primitive
  - getModifiers
```
int getModifiers()
```
    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
  - isLeaf
```
default boolean isLeaf()
```
  - isInitialized
```
boolean isInitialized()
```
    Checks whether this type is initialized. If a type is initialized it implies that it was linked and that the static initializer has run.
    
    Returns:
    
    true if this type is initialized
  - initialize
```
void initialize()
```
    Initializes this type.
  - isLinked
```
boolean isLinked()
```
    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.
    
    Returns:
    
    true if this type is linked
  - isAssignableFrom
```
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. This method is identical to Class.isAssignableFrom(Class) in terms of the value return for this type.
  - isJavaLangObject
```
default boolean isJavaLangObject()
```
    Returns true if this type is exactly the type Object.
  - isInstance
```
boolean isInstance(JavaConstant obj)
```
    Checks whether the specified object is an instance of this type.
    
    Parameters:
    
    obj - the object to test
    
    Returns:
    
    true if the object is an instance of this type
  - asExactType
```
ResolvedJavaType asExactType()
```
    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.
    
    Returns:
    
    this type if it is exact; null otherwise
  - getSuperclass
```
ResolvedJavaType getSuperclass()
```
    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.
  - getInterfaces
```
ResolvedJavaType[] getInterfaces()
```
    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.
  - getSingleImplementor
```
ResolvedJavaType getSingleImplementor()
```
    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.
    
    Returns:
    
    null if there is no implementor, the implementor if there is only one, or this if there are more than one.
  - findLeastCommonAncestor
```
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.
    
    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.
  - findLeafConcreteSubtype
```
Assumptions.AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype()
```
    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.
    
    Returns:
    
    an Assumptions.AssumptionResult containing the leaf concrete subclass for this type as described above
  - getComponentType
```
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
  - getElementalType
```
default 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
  - getArrayClass
```
ResolvedJavaType 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
  - resolveMethod
```
ResolvedJavaMethod resolveMethod(ResolvedJavaMethod method,
                                 ResolvedJavaType callerType)
```
    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.
    
    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
  - resolveConcreteMethod
```
ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method,
                                         ResolvedJavaType callerType)
```
    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 findUniqueConcreteMethod(ResolvedJavaMethod).
    
    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
  - findUniqueConcreteMethod
```
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(). 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.
    
    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
```
ResolvedJavaField[] getInstanceFields(boolean includeSuperclasses)
```
    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.
    
    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
```
ResolvedJavaField[] getStaticFields()
```
    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.
  - getAnnotation
```
<T extends Annotation> T getAnnotation(Class<T> annotationClass)
```
    Returns the annotation for the specified type of this class, if such an annotation is present.
    
    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
  - findInstanceFieldWithOffset
```
ResolvedJavaField findInstanceFieldWithOffset(long offset,
                                              Kind expectedKind)
```
    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.
    
    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
```
String getSourceFileName()
```
    Returns name of source file of this type.
  - getClassFilePath
```
URL getClassFilePath()
```
    Returns the class file path - if available - of this type, or null.
  - isLocal
```
boolean isLocal()
```
    Returns true if the type is a local type.
  - isMember
```
boolean isMember()
```
    Returns true if the type is a member type.
  - getEnclosingType
```
ResolvedJavaType getEnclosingType()
```
    Returns the enclosing type of this type, if it exists, or null.
  - getDeclaredConstructors
```
ResolvedJavaMethod[] getDeclaredConstructors()
```
    Returns an array reflecting all the constructors declared by this type. This method is similar to Class.getDeclaredConstructors() in terms of returned constructors.
  - getDeclaredMethods
```
ResolvedJavaMethod[] getDeclaredMethods()
```
    Returns an array reflecting all the methods declared by this type. This method is similar to Class.getDeclaredMethods() in terms of returned methods.
  - getClassInitializer
```
ResolvedJavaMethod getClassInitializer()
```
    Returns the <clinit> method for this class if there is one.
  - isTrustedInterfaceType
```
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.
  - findMethod
```
default ResolvedJavaMethod findMethod(String name,
                                      Signature signature)
```

Interface ResolvedJavaType

Field Summary

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

Method Summary

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

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

Method Detail

getJavaClass

getObjectHub

hasFinalizer

hasFinalizableSubclass

isInterface

isInstanceClass

isArray

isPrimitive

getModifiers

isLeaf

isInitialized

initialize

isLinked

isAssignableFrom

isJavaLangObject

isInstance

asExactType

getSuperclass

getInterfaces

getSingleImplementor

findLeastCommonAncestor

findLeafConcreteSubtype

getComponentType

getElementalType

getArrayClass

resolveMethod

resolveConcreteMethod

findUniqueConcreteMethod

getInstanceFields

getStaticFields

getAnnotation

findInstanceFieldWithOffset

getSourceFileName

getClassFilePath

isLocal

isMember

getEnclosingType

getDeclaredConstructors

getDeclaredMethods

getClassInitializer

isTrustedInterfaceType

findMethod