src/java.base/share/classes/jdk/internal/reflect/Reflection.java

*** 102,144 ****
                                            Class<?> memberClass,
                                            Class<?> targetClass,
                                            int modifiers)
          throws IllegalAccessException
      {
-         if (currentClass == null || memberClass == null) {
-             throw new InternalError();
-         }
- 
          if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
              throwIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
          }
      }
  
      /**
!      * Verify access to a member, returning {@code false} if no access
       */
      public static boolean verifyMemberAccess(Class<?> currentClass,
                                               Class<?> memberClass,
                                               Class<?> targetClass,
                                               int modifiers)
      {
!         // Verify that currentClass can access a field, method, or
!         // constructor of memberClass, where that member's access bits are
!         // "modifiers".
! 
!         boolean gotIsSameClassPackage = false;
!         boolean isSameClassPackage = false;
  
          if (currentClass == memberClass) {
              // Always succeeds
              return true;
          }
  
!         if (!verifyModuleAccess(currentClass, memberClass)) {
              return false;
          }
  
          if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
              isSameClassPackage = isSameClassPackage(currentClass, memberClass);
              gotIsSameClassPackage = true;
              if (!isSameClassPackage) {
                  return false;
--- 102,148 ----
                                            Class<?> memberClass,
                                            Class<?> targetClass,
                                            int modifiers)
          throws IllegalAccessException
      {
          if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
              throwIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
          }
      }
  
      /**
!      * Verify access to a member and return {@code true} if it is granted.
!      *
!      * @param currentClass the class performing the access
!      * @param memberClass the declaring class of the member being accessed
!      * @param targetClass the class of target object if accessing instance
!      *                    field or method;
!      *                    or the declaring class if accessing constructor;
!      *                    or null if accessing static field or method
!      * @param modifiers the member's access modifiers
!      * @return {@code true} if access to member is granted
       */
      public static boolean verifyMemberAccess(Class<?> currentClass,
                                               Class<?> memberClass,
                                               Class<?> targetClass,
                                               int modifiers)
      {
!         Objects.requireNonNull(currentClass);
!         Objects.requireNonNull(memberClass);
  
          if (currentClass == memberClass) {
              // Always succeeds
              return true;
          }
  
!         if (!verifyModuleAccess(currentClass.getModule(), memberClass)) {
              return false;
          }
  
+         boolean gotIsSameClassPackage = false;
+         boolean isSameClassPackage = false;
+ 
          if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
              isSameClassPackage = isSameClassPackage(currentClass, memberClass);
              gotIsSameClassPackage = true;
              if (!isSameClassPackage) {
                  return false;
*** 195,212 ****
          return true;
      }
  
      /**
       * Returns {@code true} if memberClass's's module exports memberClass's
!      * package to currentClass's module.
       */
-     public static boolean verifyModuleAccess(Class<?> currentClass,
-                                              Class<?> memberClass) {
-         return verifyModuleAccess(currentClass.getModule(), memberClass);
-     }
- 
      public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
          Module memberModule = memberClass.getModule();
  
          // module may be null during startup (initLevel 0)
          if (currentModule == memberModule)
             return true;  // same module (named or unnamed)
--- 199,214 ----
          return true;
      }
  
      /**
       * Returns {@code true} if memberClass's's module exports memberClass's
!      * package to currentModule.
       */
      public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
+         Objects.requireNonNull(currentModule);
+         Objects.requireNonNull(memberClass);
+ 
          Module memberModule = memberClass.getModule();
  
          // module may be null during startup (initLevel 0)
          if (currentModule == memberModule)
             return true;  // same module (named or unnamed)
*** 376,390 ****
          return printStackWhenAccessSucceeds;
      }
  
      /**
       * Throws IllegalAccessException with the an exception message based on
!      * the access that is denied.
       */
!     private static void throwIllegalAccessException(Class<?> currentClass,
                                                      Class<?> memberClass,
!                                                     Object target,
                                                      int modifiers)
          throws IllegalAccessException
      {
          String currentSuffix = "";
          String memberSuffix = "";
--- 378,394 ----
          return printStackWhenAccessSucceeds;
      }
  
      /**
       * Throws IllegalAccessException with the an exception message based on
!      * the access that is denied. This method throws meaningful exception only
!      * when {@link #verifyMemberAccess(Class, Class, Class, int)} returns false
!      * for the same parameters.
       */
!     public static void throwIllegalAccessException(Class<?> currentClass,
                                                      Class<?> memberClass,
!                                                     Class<?> targetClass,
                                                      int modifiers)
          throws IllegalAccessException
      {
          String currentSuffix = "";
          String memberSuffix = "";