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

@@ -30,11 +30,10 @@
  import java.io.ObjectOutputStream;
  import java.io.ObjectStreamClass;
  import java.io.ObjectStreamField;
  import java.io.OptionalDataException;
  import java.io.Serializable;
- import java.lang.classfile.ClassFile;
  import java.lang.invoke.MethodHandle;
  import java.lang.invoke.MethodHandles;
  import java.lang.reflect.*;
  import java.util.Set;
  

@@ -197,10 +196,13 @@
  
      public final Constructor<?> newConstructorForExternalization(Class<?> cl) {
          if (!Externalizable.class.isAssignableFrom(cl)) {
              return null;
          }
+         if (cl.isValue()) {
+             throw new UnsupportedOperationException("newConstructorForExternalization does not support value classes");
+         }
          try {
              Constructor<?> cons = cl.getConstructor();
              cons.setAccessible(true);
              return cons;
          } catch (NoSuchMethodException ex) {

@@ -213,10 +215,13 @@
      {
          if (constructorToCall.getDeclaringClass() == cl) {
              constructorToCall.setAccessible(true);
              return constructorToCall;
          }
+         if (cl.isValue()) {
+             throw new UnsupportedOperationException("newConstructorForSerialization does not support value classes");
+         }
          return generateConstructor(cl, constructorToCall);
      }
  
      /**
       * Given a class, determines whether its superclass has

@@ -272,10 +277,14 @@
       *
       * @param cl the class for which a constructor is to be found
       * @return the generated constructor, or null if none is available
       */
      public final Constructor<?> newConstructorForSerialization(Class<?> cl) {
+         if (cl.isValue()) {
+             throw new UnsupportedOperationException("newConstructorForSerialization does not support value classes: " + cl);
+         }
+ 
          Class<?> initCl = cl;
          while (Serializable.class.isAssignableFrom(initCl)) {
              Class<?> prev = initCl;
              if ((initCl = initCl.getSuperclass()) == null ||
                  (!disableSerialConstructorChecks() && !superHasAccessibleConstructor(prev))) {

@@ -511,35 +520,10 @@
          } catch (ReflectiveOperationException e) {
              return null;
          }
      }
  
-     public final Set<AccessFlag> parseAccessFlags(int mask, AccessFlag.Location location, Class<?> classFile) {
-         var cffv = classFileFormatVersion(classFile);
-         return cffv == null ?
-                 AccessFlag.maskToAccessFlags(mask, location) :
-                 AccessFlag.maskToAccessFlags(mask, location, cffv);
-     }
- 
-     private final ClassFileFormatVersion classFileFormatVersion(Class<?> cl) {
-         int raw = SharedSecrets.getJavaLangAccess().classFileVersion(cl);
- 
-         int major = raw & 0xFFFF;
-         int minor = raw >>> Character.SIZE;
- 
-         assert VM.isSupportedClassFileVersion(major, minor) : major + "." + minor;
- 
-         if (major >= ClassFile.JAVA_12_VERSION) {
-             if (minor == 0)
-                 return ClassFileFormatVersion.fromMajor(raw);
-             return null; // preview or old preview, fallback to default handling
-         } else if (major == ClassFile.JAVA_1_VERSION) {
-             return minor < 3 ? ClassFileFormatVersion.RELEASE_0 : ClassFileFormatVersion.RELEASE_1;
-         }
-         return ClassFileFormatVersion.fromMajor(major);
-     }
- 
      //--------------------------------------------------------------------------
      //
      // Internals only below this point
      //