rename: eagerResolution -> allowEnumClinit

Author: dougxc

src/java.base/share/classes/sun/reflect/annotation/AnnotationParser.java

@@ -125,12 +125,12 @@ private AnnotationType(final Class<? extends Annotation> annotationClass) {
 
                 byte[] annotationDefault = SharedSecrets.getJavaLangReflectAccess().getAnnotationDefaultBytes(method);
                 if (annotationDefault != null) {
-                    // Pass eagerResolution==false to support the
-                    // context where eager resolution is not desired.
-                    // All uses of defaultValue will use
+                    // Pass allowEnumClinit == false to avoid
+                    // enum class initialization.
+                    // All accesses of defaultValue use
                     // sun.reflect.annotation.ResolvableValue.resolved
-                    // to ensure only resolved values are seen by
-                    // users of the standard annotation API.
+                    // to ensure enum constants values are seen via
+                    // the standard annotation API.
                     Object defaultValue = AnnotationParser.parseAnnotationDefault(method, annotationDefault, false);
                     if (defaultValue != null) {
                         memberDefaults.put(name, defaultValue);

src/java.base/share/classes/sun/reflect/annotation/AnnotationType.java

@@ -29,6 +29,9 @@
  * An instance of this class is stored in an AnnotationInvocationHandler's
  * "memberValues" map to defer reification of an enum constant until the
  * dynamic proxy is queried for the enum member.
+ * <p>
+ * Instances of this object are created when the {@code allowEnumClinit}
+ * argument to {@link AnnotationParser#parseEnumValue} is {@code false}.
  */
 public final class EnumValue implements java.io.Serializable, ResolvableValue {
 
@@ -44,7 +47,7 @@ public final class EnumValue implements java.io.Serializable, ResolvableValue {
     public final String constName;
 
     /**
-     * The lazily retrived value of the enum constant.
+     * The lazily resolved value of the enum constant.
      */
     transient Object constValue;
 

src/java.base/share/classes/sun/reflect/annotation/EnumValue.java

@@ -27,14 +27,15 @@
 
 import java.io.Serializable;
 import java.lang.reflect.Array;
-import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 
 /**
  * An instance of this class is stored in an AnnotationInvocationHandler's
  * "memberValues" map to defer reification of an enum constant until the
  * dynamic proxy is queried for the enum member.
+ * <p>
+ * Instances of this object are created when the {@code allowEnumClinit}
+ * argument to {@link AnnotationParser#parseEnumArray} is {@code false}.
  */
 public final class EnumValueArray implements java.io.Serializable, ResolvableValue {
 

src/java.base/share/classes/sun/reflect/annotation/EnumValueArray.java

@@ -28,9 +28,8 @@
 /**
  * Denotes a parsed annotation element value that is not fully resolved to the
  * value returned by the annotation interface method for the element.
- * This is used for example to defer resolving enum constants which is important
- * in contexts where class initialization of the enum types should not be
- * triggered by annotation parsing.
+ * This is used, for example, to avoid enum class initialization when
+ * parsing enum annotation elements.
  */
 public interface ResolvableValue {
 

src/java.base/share/classes/sun/reflect/annotation/ResolvableValue.java

@@ -345,11 +345,15 @@ static TypeAnnotation[] parseAllTypeAnnotations(AnnotatedElement decl) {
                                     decl, false, container);
     }
 
-    /* Parse type annotations encoded as an array of bytes */
+    /**
+     * Parses types annotations encoded as an array of bytes.
+     *
+     * @param allowEnumClinit described in {@link AnnotationParser}
+     */
     public static TypeAnnotation[] parseTypeAnnotations(byte[] rawAnnotations,
            ConstantPool cp,
            AnnotatedElement baseDecl,
-           boolean eagerResolution,
+           boolean allowEnumClinit,
            Class<?> container) {
         if (rawAnnotations == null)
             return EMPTY_TYPE_ANNOTATION_ARRAY;
@@ -360,7 +364,7 @@ public static TypeAnnotation[] parseTypeAnnotations(byte[] rawAnnotations,
 
         // Parse each TypeAnnotation
         for (int i = 0; i < annotationCount; i++) {
-             TypeAnnotation ta = parseTypeAnnotation(buf, cp, baseDecl, eagerResolution, container);
+             TypeAnnotation ta = parseTypeAnnotation(buf, cp, baseDecl, allowEnumClinit, container);
              if (ta != null)
                  typeAnnotations.add(ta);
         }
@@ -414,15 +418,18 @@ static Map<Class<? extends Annotation>, Annotation> mapTypeAnnotations(TypeAnnot
     private static final byte CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT = (byte)0x4A;
     private static final byte METHOD_REFERENCE_TYPE_ARGUMENT = (byte)0x4B;
 
+    /**
+     * @param allowEnumClinit described in {@link AnnotationParser}
+     */
     public static TypeAnnotation parseTypeAnnotation(ByteBuffer buf,
            ConstantPool cp,
            AnnotatedElement baseDecl,
-           boolean eagerResolution,
+           boolean allowEnumClinit,
            Class<?> container) {
         try {
             TypeAnnotationTargetInfo ti = parseTargetInfo(buf);
             LocationInfo locationInfo = LocationInfo.parseLocationInfo(buf);
-            Annotation a = AnnotationParser.parseAnnotation(buf, cp, container, eagerResolution, false);
+            Annotation a = AnnotationParser.parseAnnotation(buf, cp, container, allowEnumClinit, false);
             if (ti == null) // Inside a method for example
                 return null;
             return new TypeAnnotation(ti, locationInfo, a, baseDecl);

src/java.base/share/classes/sun/reflect/annotation/TypeAnnotationParser.java

@@ -157,6 +157,14 @@ public <V> V get(String name, Class<V> elementType) {
         return elementType.cast(val);
     }
 
+    /**
+     * Gets an unmodifiable view of the elements in this annotation value.
+     * The type for each value in the returned map is specified by {@link #get(String, Class)}.
+     */
+    public Map<String, Object> getElements() {
+        return elements;
+    }
+
     @Override
     public String toString() {
         return "@" + type.toClassName() + "(" + elements + ")";

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/annotation/AnnotationValue.java

@@ -30,7 +30,7 @@
  * <p>
  * Similar to {@code AnnotationTypeMismatchExceptionProxy}.
  */
-public final class ElementTypeMismatch {
+public final class ElementTypeMismatch extends ErrorElement {
     private final String foundType;
 
     /**