GenericDeclaration,

Type,

AnnotatedElement,

TypeDescriptor.OfField<Class<?>>,

Constable {

private static final int ANNOTATION = 0x00002000;

private static final int ENUM = 0x00004000;

private static final int SYNTHETIC = 0x00001000;

private static native void registerNatives();

static {

runtimeSetup();

}

/// No significant static final fields; [#resetArchivedStates()] handles

/// prevents storing [#reflectionFactory] into AOT image.

@AOTRuntimeSetup

private static void runtimeSetup() {

registerNatives();

}

/*

private Class(ClassLoader loader, Class<?> arrayComponentType, char mods, ProtectionDomain pd, boolean isPrim, char flags) {

// Initialize final field for classLoader. The initialization value of non-null

// prevents future JIT optimizations from assuming this final field is null.

// The following assignments are done directly by the VM without calling this constructor.

classLoader = loader;

componentType = arrayComponentType;

modifiers = mods;

protectionDomain = pd;

primitive = isPrim;

classFileAccessFlags = flags;

}

/**

public String toString() {

String kind = isInterface() ? "interface " : isPrimitive() ? "" : "class ";

return kind.concat(getName());

}

/**

public String toGenericString() {

if (isPrimitive()) {

return toString();

} else {

StringBuilder sb = new StringBuilder();

Class<?> component = this;

int arrayDepth = 0;

if (isArray()) {

do {

arrayDepth++;

component = component.getComponentType();

} while (component.isArray());

sb.append(component.getName());

} else {

// Class modifiers are a superset of interface modifiers

int modifiers = getModifiers() & Modifier.classModifiers();

if (modifiers != 0) {

sb.append(Modifier.toString(modifiers));

sb.append(' ');

}

// A class cannot be strictfp and sealed/non-sealed so

// it is sufficient to check for sealed-ness after all

// modifiers are printed.

addSealingInfo(modifiers, sb);

if (isAnnotation()) {

sb.append('@');

}

if (isInterface()) { // Note: all annotation interfaces are interfaces

sb.append("interface");

} else {

if (isEnum())

sb.append("enum");

else if (isRecord())

sb.append("record");

else

sb.append("class");

}

sb.append(' ');

sb.append(getName());

}

TypeVariable<?>[] typeparms = component.getTypeParameters();

if (typeparms.length > 0) {

sb.append(Arrays.stream(typeparms)

.map(Class::typeVarBounds)

.collect(Collectors.joining(",", "<", ">")));

}

if (arrayDepth > 0) sb.append("[]".repeat(arrayDepth));

return sb.toString();

}

}

private void addSealingInfo(int modifiers, StringBuilder sb) {

// A class can be final XOR sealed XOR non-sealed.

if (Modifier.isFinal(modifiers)) {

return; // no-op

} else {

if (isSealed()) {

sb.append("sealed ");

return;

} else {

// Check for sealed ancestor, which implies this class

// is non-sealed.

if (hasSealedAncestor(this)) {

sb.append("non-sealed ");

}

}

}

}

private boolean hasSealedAncestor(Class<?> clazz) {

// From JLS 8.1.1.2:

// "It is a compile-time error if a class has a sealed direct

// superclass or a sealed direct superinterface, and is not

// declared final, sealed, or non-sealed either explicitly or

// implicitly.

// Thus, an effect of the sealed keyword is to force all

// direct subclasses to explicitly declare whether they are

// final, sealed, or non-sealed. This avoids accidentally

// exposing a sealed class hierarchy to unwanted subclassing."

// Therefore, will just check direct superclass and

// superinterfaces.

var superclass = clazz.getSuperclass();

if (superclass != null && superclass.isSealed()) {

return true;

}

for (var superinterface : clazz.getInterfaces()) {

if (superinterface.isSealed()) {

return true;

}

}

return false;

}

static String typeVarBounds(TypeVariable<?> typeVar) {

Type[] bounds = typeVar.getBounds();

if (bounds.length == 1 && bounds[0].equals(Object.class)) {

return typeVar.getName();

} else {

return typeVar.getName() + " extends " +

Arrays.stream(bounds)

.map(Type::getTypeName)

.collect(Collectors.joining(" & "));

}

}

/**

@CallerSensitive

public static Class<?> forName(String className)

throws ClassNotFoundException {

Class<?> caller = Reflection.getCallerClass();

return forName(className, caller);

}

// Caller-sensitive adapter method for reflective invocation

@CallerSensitiveAdapter

private static Class<?> forName(String className, Class<?> caller)

throws ClassNotFoundException {

validateClassNameLength(className);

ClassLoader loader = (caller == null) ? ClassLoader.getSystemClassLoader()

: ClassLoader.getClassLoader(caller);

return forName0(className, true, loader);

}

/**

public static Class<?> forName(String name, boolean initialize, ClassLoader loader)

throws ClassNotFoundException

{

validateClassNameLength(name);

return forName0(name, initialize, loader);

}

/** Called after security check for system loader access checks have been made. */

private static native Class<?> forName0(String name, boolean initialize,

ClassLoader loader)

throws ClassNotFoundException;

/**

public static Class<?> forName(Module module, String name) {

Objects.requireNonNull(module);

Objects.requireNonNull(name);

if (!ModifiedUtf.isValidLengthInConstantPool(name)) {

return null;

}

ClassLoader cl = module.getClassLoader();

if (cl != null) {

return cl.loadClass(module, name);

} else {

return BootLoader.loadClass(module, name);

}

}

/**

public static Class<?> forPrimitiveName(String primitiveName) {

return switch(primitiveName) {

// Integral types

case "int" -> int.class;

case "long" -> long.class;

case "short" -> short.class;

case "char" -> char.class;

case "byte" -> byte.class;

// Floating-point types

case "float" -> float.class;

case "double" -> double.class;

// Other types

case "boolean" -> boolean.class;

case "void" -> void.class;

default -> null;

};

}

/**

@CallerSensitive

@Deprecated(since="9")

public T newInstance()

throws InstantiationException, IllegalAccessException

{

// Constructor lookup

Constructor<T> tmpConstructor = cachedConstructor;

if (tmpConstructor == null) {

if (this == Class.class) {

throw new IllegalAccessException(

"Can not call newInstance() on the Class for java.lang.Class"

);

}

try {

Class<?>[] empty = {};

final Constructor<T> c = getReflectionFactory().copyConstructor(

getConstructor0(empty, Member.DECLARED));

// Disable accessibility checks on the constructor

// access check is done with the true caller

c.setAccessible(true);

cachedConstructor = tmpConstructor = c;

} catch (NoSuchMethodException e) {

throw (InstantiationException)

new InstantiationException(getName()).initCause(e);

}

}

try {

Class<?> caller = Reflection.getCallerClass();

return getReflectionFactory().newInstance(tmpConstructor, null, caller);

} catch (InvocationTargetException e) {

Unsafe.getUnsafe().throwException(e.getTargetException());

// Not reached

return null;

}

}

private transient volatile Constructor<T> cachedConstructor;

/**

@IntrinsicCandidate

public native boolean isInstance(Object obj);

/**

@IntrinsicCandidate

public native boolean isAssignableFrom(Class<?> cls);

/**

public boolean isInterface() {

return Modifier.isInterface(modifiers);

}

/**

public boolean isArray() {

return componentType != null;

}

/**

public boolean isPrimitive() {

return primitive;

}

/**

public boolean isAnnotation() {

return (getModifiers() & ANNOTATION) != 0;

}

/**

public boolean isSynthetic() {

return (getModifiers() & SYNTHETIC) != 0;

}

/**

public String getName() {

String name = this.name;

return name != null ? name : initClassName();

}

// Cache the name to reduce the number of calls into the VM.

// This field would be set by VM itself during initClassName call.

private transient String name;

private native String initClassName();

/**

public ClassLoader getClassLoader() {

return classLoader;

}

// Package-private to allow ClassLoader access

ClassLoader getClassLoader0() { return classLoader; }

/**