[GR-52021] Include targetElement in AnnotationExtractionError.

fniephaus · fniephaus · commit 3a131e2f5779 · 2024-02-20T17:04:57.000Z
PullRequest: graal/16990
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationMetadata.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationMetadata.java
@@ -30,10 +30,9 @@
 import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
 
-import jdk.graal.compiler.debug.GraalError;
-
 import com.oracle.svm.util.ReflectionUtil;
 
+import jdk.graal.compiler.debug.GraalError;
 import jdk.internal.reflect.ConstantPool;
 import sun.reflect.annotation.AnnotationParser;
 import sun.reflect.annotation.TypeNotPresentExceptionProxy;
@@ -42,12 +41,12 @@ public class AnnotationMetadata {
 
     @SuppressWarnings("serial")
     static final class AnnotationExtractionError extends Error {
-        AnnotationExtractionError(Throwable cause) {
-            super(cause);
+        AnnotationExtractionError(Object targetElement, Throwable cause) {
+            super("Failed to process '%s': %s".formatted(targetElement, cause), cause);
         }
 
-        AnnotationExtractionError(String message) {
-            super(message);
+        AnnotationExtractionError(Object targetElement, String message) {
+            super("Failed to process '%s': %s".formatted(targetElement, message));
         }
     }
 
@@ -76,9 +75,9 @@ static Object extractType(ByteBuffer buf, ConstantPool cp, Class<?> container, b
             if (targetException instanceof LinkageError || targetException instanceof TypeNotPresentException) {
                 return new TypeNotPresentExceptionProxy(signature, targetException);
             }
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(signature, e);
         } catch (ReflectiveOperationException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(signature, e);
         }
         return type;
     }
@@ -103,7 +102,7 @@ static Object createAnnotationTypeMismatchExceptionProxy(String message) {
         try {
             return annotationTypeMismatchExceptionProxyConstructor.newInstance(message);
         } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(message, e);
         }
     }
 }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationPrimitiveValue.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationPrimitiveValue.java
@@ -66,7 +66,7 @@ static AnnotationPrimitiveValue extract(ByteBuffer buf, ConstantPool cp, char ta
                 value = cp.getIntAt(constIndex) != 0;
                 break;
             default:
-                throw new AnnotationMetadata.AnnotationExtractionError("Invalid annotation encoding. Unknown tag " + tag);
+                throw new AnnotationMetadata.AnnotationExtractionError(tag, "Invalid annotation encoding. Unknown tag");
         }
         assert Wrapper.forWrapperType(value.getClass()).basicTypeChar() == tag;
         return new AnnotationPrimitiveValue(tag, value);
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationValue.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/AnnotationValue.java
@@ -36,7 +36,6 @@
 import java.util.function.BiConsumer;
 
 import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
-
 import jdk.internal.reflect.ConstantPool;
 import jdk.vm.ci.meta.JavaConstant;
 import sun.reflect.annotation.AnnotationParser;
@@ -95,7 +94,7 @@ static AnnotationValue forAnnotationFormatException() {
             try {
                 memberValue = AnnotationMemberValue.from(annotationType.memberTypes().get(memberName), memberAccessor.invoke(annotation));
             } catch (IllegalAccessException | InvocationTargetException e) {
-                throw new AnnotationMetadata.AnnotationExtractionError(e);
+                throw new AnnotationMetadata.AnnotationExtractionError(annotation, e);
             }
             Object memberDefault = annotationType.memberDefaults().get(memberName);
             if (!memberValue.equals(memberDefault)) {
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/SubstrateAnnotationExtractor.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/annotation/SubstrateAnnotationExtractor.java
@@ -162,7 +162,7 @@ public boolean hasAnnotation(AnnotatedElement element, Class<? extends Annotatio
     @SuppressWarnings("unchecked")
     @Override
     public Class<? extends Annotation>[] getAnnotationTypes(AnnotatedElement element) {
-        return Arrays.stream(getAnnotationData(element, false)).map(AnnotationValue::getType).filter(t -> t != null).toArray(Class[]::new);
+        return Arrays.stream(getAnnotationData(element, false)).map(AnnotationValue::getType).filter(Objects::nonNull).toArray(Class[]::new);
     }
 
     public AnnotationValue[] getDeclaredAnnotationData(AnnotatedElement element) {
@@ -175,8 +175,7 @@ private AnnotationValue[] getAnnotationData(AnnotatedElement element, boolean de
             cur = ((WrappedElement) cur).getWrapped();
         }
         AnnotationValue[] result = NO_ANNOTATIONS;
-        while (cur instanceof AnnotationWrapper) {
-            AnnotationWrapper wrapper = (AnnotationWrapper) cur;
+        while (cur instanceof AnnotationWrapper wrapper) {
             result = concat(result, wrapper.getInjectedAnnotations());
             cur = wrapper.getAnnotationRoot();
         }
@@ -201,11 +200,10 @@ private static AnnotationValue[] concat(AnnotationValue[] a1, AnnotationValue[]
     }
 
     private AnnotationValue[] getAnnotationDataFromRoot(AnnotatedElement rootElement) {
-        if (!(rootElement instanceof Class<?>)) {
+        if (!(rootElement instanceof Class<?> clazz)) {
             return getDeclaredAnnotationDataFromRoot(rootElement);
         }
 
-        Class<?> clazz = (Class<?>) rootElement;
         AnnotationValue[] existing = annotationCache.get(clazz);
         if (existing != null) {
             return existing;
@@ -355,10 +353,10 @@ private static byte[] getRawAnnotations(AnnotatedElement rootElement) {
             } else if (recordComponentClass != null && recordComponentClass.isInstance(rootElement)) {
                 return (byte[]) recordComponentAnnotations.get(rootElement);
             } else {
-                throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());
+                throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());
             }
         } catch (InvocationTargetException | IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(rootElement, e);
         }
     }
 
@@ -369,10 +367,10 @@ private static byte[] getRawParameterAnnotations(Executable rootElement) {
             } else if (rootElement instanceof Constructor<?>) {
                 return (byte[]) constructorParameterAnnotations.get(rootElement);
             } else {
-                throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());
+                throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());
             }
         } catch (IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(rootElement, e);
         }
     }
 
@@ -387,18 +385,18 @@ private static byte[] getRawTypeAnnotations(AnnotatedElement rootElement) {
             } else if (recordComponentClass != null && recordComponentClass.isInstance(rootElement)) {
                 return (byte[]) recordComponentTypeAnnotations.get(rootElement);
             } else {
-                throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());
+                throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());
             }
         } catch (InvocationTargetException | IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(rootElement, e);
         }
     }
 
     private static byte[] getRawAnnotationDefault(Method method) {
         try {
             return (byte[]) methodAnnotationDefault.get(method);
         } catch (IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(method, e);
         }
     }
 
@@ -407,7 +405,7 @@ private static ConstantPool getConstantPool(AnnotatedElement rootElement) {
         try {
             return (ConstantPool) classGetConstantPool.invoke(container);
         } catch (InvocationTargetException | IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(rootElement, e);
         }
     }
 
@@ -422,10 +420,10 @@ private static Class<?> getContainer(AnnotatedElement rootElement) {
             try {
                 return (Class<?>) recordComponentGetDeclaringRecord.invoke(rootElement);
             } catch (IllegalAccessException | InvocationTargetException e) {
-                throw new AnnotationExtractionError(e);
+                throw new AnnotationExtractionError(rootElement, e);
             }
         } else {
-            throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());
+            throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());
         }
     }
 
@@ -443,14 +441,14 @@ private static AnnotatedElement unwrap(AnnotatedElement element) {
     private static AnnotatedElement findRoot(AnnotatedElement element) {
         assert !(element instanceof WrappedElement || element instanceof AnnotationWrapper);
         try {
-            if (element instanceof ResolvedJavaType) {
-                return OriginalClassProvider.getJavaClass((ResolvedJavaType) element);
-            } else if (element instanceof ResolvedJavaMethod) {
-                return OriginalMethodProvider.getJavaMethod((ResolvedJavaMethod) element);
-            } else if (element instanceof ResolvedJavaField) {
-                return OriginalFieldProvider.getJavaField((ResolvedJavaField) element);
-            } else if (element instanceof Package) {
-                return (Class<?>) packageGetPackageInfo.invoke(element);
+            if (element instanceof ResolvedJavaType type) {
+                return OriginalClassProvider.getJavaClass(type);
+            } else if (element instanceof ResolvedJavaMethod method) {
+                return OriginalMethodProvider.getJavaMethod(method);
+            } else if (element instanceof ResolvedJavaField field) {
+                return OriginalFieldProvider.getJavaField(field);
+            } else if (element instanceof Package packageObject) {
+                return (Class<?>) packageGetPackageInfo.invoke(packageObject);
             } else {
                 return element;
             }
@@ -459,9 +457,9 @@ private static AnnotatedElement findRoot(AnnotatedElement element) {
             if (targetException instanceof LinkageError) {
                 throw (LinkageError) targetException;
             }
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(element, e);
         } catch (IllegalAccessException e) {
-            throw new AnnotationExtractionError(e);
+            throw new AnnotationExtractionError(element, e);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,9 @@`
`30`	`30`	`import java.lang.reflect.Method;`
`31`	`31`	`import java.nio.ByteBuffer;`
`32`	`32`
`33`		`-import jdk.graal.compiler.debug.GraalError;`
`34`		`-`
`35`	`33`	`import com.oracle.svm.util.ReflectionUtil;`
`36`	`34`
	`35`	`+import jdk.graal.compiler.debug.GraalError;`
`37`	`36`	`import jdk.internal.reflect.ConstantPool;`
`38`	`37`	`import sun.reflect.annotation.AnnotationParser;`
`39`	`38`	`import sun.reflect.annotation.TypeNotPresentExceptionProxy;`
`@@ -42,12 +41,12 @@ public class AnnotationMetadata {`
`42`	`41`
`43`	`42`	`@SuppressWarnings("serial")`
`44`	`43`	`static final class AnnotationExtractionError extends Error {`
`45`		`- AnnotationExtractionError(Throwable cause) {`
`46`		`- super(cause);`
	`44`	`+ AnnotationExtractionError(Object targetElement, Throwable cause) {`
	`45`	`+ super("Failed to process '%s': %s".formatted(targetElement, cause), cause);`
`47`	`46`	`}`
`48`	`47`
`49`		`- AnnotationExtractionError(String message) {`
`50`		`- super(message);`
	`48`	`+ AnnotationExtractionError(Object targetElement, String message) {`
	`49`	`+ super("Failed to process '%s': %s".formatted(targetElement, message));`
`51`	`50`	`}`
`52`	`51`	`}`
`53`	`52`
`@@ -76,9 +75,9 @@ static Object extractType(ByteBuffer buf, ConstantPool cp, Class<?> container, b`
`76`	`75`	`if (targetException instanceof LinkageError \|\| targetException instanceof TypeNotPresentException) {`
`77`	`76`	`return new TypeNotPresentExceptionProxy(signature, targetException);`
`78`	`77`	`}`
`79`		`- throw new AnnotationExtractionError(e);`
	`78`	`+ throw new AnnotationExtractionError(signature, e);`
`80`	`79`	`} catch (ReflectiveOperationException e) {`
`81`		`- throw new AnnotationExtractionError(e);`
	`80`	`+ throw new AnnotationExtractionError(signature, e);`
`82`	`81`	`}`
`83`	`82`	`return type;`
`84`	`83`	`}`
`@@ -103,7 +102,7 @@ static Object createAnnotationTypeMismatchExceptionProxy(String message) {`
`103`	`102`	`try {`
`104`	`103`	`return annotationTypeMismatchExceptionProxyConstructor.newInstance(message);`
`105`	`104`	`} catch (InvocationTargetException \| InstantiationException \| IllegalAccessException e) {`
`106`		`- throw new AnnotationExtractionError(e);`
	`105`	`+ throw new AnnotationExtractionError(message, e);`
`107`	`106`	`}`
`108`	`107`	`}`
`109`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ static AnnotationPrimitiveValue extract(ByteBuffer buf, ConstantPool cp, char ta`
`66`	`66`	`value = cp.getIntAt(constIndex) != 0;`
`67`	`67`	`break;`
`68`	`68`	`default:`
`69`		`- throw new AnnotationMetadata.AnnotationExtractionError("Invalid annotation encoding. Unknown tag " + tag);`
	`69`	`+ throw new AnnotationMetadata.AnnotationExtractionError(tag, "Invalid annotation encoding. Unknown tag");`
`70`	`70`	`}`
`71`	`71`	`assert Wrapper.forWrapperType(value.getClass()).basicTypeChar() == tag;`
`72`	`72`	`return new AnnotationPrimitiveValue(tag, value);`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ public boolean hasAnnotation(AnnotatedElement element, Class<? extends Annotatio`
`162`	`162`	`@SuppressWarnings("unchecked")`
`163`	`163`	`@Override`
`164`	`164`	`public Class<? extends Annotation>[] getAnnotationTypes(AnnotatedElement element) {`
`165`		`- return Arrays.stream(getAnnotationData(element, false)).map(AnnotationValue::getType).filter(t -> t != null).toArray(Class[]::new);`
	`165`	`+ return Arrays.stream(getAnnotationData(element, false)).map(AnnotationValue::getType).filter(Objects::nonNull).toArray(Class[]::new);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`public AnnotationValue[] getDeclaredAnnotationData(AnnotatedElement element) {`
`@@ -175,8 +175,7 @@ private AnnotationValue[] getAnnotationData(AnnotatedElement element, boolean de`
`175`	`175`	`cur = ((WrappedElement) cur).getWrapped();`
`176`	`176`	`}`
`177`	`177`	`AnnotationValue[] result = NO_ANNOTATIONS;`
`178`		`- while (cur instanceof AnnotationWrapper) {`
`179`		`- AnnotationWrapper wrapper = (AnnotationWrapper) cur;`
	`178`	`+ while (cur instanceof AnnotationWrapper wrapper) {`
`180`	`179`	`result = concat(result, wrapper.getInjectedAnnotations());`
`181`	`180`	`cur = wrapper.getAnnotationRoot();`
`182`	`181`	`}`
`@@ -201,11 +200,10 @@ private static AnnotationValue[] concat(AnnotationValue[] a1, AnnotationValue[]`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`private AnnotationValue[] getAnnotationDataFromRoot(AnnotatedElement rootElement) {`
`204`		`- if (!(rootElement instanceof Class<?>)) {`
	`203`	`+ if (!(rootElement instanceof Class<?> clazz)) {`
`205`	`204`	`return getDeclaredAnnotationDataFromRoot(rootElement);`
`206`	`205`	`}`
`207`	`206`
`208`		`- Class<?> clazz = (Class<?>) rootElement;`
`209`	`207`	`AnnotationValue[] existing = annotationCache.get(clazz);`
`210`	`208`	`if (existing != null) {`
`211`	`209`	`return existing;`
`@@ -355,10 +353,10 @@ private static byte[] getRawAnnotations(AnnotatedElement rootElement) {`
`355`	`353`	`} else if (recordComponentClass != null && recordComponentClass.isInstance(rootElement)) {`
`356`	`354`	`return (byte[]) recordComponentAnnotations.get(rootElement);`
`357`	`355`	`} else {`
`358`		`- throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());`
	`356`	`+ throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());`
`359`	`357`	`}`
`360`	`358`	`} catch (InvocationTargetException \| IllegalAccessException e) {`
`361`		`- throw new AnnotationExtractionError(e);`
	`359`	`+ throw new AnnotationExtractionError(rootElement, e);`
`362`	`360`	`}`
`363`	`361`	`}`
`364`	`362`
`@@ -369,10 +367,10 @@ private static byte[] getRawParameterAnnotations(Executable rootElement) {`
`369`	`367`	`} else if (rootElement instanceof Constructor<?>) {`
`370`	`368`	`return (byte[]) constructorParameterAnnotations.get(rootElement);`
`371`	`369`	`} else {`
`372`		`- throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());`
	`370`	`+ throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());`
`373`	`371`	`}`
`374`	`372`	`} catch (IllegalAccessException e) {`
`375`		`- throw new AnnotationExtractionError(e);`
	`373`	`+ throw new AnnotationExtractionError(rootElement, e);`
`376`	`374`	`}`
`377`	`375`	`}`
`378`	`376`
`@@ -387,18 +385,18 @@ private static byte[] getRawTypeAnnotations(AnnotatedElement rootElement) {`
`387`	`385`	`} else if (recordComponentClass != null && recordComponentClass.isInstance(rootElement)) {`
`388`	`386`	`return (byte[]) recordComponentTypeAnnotations.get(rootElement);`
`389`	`387`	`} else {`
`390`		`- throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());`
	`388`	`+ throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());`
`391`	`389`	`}`
`392`	`390`	`} catch (InvocationTargetException \| IllegalAccessException e) {`
`393`		`- throw new AnnotationExtractionError(e);`
	`391`	`+ throw new AnnotationExtractionError(rootElement, e);`
`394`	`392`	`}`
`395`	`393`	`}`
`396`	`394`
`397`	`395`	`private static byte[] getRawAnnotationDefault(Method method) {`
`398`	`396`	`try {`
`399`	`397`	`return (byte[]) methodAnnotationDefault.get(method);`
`400`	`398`	`} catch (IllegalAccessException e) {`
`401`		`- throw new AnnotationExtractionError(e);`
	`399`	`+ throw new AnnotationExtractionError(method, e);`
`402`	`400`	`}`
`403`	`401`	`}`
`404`	`402`
`@@ -407,7 +405,7 @@ private static ConstantPool getConstantPool(AnnotatedElement rootElement) {`
`407`	`405`	`try {`
`408`	`406`	`return (ConstantPool) classGetConstantPool.invoke(container);`
`409`	`407`	`} catch (InvocationTargetException \| IllegalAccessException e) {`
`410`		`- throw new AnnotationExtractionError(e);`
	`408`	`+ throw new AnnotationExtractionError(rootElement, e);`
`411`	`409`	`}`
`412`	`410`	`}`
`413`	`411`
`@@ -422,10 +420,10 @@ private static Class<?> getContainer(AnnotatedElement rootElement) {`
`422`	`420`	`try {`
`423`	`421`	`return (Class<?>) recordComponentGetDeclaringRecord.invoke(rootElement);`
`424`	`422`	`} catch (IllegalAccessException \| InvocationTargetException e) {`
`425`		`- throw new AnnotationExtractionError(e);`
	`423`	`+ throw new AnnotationExtractionError(rootElement, e);`
`426`	`424`	`}`
`427`	`425`	`} else {`
`428`		`- throw new AnnotationExtractionError("Unexpected annotated element type: " + rootElement.getClass());`
	`426`	`+ throw new AnnotationExtractionError(rootElement, "Unexpected annotated element type: " + rootElement.getClass());`
`429`	`427`	`}`
`430`	`428`	`}`
`431`	`429`
`@@ -443,14 +441,14 @@ private static AnnotatedElement unwrap(AnnotatedElement element) {`
`443`	`441`	`private static AnnotatedElement findRoot(AnnotatedElement element) {`
`444`	`442`	`assert !(element instanceof WrappedElement \|\| element instanceof AnnotationWrapper);`
`445`	`443`	`try {`
`446`		`- if (element instanceof ResolvedJavaType) {`
`447`		`- return OriginalClassProvider.getJavaClass((ResolvedJavaType) element);`
`448`		`- } else if (element instanceof ResolvedJavaMethod) {`
`449`		`- return OriginalMethodProvider.getJavaMethod((ResolvedJavaMethod) element);`
`450`		`- } else if (element instanceof ResolvedJavaField) {`
`451`		`- return OriginalFieldProvider.getJavaField((ResolvedJavaField) element);`
`452`		`- } else if (element instanceof Package) {`
`453`		`- return (Class<?>) packageGetPackageInfo.invoke(element);`
	`444`	`+ if (element instanceof ResolvedJavaType type) {`
	`445`	`+ return OriginalClassProvider.getJavaClass(type);`
	`446`	`+ } else if (element instanceof ResolvedJavaMethod method) {`
	`447`	`+ return OriginalMethodProvider.getJavaMethod(method);`
	`448`	`+ } else if (element instanceof ResolvedJavaField field) {`
	`449`	`+ return OriginalFieldProvider.getJavaField(field);`
	`450`	`+ } else if (element instanceof Package packageObject) {`
	`451`	`+ return (Class<?>) packageGetPackageInfo.invoke(packageObject);`
`454`	`452`	`} else {`
`455`	`453`	`return element;`
`456`	`454`	`}`
`@@ -459,9 +457,9 @@ private static AnnotatedElement findRoot(AnnotatedElement element) {`
`459`	`457`	`if (targetException instanceof LinkageError) {`
`460`	`458`	`throw (LinkageError) targetException;`
`461`	`459`	`}`
`462`		`- throw new AnnotationExtractionError(e);`
	`460`	`+ throw new AnnotationExtractionError(element, e);`
`463`	`461`	`} catch (IllegalAccessException e) {`
`464`		`- throw new AnnotationExtractionError(e);`
	`462`	`+ throw new AnnotationExtractionError(element, e);`
`465`	`463`	`}`
`466`	`464`	`}`
`467`	`465`	`}`