src/java.base/share/classes/java/lang/Class.java

@@ -4019,41 +4019,26 @@
     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.
+     * Every class and interface belongs to exactly one nest.
      *
-     * <p>If this class is a {@linkplain Class#isHiddenClass() hidden class}
-     * created by calling
-     * {@link MethodHandles.Lookup#defineHiddenClass(byte[], boolean, MethodHandles.Lookup.ClassOption...)
-     * Lookup::defineHiddenClass} with {@link MethodHandles.Lookup.ClassOption#NESTMATE
-     * NESTMATE} option, then the hidden class is added as a member to
-     * the nest of a {@linkplain MethodHandles.Lookup#lookupClass() lookup class}
-     * dynamically and it has the same nest host as the lookup class.
-     *
-     * @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.
+     * 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

@@ -4074,24 +4059,21 @@
         }
 
         Class<?> host = this.nest;
         if (host == null) {
             host = getNestHost0();
-            // if null then nest membership validation failed, so we
-            // act as-if we have no nest-host attribute
-            if (host == null || host == this) {
+            if (host == this) {
                 return this.nest = this;
             }
-            this.nest = host;
         }
         // returning a different class requires a security check
         SecurityManager sm = System.getSecurityManager();
         if (sm != null) {
             checkPackageAccess(sm,
                                ClassLoader.getClassLoader(Reflection.getCallerClass()), true);
         }
-        return host;
+        return (this.nest = host);
     }
 
     // keep a strong reference to the nest host
     private transient Class<?> nest;
 

@@ -4123,50 +4105,49 @@
 
     /**
      * 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}.
+     * 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>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.
+     * <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
-     * This method returns the nest members listed in the {@code NestMembers}
-     * attribute.  The returned array does not include any hidden class that
-     * were added to the nest of this class via
+     * 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 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()
+     * @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 };