[GR-70940] Replace AnnotatedElement usages with Annotated-based access in SVM

PullRequest: graal/22429

Author: dougxc

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/CheckGraalInvariants.java

@@ -215,13 +215,6 @@ public boolean shouldVerifyFoldableMethods() {
             return true;
         }
 
-        /**
-         * Determines if {@link VerifyAnnotatedElementUsage} is to be checked.
-         */
-        public boolean shouldVerifyAnnotatedElementUsages() {
-            return true;
-        }
-
         public void verifyCurrentTimeMillis(MetaAccessProvider meta, MethodCallTargetNode t, ResolvedJavaType declaringClass) {
             final ResolvedJavaType services = meta.lookupJavaType(GraalServices.class);
             if (!declaringClass.equals(services)) {
@@ -385,6 +378,7 @@ public static void runTest(InvariantsTool tool) {
         verifiers.add(new VerifyLoopInfo());
         verifiers.add(new VerifyGuardsStageUsages());
         verifiers.add(new VerifyAArch64RegisterUsages());
+        verifiers.add(new VerifyAnnotatedElementUsage());
         VerifyAssertionUsage assertionUsages = null;
         boolean checkAssertions = tool.checkAssertions();
 
@@ -403,9 +397,6 @@ public static void runTest(InvariantsTool tool) {
         if (tool.shouldVerifyFoldableMethods()) {
             verifiers.add(foldableMethodsVerifier);
         }
-        if (tool.shouldVerifyAnnotatedElementUsages()) {
-            verifiers.add(new VerifyAnnotatedElementUsage());
-        }
 
         verifiers.add(new VerifyCurrentTimeMillisUsage(tool));
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/annotation/AnnotationValueParser.java

@@ -151,7 +151,7 @@ public static Object parseMemberValue(ResolvedJavaType memberType,
             result = new ElementTypeMismatch(memberType.toJavaName());
         } else if (tag != '[' &&
                         !(result instanceof ErrorElement) &&
-                        !matchesMemberType(result, memberType)) {
+                        !AnnotationValueType.matchesElementType(result, memberType)) {
             if (result instanceof AnnotationValue) {
                 result = new ElementTypeMismatch(result.toString());
             } else {
@@ -161,22 +161,6 @@ public static Object parseMemberValue(ResolvedJavaType memberType,
         return result;
     }
 
-    private static boolean matchesMemberType(Object result, ResolvedJavaType memberType) {
-        if (result instanceof AnnotationValue av) {
-            return memberType.equals(av.getAnnotationType());
-        }
-        if (result instanceof ResolvedJavaType) {
-            return memberType.getName().equals("Ljava/lang/Class;");
-        }
-        if (result instanceof EnumElement ee) {
-            return ee.enumType.equals(memberType);
-        }
-        if (memberType.isPrimitive()) {
-            return result.getClass() == memberType.getJavaKind().toBoxedJavaClass();
-        }
-        return memberType.toJavaName().equals(result.getClass().getName());
-    }
-
     private static Object parsePrimitiveConst(char tag,
                     ByteBuffer buf, ConstantPool constPool) {
         int constIndex = buf.getShort() & 0xFFFF;

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/annotation/AnnotationValueType.java

@@ -77,6 +77,29 @@ private AnnotationValueType(ResolvedJavaType annotationClass) {
         }
     }
 
+    /**
+     * Determines if the type of {@code elementValue} matches {@code elementType}.
+     *
+     * @param elementValue a value of a type returned by {@link AnnotationValue#get}
+     * @param elementType an annotation element type (i.e. the return type of an annotation
+     *            interface method)
+     */
+    public static boolean matchesElementType(Object elementValue, ResolvedJavaType elementType) {
+        if (elementValue instanceof AnnotationValue av) {
+            return elementType.equals(av.getAnnotationType());
+        }
+        if (elementValue instanceof ResolvedJavaType) {
+            return elementType.getName().equals("Ljava/lang/Class;");
+        }
+        if (elementValue instanceof EnumElement ee) {
+            return ee.enumType.equals(elementType);
+        }
+        if (elementType.isPrimitive()) {
+            return elementValue.getClass() == elementType.getJavaKind().toBoxedJavaClass();
+        }
+        return elementType.toJavaName().equals(elementValue.getClass().getName());
+    }
+
     /**
      * Gets the element types for the annotation represented by this object.
      *

substratevm/mx.substratevm/suite.py

@@ -228,9 +228,13 @@
                 "compiler:GRAAL",
             ],
             "requiresConcealed" : {
-                "java.base" : ["jdk.internal.module"],
+                "java.base" : [
+                    "jdk.internal.module",
+                    "sun.reflect.annotation"
+                ],
                 "jdk.internal.vm.ci": [
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                     "jdk.vm.ci.runtime"
                 ]
@@ -242,6 +246,10 @@
             "checkstyle": "com.oracle.svm.core",
             "workingSets": "SVM",
             "jacoco" : "include",
+
+            # Direct reference to jdk.vm.ci.meta.annotation.Annotated
+            # causes spotbugs analysis to fail with "missing class" error.
+            "spotbugs": "false",
         },
 
         "com.oracle.svm.common": {
@@ -378,6 +386,7 @@
                 ],
                 "jdk.internal.vm.ci": [
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                     "jdk.vm.ci.aarch64",
                     "jdk.vm.ci.amd64",
@@ -1373,6 +1382,7 @@
                 "jdk.internal.vm.ci": [
                     "jdk.vm.ci.aarch64",
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                     "jdk.vm.ci.code.stack"
                 ]
@@ -1583,6 +1593,7 @@
             "requiresConcealed": {
                 "jdk.internal.vm.ci": [
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                     "jdk.vm.ci.common",
                 ]
@@ -1632,6 +1643,7 @@
             "requiresConcealed" : {
                 "jdk.internal.vm.ci" : [
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                 ],
                 "java.base" : [

substratevm/src/com.oracle.graal.pointsto.standalone/src/com/oracle/graal/pointsto/standalone/StandaloneAnnotationExtractor.java

@@ -26,12 +26,12 @@
 
 package com.oracle.graal.pointsto.standalone;
 
-import org.graalvm.nativeimage.impl.AnnotationExtractor;
-
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.util.Arrays;
 
+import org.graalvm.nativeimage.impl.AnnotationExtractor;
+
 public class StandaloneAnnotationExtractor implements AnnotationExtractor {
     // Checkstyle: allow direct annotation access
     @Override

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java

@@ -42,8 +42,6 @@
 import java.util.function.Consumer;
 import java.util.stream.StreamSupport;
 
-import org.graalvm.nativeimage.AnnotationAccess;
-
 import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.api.PointstoOptions;
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
@@ -77,6 +75,7 @@
 import com.oracle.graal.pointsto.util.Timer.StopTimer;
 import com.oracle.graal.pointsto.util.TimerCollection;
 import com.oracle.svm.common.meta.MultiMethod;
+import com.oracle.svm.util.AnnotationUtil;
 import com.oracle.svm.util.ClassUtil;
 
 import jdk.graal.compiler.api.replacements.Fold;
@@ -166,7 +165,7 @@ public PointsToAnalysis(OptionValues options, AnalysisUniverse universe, HostVM
      * this type cannot be extended outside the observable universe.</li>
      * <li>In <b>closed type world</b> all types are considered closed.</li>
      * </ul>
-     * 
+     *
      * This method is conservative, it returns false in cases where we are not sure, and further
      * refining when a type is closed will improve analysis. For example GR-59311 will also define
      * when a sealed type can be treated as a closed type.
@@ -394,7 +393,7 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia
         assert !universe.sealed() : "Cannot register root methods after analysis universe is sealed.";
         validateRootMethodRegistration(aMethod, invokeSpecial);
         AnalysisError.guarantee(aMethod.isOriginalMethod());
-        AnalysisError.guarantee(!AnnotationAccess.isAnnotationPresent(aMethod, Fold.class), "@Fold annotated method cannot be a root method.");
+        AnalysisError.guarantee(!AnnotationUtil.isAnnotationPresent(aMethod, Fold.class), "@Fold annotated method cannot be a root method.");
         boolean isStatic = aMethod.isStatic();
         int paramCount = aMethod.getSignature().getParameterCount(!isStatic);
         PointsToAnalysisMethod originalPTAMethod = assertPointsToAnalysisMethod(aMethod);

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java

@@ -34,8 +34,6 @@
 import java.util.Map;
 import java.util.Optional;
 
-import org.graalvm.nativeimage.AnnotationAccess;
-
 import com.oracle.graal.pointsto.AbstractAnalysisEngine;
 import com.oracle.graal.pointsto.ObjectScanner.EmbeddedRootScan;
 import com.oracle.graal.pointsto.PointsToAnalysis;
@@ -62,6 +60,7 @@
 import com.oracle.graal.pointsto.typestate.TypeState;
 import com.oracle.graal.pointsto.util.AnalysisError;
 import com.oracle.svm.common.meta.MultiMethod;
+import com.oracle.svm.util.AnnotationUtil;
 
 import jdk.graal.compiler.core.common.SuppressFBWarnings;
 import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor;
@@ -509,7 +508,7 @@ private static void registerForeignCall(AbstractAnalysisEngine bb, ForeignCallsP
     }
 
     private boolean handleNodeIntrinsic() {
-        if (AnnotationAccess.isAnnotationPresent(method, NodeIntrinsic.class)) {
+        if (AnnotationUtil.isAnnotationPresent(method, NodeIntrinsic.class)) {
             graph.getDebug().log("apply MethodTypeFlow on node intrinsic %s", method);
             AnalysisType returnType = method.getSignature().getReturnType();
             if (bb.isSupportedJavaKind(returnType.getJavaKind())) {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/WrappedJavaField.java

@@ -24,10 +24,18 @@
  */
 package com.oracle.graal.pointsto.infrastructure;
 
+import com.oracle.svm.util.AnnotatedWrapper;
+
 import jdk.vm.ci.meta.ResolvedJavaField;
+import jdk.vm.ci.meta.annotation.Annotated;
 
-public interface WrappedJavaField extends ResolvedJavaField, WrappedElement {
+public interface WrappedJavaField extends ResolvedJavaField, WrappedElement, AnnotatedWrapper {
 
     @Override
     ResolvedJavaField getWrapped();
+
+    @Override
+    default Annotated getWrappedAnnotated() {
+        return getWrapped();
+    }
 }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/WrappedJavaMethod.java

@@ -24,10 +24,18 @@
  */
 package com.oracle.graal.pointsto.infrastructure;
 
+import com.oracle.svm.util.AnnotatedWrapper;
+
 import jdk.vm.ci.meta.ResolvedJavaMethod;
+import jdk.vm.ci.meta.annotation.Annotated;
 
-public interface WrappedJavaMethod extends WrappedElement, ResolvedJavaMethod {
+public interface WrappedJavaMethod extends WrappedElement, AnnotatedWrapper, ResolvedJavaMethod {
 
     @Override
     ResolvedJavaMethod getWrapped();
+
+    @Override
+    default Annotated getWrappedAnnotated() {
+        return getWrapped();
+    }
 }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/WrappedJavaType.java

@@ -24,10 +24,18 @@
  */
 package com.oracle.graal.pointsto.infrastructure;
 
+import com.oracle.svm.util.AnnotatedWrapper;
+
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.annotation.Annotated;
 
-public interface WrappedJavaType extends WrappedElement, ResolvedJavaType {
+public interface WrappedJavaType extends WrappedElement, AnnotatedWrapper, ResolvedJavaType {
 
     @Override
     ResolvedJavaType getWrapped();
+
+    @Override
+    default Annotated getWrappedAnnotated() {
+        return getWrapped();
+    }
 }