< prev index next >
src/java.base/share/classes/java/lang/Class.java
Print this page
rev 58565 : 8238358: Implementation of JEP 371: Hidden Classes
Reviewed-by: duke
Contributed-by: mandy.chung@oracle.com, lois.foltan@oracle.com, david.holmes@oracle.com, harold.seigel@oracle.com, serguei.spitsyn@oracle.com, alex.buckley@oracle.com, jamsheed.c.m@oracle.com
rev 58567 : [mq]: rename-isHidden
rev 58569 : imported patch hidden-class-3-jdarcy
*** 26,35 ****
--- 26,36 ----
package java.lang;
import java.lang.annotation.Annotation;
import java.lang.constant.ClassDesc;
import java.lang.invoke.TypeDescriptor;
+ import java.lang.invoke.MethodHandles;
import java.lang.module.ModuleReader;
import java.lang.ref.SoftReference;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamField;
*** 61,72 ****
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
- import java.util.StringJoiner;
- import java.util.stream.Stream;
import java.util.stream.Collectors;
import jdk.internal.HotSpotIntrinsicCandidate;
import jdk.internal.loader.BootLoader;
import jdk.internal.loader.BuiltinClassLoader;
--- 62,71 ----
*** 98,134 ****
* ({@code boolean}, {@code byte}, {@code char}, {@code short}, {@code
* int}, {@code long}, {@code float}, and {@code double}), and the
* keyword {@code void} are also represented as {@code Class} objects.
*
* <p> {@code Class} has no public constructor. Instead a {@code Class}
! * object is constructed automatically by the Java Virtual Machine
! * when a class loader invokes one of the
! * {@link ClassLoader#defineClass(String,byte[], int,int) defineClass} methods
! * and passes the bytes of a {@code class} file.
*
* <p> The methods of class {@code Class} expose many characteristics of a
* class or interface. Most characteristics are derived from the {@code class}
! * file that the class loader passed to the Java Virtual Machine. A few
! * characteristics are determined by the class loading environment at run time,
! * such as the module returned by {@link #getModule() getModule()}.
! *
! * <p> Some methods of class {@code Class} expose whether the declaration of
! * a class or interface in Java source code was <em>enclosed</em> within
! * another declaration. Other methods describe how a class or interface
! * is situated in a <em>nest</em>. A <a id="nest">nest</a> is a set of
! * classes and interfaces, in the same run-time package, that
! * allow mutual access to their {@code private} members.
! * The classes and interfaces are known as <em>nestmates</em>.
! * One nestmate acts as the
! * <em>nest host</em>, and enumerates the other nestmates which
! * belong to the nest; each of them in turn records it as the nest host.
! * The classes and interfaces which belong to a nest, including its host, are
! * determined when
! * {@code class} files are generated, for example, a Java compiler
! * will typically record a top-level class as the host of a nest where the
! * other members are the classes and interfaces whose declarations are
! * enclosed within the top-level class declaration.
*
* <p> The following example uses a {@code Class} object to print the
* class name of an object:
*
* <blockquote><pre>
--- 97,124 ----
* ({@code boolean}, {@code byte}, {@code char}, {@code short}, {@code
* int}, {@code long}, {@code float}, and {@code double}), and the
* keyword {@code void} are also represented as {@code Class} objects.
*
* <p> {@code Class} has no public constructor. Instead a {@code Class}
! * object is constructed automatically by the Java Virtual Machine when
! * a class is derived from the bytes of a {@code class} file through
! * the invocation of one of the following methods:
! * <ul>
! * <li> {@link ClassLoader#defineClass(String, byte[], int, int) ClassLoader::defineClass}
! * <li> {@link java.lang.invoke.MethodHandles.Lookup#defineClass(byte[])
! * java.lang.invoke.MethodHandles.Lookup::defineClass}
! * <li> {@link java.lang.invoke.MethodHandles.Lookup#defineHiddenClass(byte[], boolean, MethodHandles.Lookup.ClassOption...)
! * java.lang.invoke.MethodHandles.Lookup::defineHiddenClass}
! * </ul>
*
* <p> The methods of class {@code Class} expose many characteristics of a
* class or interface. Most characteristics are derived from the {@code class}
! * file that the class loader passed to the Java Virtual Machine or
! * from the {@code class} file passed to {@code Lookup::defineClass}
! * or {@code Lookup::defineHiddenClass}.
! * A few characteristics are determined by the class loading environment
! * at run time, such as the module returned by {@link #getModule() getModule()}.
*
* <p> The following example uses a {@code Class} object to print the
* class name of an object:
*
* <blockquote><pre>
*** 136,154 ****
* System.out.println("The class of " + obj +
* " is " + obj.getClass().getName());
* }
* </pre></blockquote>
*
! * <p> It is also possible to get the {@code Class} object for a named
* type (or for void) using a class literal. See Section 15.8.2 of
* <cite>The Java™ Language Specification</cite>.
* For example:
*
* <blockquote>
* {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
* </blockquote>
*
* @param <T> the type of the class modeled by this {@code Class}
* object. For example, the type of {@code String.class} is {@code
* Class<String>}. Use {@code Class<?>} if the class being modeled is
* unknown.
*
--- 126,180 ----
* System.out.println("The class of " + obj +
* " is " + obj.getClass().getName());
* }
* </pre></blockquote>
*
! * It is also possible to get the {@code Class} object for a named
* type (or for void) using a class literal. See Section 15.8.2 of
* <cite>The Java™ Language Specification</cite>.
* For example:
*
* <blockquote>
* {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
* </blockquote>
*
+ * <p> Some methods of class {@code Class} expose whether the declaration of
+ * a class or interface in Java source code was <em>enclosed</em> within
+ * another declaration. Other methods describe how a class or interface
+ * is situated in a <em>nest</em>. A <a id="nest">nest</a> is a set of
+ * classes and interfaces, in the same run-time package, that
+ * allow mutual access to their {@code private} members.
+ * The classes and interfaces are known as <em>nestmates</em>.
+ * One nestmate acts as the
+ * <em>nest host</em>, and enumerates the other nestmates which
+ * belong to the nest; each of them in turn records it as the nest host.
+ * The classes and interfaces which belong to a nest, including its host, are
+ * determined when
+ * {@code class} files are generated, for example, a Java compiler
+ * will typically record a top-level class as the host of a nest where the
+ * other members are the classes and interfaces whose declarations are
+ * enclosed within the top-level class declaration.
+ *
+ * <p> A class or interface created by the invocation of
+ * {@link java.lang.invoke.MethodHandles.Lookup#defineHiddenClass(byte[], boolean, MethodHandles.Lookup.ClassOption...)
+ * Lookup::defineHiddenClass} is a {@linkplain Class#isHidden() <em>hidden</em>}
+ * class or interface.
+ * All kinds of class, including enum types and record types, may be
+ * hidden classes; all kinds of interface, including annotation types,
+ * may be hidden interfaces.
+ *
+ * The {@linkplain #getName() name of a hidden class or interface} is not a
+ * binary name, which means that a hidden class or interface cannot be
+ * resolved by linkage of constant pool entries and cannot be discovered by
+ * {@link #forName Class::forName} or {@link ClassLoader#loadClass(String, boolean)
+ * ClassLoader::loadClass}.
+ *
+ * A hidden class or interface is never an array class, but may be
+ * the element type of an array. In all other respects, the fact that
+ * a class or interface is hidden has no bearing on the characteristics
+ * exposed by the methods of class {@code Class}.
+ *
* @param <T> the type of the class modeled by this {@code Class}
* object. For example, the type of {@code String.class} is {@code
* Class<String>}. Use {@code Class<?>} if the class being modeled is
* unknown.
*
*** 184,196 ****
}
/**
* Converts the object to a string. The string representation is the
* string "class" or "interface", followed by a space, and then by the
! * fully qualified name of the class in the format returned by
! * {@code getName}. If this {@code Class} object represents a
! * primitive type, this method returns the name of the primitive type. If
* this {@code Class} object represents void this method returns
* "void". If this {@code Class} object represents an array type,
* this method returns "class " followed by {@code getName}.
*
* @return a string representation of this class object.
--- 210,222 ----
}
/**
* Converts the object to a string. The string representation is the
* string "class" or "interface", followed by a space, and then by the
! * name of the class in the format returned by {@code getName}.
! * If this {@code Class} object represents a primitive type,
! * this method returns the name of the primitive type. If
* this {@code Class} object represents void this method returns
* "void". If this {@code Class} object represents an array type,
* this method returns "class " followed by {@code getName}.
*
* @return a string representation of this class object.
*** 740,754 ****
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
/**
! * Returns {@code true} if this class is a synthetic class;
! * returns {@code false} otherwise.
! * @return {@code true} if and only if this class is a synthetic class as
! * defined by the Java Language Specification.
* @jls 13.1 The Form of a Binary
* @since 1.5
*/
public boolean isSynthetic() {
return (getModifiers() & SYNTHETIC) != 0;
}
--- 766,781 ----
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
/**
! * Returns {@code true} if and only if this class has the synthetic modifier
! * bit set.
! *
! * @return {@code true} if and only if this class has the synthetic modifier bit set
* @jls 13.1 The Form of a Binary
+ * @jvms 4.1 The {@code ClassFile} Structure
* @since 1.5
*/
public boolean isSynthetic() {
return (getModifiers() & SYNTHETIC) != 0;
}
*** 756,776 ****
/**
* Returns the name of the entity (class, interface, array class,
* primitive type, or void) represented by this {@code Class} object,
* as a {@code String}.
*
! * <p> If this class object represents a reference type that is not an
! * array type then the binary name of the class is returned, as specified
! * by
* <cite>The Java™ Language Specification</cite>.
*
! * <p> If this class object represents a primitive type or void, then the
! * name returned is a {@code String} equal to the Java language
! * keyword corresponding to the primitive type or void.
! *
! * <p> If this class object represents a class of arrays, then the internal
! * form of the name consists of the name of the element type preceded by
* one or more '{@code [}' characters representing the depth of the array
* nesting. The encoding of element type names is as follows:
*
* <blockquote><table class="striped">
* <caption style="display:none">Element types and encodings</caption>
--- 783,811 ----
/**
* Returns the name of the entity (class, interface, array class,
* primitive type, or void) represented by this {@code Class} object,
* as a {@code String}.
*
! * <p> If this {@code Class} object represents a class or interface,
! * not an array class, then
! * <ul>
! * <li> If the class or interface is not {@linkplain #isHidden() hidden},
! * then the <a href="ClassLoader.html#binary-name">binary name</a>
! * of the class is returned, as specified by
* <cite>The Java™ Language Specification</cite>.
+ * <li> If the class or interface is hidden, then the result is a string
+ * of the format: {@code N + '/' + <suffix>}
+ * where {@code N} is the binary name indicated by the {@code class}
+ * file passed to
+ * {@link java.lang.invoke.MethodHandles.Lookup#defineHiddenClass(byte[], boolean, MethodHandles.Lookup.ClassOption...)
+ * java.lang.invoke.MethodHandles.Lookup::defineHiddenClass} and
+ * {@code <suffix>} is an unqualified name that is guaranteed to be
+ * unique during this execution of the JVM.
+ * </ul>
*
! * <p> If this {@code Class} object represents an array class, then
! * the name consists of the encoded element type (see below) preceded by
* one or more '{@code [}' characters representing the depth of the array
* nesting. The encoding of element type names is as follows:
*
* <blockquote><table class="striped">
* <caption style="display:none">Element types and encodings</caption>
*** 789,798 ****
--- 824,837 ----
* <tr><th scope="row"> long <td style="text-align:center"> J
* <tr><th scope="row"> short <td style="text-align:center"> S
* </tbody>
* </table></blockquote>
*
+ * <p> If this {@code Class} object represents a primitive type or {@code void},
+ * then the result is a {@code String} equal to the Java language
+ * keyword corresponding to the primitive type or {@code void}.
+ *
* <p> The class or interface name <i>classname</i> is the binary name of
* the class specified above.
*
* <p> Examples:
* <blockquote><pre>
*** 805,815 ****
* (new int[3][4][5][6][7][8][9]).getClass().getName()
* returns "[[[[[[[I"
* </pre></blockquote>
*
* @return the name of the class or interface
! * represented by this object.
*/
public String getName() {
String name = this.name;
return name != null ? name : initClassName();
}
--- 844,854 ----
* (new int[3][4][5][6][7][8][9]).getClass().getName()
* returns "[[[[[[[I"
* </pre></blockquote>
*
* @return the name of the class or interface
! * represented by this {@code Class} object.
*/
public String getName() {
String name = this.name;
return name != null ? name : initClassName();
}
*** 883,892 ****
--- 922,939 ----
// 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;
+ }
+
/**
* Returns an array of {@code TypeVariable} objects that represent the
* type variables declared by the generic declaration represented by this
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
*** 1609,1622 ****
return getName();
}
/**
* Returns the canonical name of the underlying class as
! * defined by the Java Language Specification. Returns null if
! * the underlying class does not have a canonical name (i.e., if
! * it is a local or anonymous class or an array whose component
! * type does not have a canonical name).
* @return the canonical name of the underlying class if it exists, and
* {@code null} otherwise.
* @since 1.5
*/
public String getCanonicalName() {
--- 1656,1675 ----
return getName();
}
/**
* Returns the canonical name of the underlying class as
! * defined by <cite>The Java™ Language Specification</cite>.
! * Returns {@code null} if the underlying class does not have a canonical
! * name. Classes without canonical names include:
! * <ul>
! * <li>a {@linkplain #isLocalClass() local class}
! * <li>a {@linkplain #isAnonymousClass() anonymous class}
! * <li>a {@linkplain #isHidden() hidden class}
! * <li>an array whose component type does not have a canonical name</li>
! * </ul>
! *
* @return the canonical name of the underlying class if it exists, and
* {@code null} otherwise.
* @since 1.5
*/
public String getCanonicalName() {
*** 1634,1644 ****
if (canonicalName != null)
return canonicalName + "[]";
else
return ReflectionData.NULL_SENTINEL;
}
! if (isLocalOrAnonymousClass())
return ReflectionData.NULL_SENTINEL;
Class<?> enclosingClass = getEnclosingClass();
if (enclosingClass == null) { // top level class
return getName();
} else {
--- 1687,1697 ----
if (canonicalName != null)
return canonicalName + "[]";
else
return ReflectionData.NULL_SENTINEL;
}
! if (isHidden() || isLocalOrAnonymousClass())
return ReflectionData.NULL_SENTINEL;
Class<?> enclosingClass = getEnclosingClass();
if (enclosingClass == null) { // top level class
return getName();
} else {
*** 1651,1660 ****
--- 1704,1716 ----
/**
* Returns {@code true} if and only if the underlying class
* is an anonymous class.
*
+ * @apiNote
+ * An anonymous class is not a {@linkplain #isHidden() hidden class}.
+ *
* @return {@code true} if and only if this class is an anonymous class.
* @since 1.5
*/
public boolean isAnonymousClass() {
return !isArray() && isLocalOrAnonymousClass() &&
*** 2874,2883 ****
--- 2930,2944 ----
public java.security.ProtectionDomain getProtectionDomain() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(SecurityConstants.GET_PD_PERMISSION);
}
+ return protectionDomain();
+ }
+
+ // package-private
+ java.security.ProtectionDomain protectionDomain() {
java.security.ProtectionDomain pd = getProtectionDomain0();
if (pd == null) {
if (allPermDomain == null) {
java.security.Permissions perms =
new java.security.Permissions();
*** 2888,2898 ****
pd = allPermDomain;
}
return pd;
}
-
/**
* Returns the ProtectionDomain of this class.
*/
private native java.security.ProtectionDomain getProtectionDomain0();
--- 2949,2958 ----
*** 4006,4038 ****
private native Class<?> getNestHost0();
/**
* Returns the nest host of the <a href=#nest>nest</a> to which the class
* or interface represented by this {@code Class} object belongs.
! * Every class and interface is a member of exactly one nest.
! * A class or interface that is not recorded as belonging to a nest
! * belongs to the nest consisting only of itself, and is the nest
! * host.
! *
! * <p>Each of the {@code Class} objects representing array types,
! * primitive types, and {@code void} returns {@code this} to indicate
! * that the represented entity belongs to the nest consisting only of
! * itself, and is the nest host.
*
! * <p>If there is a {@linkplain LinkageError linkage error} accessing
! * the nest host, or if this class or interface is not enumerated as
! * a member of the nest by the nest host, then it is considered to belong
! * to its own nest and {@code this} is returned as the host.
! *
! * @apiNote A {@code class} file of version 55.0 or greater may record the
! * host of the nest to which it belongs by using the {@code NestHost}
! * attribute (JVMS 4.7.28). Alternatively, a {@code class} file of
! * version 55.0 or greater may act as a nest host by enumerating the nest's
! * other members with the
! * {@code NestMembers} attribute (JVMS 4.7.29).
! * A {@code class} file of version 54.0 or lower does not use these
! * attributes.
*
* @return the nest host of this class or interface
*
* @throws SecurityException
* If the returned class is not the current class, and
--- 4066,4091 ----
private native Class<?> getNestHost0();
/**
* Returns the nest host of the <a href=#nest>nest</a> to which the class
* or interface represented by this {@code Class} object belongs.
! * Every class and interface belongs to exactly one nest.
*
! * If the nest host of this class or interface has previously
! * been determined, then this method returns the nest host.
! * If the nest host of this class or interface has
! * not previously been determined, then this method determines the nest
! * host using the algorithm of JVMS 5.4.4, and returns it.
! *
! * Often, a class or interface belongs to a nest consisting only of itself,
! * in which case this method returns {@code this} to indicate that the class
! * or interface is the nest host.
! *
! * <p>If this {@code Class} object represents a primitive type, an array type,
! * or {@code void}, then this method returns {@code this},
! * indicating that the represented entity belongs to the nest consisting only of
! * itself, and is the nest host.
*
* @return the nest host of this class or interface
*
* @throws SecurityException
* If the returned class is not the current class, and
*** 4049,4069 ****
@CallerSensitive
public Class<?> getNestHost() {
if (isPrimitive() || isArray()) {
return this;
}
! Class<?> host;
! try {
! host = getNestHost0();
! } catch (LinkageError e) {
! // if we couldn't load our nest-host then we
! // act as-if we have no nest-host attribute
! return this;
! }
! // if null then nest membership validation failed, so we
! // act as-if we have no nest-host attribute
! if (host == null || host == this) {
return this;
}
// returning a different class requires a security check
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
--- 4102,4114 ----
@CallerSensitive
public Class<?> getNestHost() {
if (isPrimitive() || isArray()) {
return this;
}
!
! Class<?> host = getNestHost0();
! if (host == this) {
return this;
}
// returning a different class requires a security check
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
*** 4091,4146 ****
}
if (isPrimitive() || isArray() ||
c.isPrimitive() || c.isArray()) {
return false;
}
! try {
! return getNestHost0() == c.getNestHost0();
! } catch (LinkageError e) {
! return false;
! }
}
private native Class<?>[] getNestMembers0();
/**
* Returns an array containing {@code Class} objects representing all the
* classes and interfaces that are members of the nest to which the class
* or interface represented by this {@code Class} object belongs.
- * The {@linkplain #getNestHost() nest host} of that nest is the zeroth
- * element of the array. Subsequent elements represent any classes or
- * interfaces that are recorded by the nest host as being members of
- * the nest; the order of such elements is unspecified. Duplicates are
- * permitted.
- * If the nest host of that nest does not enumerate any members, then the
- * array has a single element containing {@code this}.
*
! * <p>Each of the {@code Class} objects representing array types,
! * primitive types, and {@code void} returns an array containing only
* {@code this}.
*
! * <p>This method validates that, for each class or interface which is
! * recorded as a member of the nest by the nest host, that class or
! * interface records itself as a member of that same nest. Any exceptions
! * that occur during this validation are rethrown by this method.
*
* @return an array of all classes and interfaces in the same nest as
* this class
*
- * @throws LinkageError
- * If there is any problem loading or validating a nest member or
- * its nest host
* @throws SecurityException
* If any returned class is not the current class, and
* if a security manager, <i>s</i>, is present and the caller's
* class loader is not the same as or an ancestor of the class
* loader for that returned class and invocation of {@link
* SecurityManager#checkPackageAccess s.checkPackageAccess()}
* denies access to the package of that returned class
*
* @since 11
* @see #getNestHost()
*/
@CallerSensitive
public Class<?>[] getNestMembers() {
if (isPrimitive() || isArray()) {
return new Class<?>[] { this };
--- 4136,4194 ----
}
if (isPrimitive() || isArray() ||
c.isPrimitive() || c.isArray()) {
return false;
}
!
! return getNestHost() == c.getNestHost();
}
private native Class<?>[] getNestMembers0();
/**
* Returns an array containing {@code Class} objects representing all the
* classes and interfaces that are members of the nest to which the class
* or interface represented by this {@code Class} object belongs.
*
! * First, this method obtains the {@linkplain #getNestHost() nest host}, {@code H}, of the nest
! * to which the class or interface represented by this {@code Class} object belongs.
! * The zeroth element of the returned array is {@code H}.
! *
! * Then, for each class or interface {@code C} which is recorded by {@code H} as being a member
! * of its nest, this method attempts to obtain the {@code Class} object for {@code C}
! * (using {@linkplain #getClassLoader() the defining class loader} of the current {@code Class} object),
! * and then obtains the {@linkplain #getNestHost() nest host} of the nest to which {@code C} belongs.
! * The classes and interfaces which are recorded by {@code H} as being members of its nest,
! * and for which {@code H} can be determined as their nest host, are indicated by subsequent elements
! * of the returned array. The order of such elements is unspecified.
! * Duplicates are permitted.
! *
! * <p>If this {@code Class} object represents a primitive type, an array type,
! * or {@code void}, then this method returns a single-element array containing
* {@code this}.
*
! * @apiNote
! * The returned array includes only the nest members recorded in the {@code NestMembers}
! * attribute, and not any hidden classes that were added to the nest via
! * {@link MethodHandles.Lookup#defineHiddenClass(byte[], boolean, MethodHandles.Lookup.ClassOption...)
! * Lookup::defineHiddenClass}.
*
* @return an array of all classes and interfaces in the same nest as
* this class
*
* @throws SecurityException
* If any returned class is not the current class, and
* if a security manager, <i>s</i>, is present and the caller's
* class loader is not the same as or an ancestor of the class
* loader for that returned class and invocation of {@link
* SecurityManager#checkPackageAccess s.checkPackageAccess()}
* denies access to the package of that returned class
*
* @since 11
* @see #getNestHost()
+ * @jvms 4.7.28 The {@code NestHost} Attribute
+ * @jvms 4.7.29 The {@code NestMembers} Attribute
*/
@CallerSensitive
public Class<?>[] getNestMembers() {
if (isPrimitive() || isArray()) {
return new Class<?>[] { this };
*** 4222,4227 ****
--- 4270,4287 ----
*/
@Override
public Optional<ClassDesc> describeConstable() {
return Optional.of(ClassDesc.ofDescriptor(descriptorString()));
}
+
+ /**
+ * Returns {@code true} if and only if the underlying class is a hidden class.
+ *
+ * @return {@code true} if and only if this class is a hidden class.
+ *
+ * @since 15
+ * @see MethodHandles.Lookup#defineHiddenClass
+ */
+ @HotSpotIntrinsicCandidate
+ public native boolean isHidden();
+
}
< prev index next >