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 final ClassDesc[] EMPTY_CLASS_DESC_ARRAY = new ClassDesc[0];

private static native void registerNatives();

static {

registerNatives();

}

/*

private Class(ClassLoader loader, Class<?> arrayComponentType) {

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

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

classLoader = loader;

componentType = arrayComponentType;

}

/**

public String toString() {

return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))

+ getName();

}

/**

@SuppressWarnings("preview")

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(' ');

}

if (isAnnotation()) {

sb.append('@');

}

if (isInterface()) { // Note: all annotation types 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();

}

}

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 forName0(className, true, ClassLoader.getClassLoader(caller), caller);

}

/**

@CallerSensitive

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

ClassLoader loader)

throws ClassNotFoundException

{

Class<?> caller = null;

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

// Reflective call to get caller class is only needed if a security manager

// is present. Avoid the overhead of making this call otherwise.

caller = Reflection.getCallerClass();

if (loader == null) {

ClassLoader ccl = ClassLoader.getClassLoader(caller);

if (ccl != null) {

sm.checkPermission(

SecurityConstants.GET_CLASSLOADER_PERMISSION);

}

}

}

return forName0(name, initialize, loader, caller);

}

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

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

ClassLoader loader,

Class<?> caller)

throws ClassNotFoundException;

/**

@CallerSensitive

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

Objects.requireNonNull(module);

Objects.requireNonNull(name);

ClassLoader cl;

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

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

if (caller != null && caller.getModule() != module) {

// if caller is null, Class.forName is the last java frame on the stack.

// java.base has all permissions

sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

}

PrivilegedAction<ClassLoader> pa = module::getClassLoader;

cl = AccessController.doPrivileged(pa);

} else {

cl = module.getClassLoader();

}

if (cl != null) {

return cl.loadClass(module, name);

} else {

return BootLoader.loadClass(module, name);

}

}

/**

@CallerSensitive

@Deprecated(since="9")

public T newInstance()

throws InstantiationException, IllegalAccessException

{

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), false);

}

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

java.security.AccessController.doPrivileged(

new java.security.PrivilegedAction<>() {

public Void run() {

c.setAccessible(true);

return null;

}

});

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;

/**

@HotSpotIntrinsicCandidate

public native boolean isInstance(Object obj);

/**

@HotSpotIntrinsicCandidate

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

/**

@HotSpotIntrinsicCandidate

public native boolean isInterface();

/**

@HotSpotIntrinsicCandidate

public native boolean isArray();

/**

@HotSpotIntrinsicCandidate

public native boolean isPrimitive();

/**

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();

/**

@CallerSensitive

@ForceInline // to ensure Reflection.getCallerClass optimization

public ClassLoader getClassLoader() {

ClassLoader cl = getClassLoader0();

if (cl == null)

return null;

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());

}

return cl;

}

// Package-private to allow ClassLoader access

ClassLoader getClassLoader0() { return classLoader; }

/**

public Module getModule() {

return module;

}

// set by VM

private transient Module module;

// Initialized in JVM not by private constructor

// This field is filtered from reflection access, i.e. getDeclaredField

// will throw NoSuchFieldException

private final ClassLoader classLoader;

// Set by VM

private transient Object classData;

// package-private

Object getClassData() {

return classData;

}

/**

@SuppressWarnings("unchecked")

public TypeVariable<Class<T>>[] getTypeParameters() {

ClassRepository info = getGenericInfo();

if (info != null)

return (TypeVariable<Class<T>>[])info.getTypeParameters();

else

return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];

}

/**

@HotSpotIntrinsicCandidate

public native Class<? super T> getSuperclass();

/**