replaced uses of AnnotationAccess with AnnotationUtil

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

@@ -231,6 +231,7 @@
                 "java.base" : ["jdk.internal.module"],
                 "jdk.internal.vm.ci": [
                     "jdk.vm.ci.meta",
+                    "jdk.vm.ci.meta.annotation",
                     "jdk.vm.ci.code",
                     "jdk.vm.ci.runtime"
                 ]
@@ -242,6 +243,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 +383,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 +1379,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"
                 ]

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/meta/AnalysisElement.java

@@ -48,6 +48,7 @@
 import com.oracle.graal.pointsto.util.AnalysisFuture;
 import com.oracle.graal.pointsto.util.AtomicUtils;
 import com.oracle.graal.pointsto.util.ConcurrentLightHashSet;
+import com.oracle.svm.util.AnnotationUtil;
 
 import jdk.graal.compiler.debug.GraalError;
 import jdk.vm.ci.code.BytecodePosition;
@@ -86,17 +87,17 @@ public AnnotationsInfo getTypeAnnotationInfo() {
 
     @Override
     public final boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
-        return getUniverse().getAnnotationExtractor().hasAnnotation(getWrapped(), annotationClass);
+        return AnnotationUtil.isAnnotationPresent((Annotated) getWrapped(), annotationClass);
     }
 
     @Override
     public final <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        return getUniverse().getAnnotationExtractor().extractAnnotation(getWrapped(), annotationClass, false);
+        return AnnotationUtil.getAnnotation((Annotated) getWrapped(), annotationClass);
     }
 
     @Override
     public final <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
-        return getUniverse().getAnnotationExtractor().extractAnnotation(getWrapped(), annotationClass, true);
+        throw GraalError.shouldNotReachHere("The getDeclaredAnnotation method is not supported");
     }
 
     @Override

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisField.java

@@ -36,6 +36,7 @@
 import com.oracle.graal.pointsto.util.AnalysisFuture;
 import com.oracle.graal.pointsto.util.AtomicUtils;
 import com.oracle.svm.common.meta.GuaranteeFolded;
+import com.oracle.svm.util.AnnotationUtil;
 import com.oracle.svm.util.OriginalClassProvider;
 import com.oracle.svm.util.OriginalFieldProvider;
 
@@ -257,7 +258,7 @@ public void injectDeclaredType() {
     }
 
     public boolean isGuaranteeFolded() {
-        return getAnnotation(GuaranteeFolded.class) != null;
+        return AnnotationUtil.getAnnotation(this, GuaranteeFolded.class) != null;
     }
 
     public void checkGuaranteeFolded() {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/results/TypeFlowSimplifier.java

@@ -29,7 +29,6 @@
 import java.util.List;
 
 import org.graalvm.collections.EconomicSet;
-import org.graalvm.nativeimage.AnnotationAccess;
 
 import com.oracle.graal.pointsto.PointsToAnalysis;
 import com.oracle.graal.pointsto.flow.InvokeTypeFlow;
@@ -45,6 +44,7 @@
 import com.oracle.graal.pointsto.typestate.TypeState;
 import com.oracle.graal.pointsto.util.AnalysisError;
 import com.oracle.svm.core.annotate.Delete;
+import com.oracle.svm.util.AnnotationUtil;
 import com.oracle.svm.util.ImageBuildStatistics;
 
 import jdk.graal.compiler.core.common.type.IntegerStamp;
@@ -376,7 +376,7 @@ private void handleInvoke(Invoke invoke, SimplifierTool tool) {
                 AnalysisMethod singleCallee = callees.iterator().next();
                 assert targetMethod.equals(singleCallee) : "Direct invoke target mismatch: " + targetMethod + " != " + singleCallee + ". Called from " + graph.method().format("%H.%n");
             }
-        } else if (AnnotationAccess.isAnnotationPresent(targetMethod, Delete.class)) {
+        } else if (AnnotationUtil.isAnnotationPresent(targetMethod, Delete.class)) {
             /* We de-virtualize invokes to deleted methods since the callee must be unique. */
             AnalysisError.guarantee(callees.size() == 1, "@Delete methods should have a single callee.");
             AnalysisMethod singleCallee = callees.iterator().next();

substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/DirectMethodProcessingHandler.java

@@ -26,12 +26,11 @@
 
 import java.lang.reflect.Modifier;
 
-import org.graalvm.nativeimage.AnnotationAccess;
-
 import com.oracle.graal.pointsto.AbstractAnalysisEngine;
 import com.oracle.graal.pointsto.flow.MethodTypeFlowBuilder;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.svm.util.AnnotationUtil;
 
 import jdk.graal.compiler.graph.Node;
 import jdk.graal.compiler.nodes.CallTargetNode;
@@ -128,7 +127,7 @@ private static void analyzeStructuredGraph(ReachabilityAnalysisEngine bb, Reacha
 
     private static void processInvoke(ReachabilityAnalysisEngine bb, ReachabilityAnalysisMethod method, ReachabilityAnalysisMethod targetMethod, CallTargetNode.InvokeKind kind,
                     ValueNodeInterface node) {
-        if (targetMethod == null || AnnotationAccess.isAnnotationPresent(targetMethod, Node.NodeIntrinsic.class)) {
+        if (targetMethod == null || AnnotationUtil.isAnnotationPresent(targetMethod, Node.NodeIntrinsic.class)) {
             return;
         }
         BytecodePosition reason = AbstractAnalysisEngine.sourcePosition(node.asNode());