removed AnnotatedElement as super interface of ResolvedJava[Type|Method|Field]

Author: dougxc

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotJDKReflection.java

@@ -22,23 +22,21 @@
  */
 package jdk.vm.ci.hotspot;
 
-import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
-import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
+import jdk.vm.ci.common.JVMCIError;
+import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.JavaKind;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+import jdk.vm.ci.meta.ResolvedJavaType;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.Array;
-import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 
-import jdk.vm.ci.common.JVMCIError;
-import jdk.vm.ci.meta.JavaConstant;
-import jdk.vm.ci.meta.JavaKind;
-import jdk.vm.ci.meta.ResolvedJavaMethod;
-import jdk.vm.ci.meta.ResolvedJavaType;
+import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
+import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
 
 /**
  * Implementation of {@link HotSpotJVMCIReflection} in terms of standard JDK reflection API. This is
@@ -68,24 +66,6 @@ boolean isAssignableFrom(HotSpotResolvedObjectTypeImpl holder, HotSpotResolvedOb
 
     }
 
-    @Override
-    Annotation[] getAnnotations(HotSpotResolvedObjectTypeImpl holder) {
-        Class<?> javaMirror = getMirror(holder);
-        return javaMirror.getAnnotations();
-    }
-
-    @Override
-    Annotation[] getDeclaredAnnotations(HotSpotResolvedObjectTypeImpl holder) {
-        Class<?> javaMirror = getMirror(holder);
-        return javaMirror.getDeclaredAnnotations();
-    }
-
-    @Override
-    <T extends Annotation> T getAnnotation(HotSpotResolvedObjectTypeImpl holder, Class<T> annotationClass) {
-        Class<?> javaMirror = getMirror(holder);
-        return javaMirror.getAnnotation(annotationClass);
-    }
-
     @Override
     boolean isLocalClass(HotSpotResolvedObjectTypeImpl holder) {
         Class<?> javaMirror = getMirror(holder);
@@ -132,46 +112,11 @@ ResolvedJavaMethod.Parameter[] getParameters(HotSpotResolvedJavaMethodImpl javaM
         return res;
     }
 
-    @Override
-    Annotation[][] getParameterAnnotations(HotSpotResolvedJavaMethodImpl javaMethod) {
-        return getMethod(javaMethod).getParameterAnnotations();
-    }
-
     @Override
     Type[] getGenericParameterTypes(HotSpotResolvedJavaMethodImpl javaMethod) {
         return getMethod(javaMethod).getGenericParameterTypes();
     }
 
-    @Override
-    Annotation[] getFieldAnnotations(HotSpotResolvedJavaFieldImpl javaField) {
-        return getField(javaField).getAnnotations();
-    }
-
-    @Override
-    Annotation[] getMethodAnnotations(HotSpotResolvedJavaMethodImpl javaMethod) {
-        return getMethod(javaMethod).getAnnotations();
-    }
-
-    @Override
-    Annotation[] getMethodDeclaredAnnotations(HotSpotResolvedJavaMethodImpl javaMethod) {
-        return getMethod(javaMethod).getDeclaredAnnotations();
-    }
-
-    @Override
-    Annotation[] getFieldDeclaredAnnotations(HotSpotResolvedJavaFieldImpl javaField) {
-        return getField(javaField).getDeclaredAnnotations();
-    }
-
-    @Override
-    <T extends Annotation> T getMethodAnnotation(HotSpotResolvedJavaMethodImpl javaMethod, Class<T> annotationClass) {
-        return getMethod(javaMethod).getAnnotation(annotationClass);
-    }
-
-    @Override
-    <T extends Annotation> T getFieldAnnotation(HotSpotResolvedJavaFieldImpl javaField, Class<T> annotationClass) {
-        return getField(javaField).getAnnotation(annotationClass);
-    }
-
     @Override
     HotSpotResolvedObjectTypeImpl getType(HotSpotObjectConstantImpl object) {
         Object value = resolveObject(object);
@@ -191,8 +136,7 @@ String asString(HotSpotObjectConstantImpl object) {
     @Override
     ResolvedJavaType asJavaType(HotSpotObjectConstantImpl object) {
         Object value = resolveObject(object);
-        if (value instanceof Class) {
-            Class<?> javaClass = (Class<?>) value;
+        if (value instanceof Class<?> javaClass) {
             return runtime().fromClass(javaClass);
         }
         if (value instanceof ResolvedJavaType) {
@@ -306,11 +250,7 @@ static Executable getMethod(HotSpotResolvedJavaMethodImpl method) {
 
     /**
      * Gets a {@link Field} object corresponding to {@code field}. This method guarantees the same
-     * {@link Field} object is returned if called twice on the same {@code field} value. This is
-     * required to ensure the results of {@link HotSpotResolvedJavaFieldImpl#getAnnotations()} and
-     * {@link HotSpotResolvedJavaFieldImpl#getAnnotation(Class)} are stable (i.e., for a given field
-     * {@code f} and annotation class {@code a}, the same object is returned for each call to
-     * {@code f.getAnnotation(a)}).
+     * {@link Field} object is returned if called twice on the same {@code field} value.
      */
     static Field getField(HotSpotResolvedJavaFieldImpl field) {
         HotSpotResolvedObjectTypeImpl declaringClass = field.getDeclaringClass();

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotJVMCIReflection.java

@@ -22,13 +22,12 @@
  */
 package jdk.vm.ci.hotspot;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
+import java.lang.reflect.Type;
+
 /**
  * API for reflecting on the internals of HotSpot JVMCI types and objects.
  */
@@ -38,12 +37,6 @@ abstract class HotSpotJVMCIReflection {
 
     abstract boolean isAssignableFrom(HotSpotResolvedObjectTypeImpl holder, HotSpotResolvedObjectTypeImpl otherType);
 
-    abstract Annotation[] getAnnotations(HotSpotResolvedObjectTypeImpl holder);
-
-    abstract Annotation[] getDeclaredAnnotations(HotSpotResolvedObjectTypeImpl holder);
-
-    abstract <T extends Annotation> T getAnnotation(HotSpotResolvedObjectTypeImpl holder, Class<T> annotationClass);
-
     abstract boolean isLocalClass(HotSpotResolvedObjectTypeImpl holder);
 
     abstract boolean isMemberClass(HotSpotResolvedObjectTypeImpl holder);
@@ -56,20 +49,8 @@ abstract class HotSpotJVMCIReflection {
 
     abstract ResolvedJavaMethod.Parameter[] getParameters(HotSpotResolvedJavaMethodImpl javaMethod);
 
-    abstract Annotation[][] getParameterAnnotations(HotSpotResolvedJavaMethodImpl javaMethod);
-
     abstract Type[] getGenericParameterTypes(HotSpotResolvedJavaMethodImpl javaMethod);
 
-    abstract Annotation[] getFieldAnnotations(HotSpotResolvedJavaFieldImpl javaMethod);
-
-    abstract Annotation[] getMethodAnnotations(HotSpotResolvedJavaMethodImpl javaField);
-
-    abstract Annotation[] getMethodDeclaredAnnotations(HotSpotResolvedJavaMethodImpl javaMethod);
-
-    abstract Annotation[] getFieldDeclaredAnnotations(HotSpotResolvedJavaFieldImpl javaMethod);
-
-    abstract <T extends Annotation> T getMethodAnnotation(HotSpotResolvedJavaMethodImpl javaMethod, Class<T> annotationClass);
-
     abstract HotSpotResolvedObjectTypeImpl getType(HotSpotObjectConstantImpl object);
 
     abstract String asString(HotSpotObjectConstantImpl object);
@@ -95,13 +76,11 @@ abstract class HotSpotJVMCIReflection {
 
     abstract JavaConstant boxPrimitive(JavaConstant source);
 
-    abstract <T extends Annotation> T getFieldAnnotation(HotSpotResolvedJavaFieldImpl javaField, Class<T> annotationClass);
-
     /**
      * Resolves {@code objectHandle} to a raw object if possible.
      *
      * @throws HotSpotJVMCIUnsupportedOperationError if {@code objectHandle} refers to an object in
-     *             another heap
+     *                                               another heap
      */
     abstract Object resolveObject(HotSpotObjectConstantImpl objectHandle);
 }

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java

@@ -29,11 +29,8 @@
 import jdk.vm.ci.meta.annotation.AbstractAnnotated;
 import jdk.vm.ci.meta.annotation.AnnotationsInfo;
 
-import java.lang.annotation.Annotation;
-
 import static jdk.internal.misc.Unsafe.ADDRESS_SIZE;
 import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
-import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
 import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
 
@@ -109,7 +106,7 @@ public boolean isInternal() {
      * Determines if a given object contains this field.
      *
      * @return true iff this is a non-static field and its declaring class is assignable from
-     *         {@code object}'s class
+     * {@code object}'s class
      */
     @Override
     public boolean isInObject(JavaConstant object) {
@@ -204,30 +201,6 @@ private boolean hasAnnotations(boolean typeAnnotations) {
         return false;
     }
 
-    @Override
-    public Annotation[] getAnnotations() {
-        if (!hasAnnotations(false)) {
-            return new Annotation[0];
-        }
-        return runtime().reflection.getFieldAnnotations(this);
-    }
-
-    @Override
-    public Annotation[] getDeclaredAnnotations() {
-        if (!hasAnnotations(false)) {
-            return new Annotation[0];
-        }
-        return runtime().reflection.getFieldDeclaredAnnotations(this);
-    }
-
-    @Override
-    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        if (!hasAnnotations(false)) {
-            return null;
-        }
-        return runtime().reflection.getFieldAnnotation(this, annotationClass);
-    }
-
     @Override
     public JavaConstant getConstantValue() {
         return holder.getFieldInfo(index).getConstantValue(holder);

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java

@@ -40,7 +40,6 @@
 import jdk.vm.ci.meta.TriState;
 import jdk.vm.ci.meta.annotation.AnnotationsInfo;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
@@ -449,7 +448,6 @@ public boolean hasCompiledCode() {
     }
 
     /**
-     * @param level
      * @return true if the currently installed code was generated at {@code level}.
      */
     @Override
@@ -506,38 +504,6 @@ public Parameter[] getParameters() {
         return runtime().reflection.getParameters(this);
     }
 
-    @Override
-    public Annotation[][] getParameterAnnotations() {
-        if (!hasAnnotations(HotSpotVMConfig.config().constMethodHasParameterAnnotations)) {
-            return new Annotation[signature.getParameterCount(false)][0];
-        }
-        return runtime().reflection.getParameterAnnotations(this);
-    }
-
-    @Override
-    public Annotation[] getAnnotations() {
-        if (!hasAnnotations(config().constMethodHasMethodAnnotations)) {
-            return new Annotation[0];
-        }
-        return runtime().reflection.getMethodAnnotations(this);
-    }
-
-    @Override
-    public Annotation[] getDeclaredAnnotations() {
-        if (!hasAnnotations(config().constMethodHasMethodAnnotations)) {
-            return new Annotation[0];
-        }
-        return runtime().reflection.getMethodDeclaredAnnotations(this);
-    }
-
-    @Override
-    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        if (!hasAnnotations(config().constMethodHasMethodAnnotations)) {
-            return null;
-        }
-        return runtime().reflection.getMethodAnnotation(this, annotationClass);
-    }
-
     /**
      * Returns whether this method has annotations in the category specified by {@code category}.
      *

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java

@@ -1023,30 +1023,6 @@ private boolean hasDirectAnnotations(boolean typeAnnotations) {
 
     private static final Annotation[] NO_ANNOTATIONS = {};
 
-    @Override
-    public Annotation[] getAnnotations() {
-        if (!mayHaveAnnotations(true)) {
-            return NO_ANNOTATIONS;
-        }
-        return runtime().reflection.getAnnotations(this);
-    }
-
-    @Override
-    public Annotation[] getDeclaredAnnotations() {
-        if (!mayHaveAnnotations(false)) {
-            return NO_ANNOTATIONS;
-        }
-        return runtime().reflection.getDeclaredAnnotations(this);
-    }
-
-    @Override
-    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        if (!mayHaveAnnotations(true)) {
-            return null;
-        }
-        return runtime().reflection.getAnnotation(this, annotationClass);
-    }
-
     /**
      * Performs a fast-path check that this type is resolved in the context of a given accessing
      * class. A negative result does not mean this type is not resolved with respect to

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedPrimitiveType.java

@@ -34,7 +34,6 @@
 import jdk.vm.ci.meta.UnresolvedJavaType;
 import jdk.vm.ci.meta.annotation.AnnotationsInfo;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.Modifier;
 import java.util.List;
 
@@ -254,21 +253,6 @@ public List<? extends ResolvedJavaRecordComponent> getRecordComponents() {
         return null;
     }
 
-    @Override
-    public Annotation[] getAnnotations() {
-        return new Annotation[0];
-    }
-
-    @Override
-    public Annotation[] getDeclaredAnnotations() {
-        return new Annotation[0];
-    }
-
-    @Override
-    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        return null;
-    }
-
     @Override
     public AnnotationsInfo getTypeAnnotationInfo() {
         return null;