--- old/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-25 12:06:33.000000000 -0700 +++ new/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-25 12:06:32.000000000 -0700 @@ -27,6 +27,10 @@ import java.lang.annotation.Annotation; import java.lang.annotation.AnnotationFormatError; +import java.lang.annotation.Repeatable; +import java.util.Objects; +import sun.reflect.annotation.AnnotationSupport; +import sun.reflect.annotation.AnnotationType; /** * Represents an annotated element of the program currently running in this @@ -222,6 +226,16 @@ * The caller of this method is free to modify the returned array; it will * have no effect on the arrays returned to other callers. * + * @implSpec The default implementation first calls {@link + * #getDeclaredAnnotationsByType(Class)} on the argument type. If + * the returned array has size greater than zero, the array is + * returned. If the returned array has size zero and this {@code + * AnnotatedElement} is a class and the argument type is an + * inheritable annotation, and the superclass of this {@code + * AnnoatedElement} is non-null, then the result of {@code + * getAnnotationsByType(annotationClass)} on the superclass is + * returned. Otherwise, a zero-length array is returned. + * * @param the type of the annotation to query for and return if present * @param annotationClass the Class object corresponding to the * annotation type @@ -230,8 +244,30 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getAnnotationsByType(Class annotationClass); + default T[] getAnnotationsByType(Class annotationClass) { + /* + * Definition of associated: directly or indirectly present OR + * neither directly nor indirectly present AND the element is + * a Class, the annotation type is inheritable, and the + * annotation type is associated with the superclass of the + * element. + */ + T[] result = getDeclaredAnnotationsByType(annotationClass); + + if (result.length == 0 && // Neither directly nor indirectly present + this instanceof Class && // the element is a class + AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable + Class clazz = ((Class) this).getSuperclass(); + if (clazz != null) { + // Determine if the annotation is associated with the + // superclass + result = clazz.getAnnotationsByType(annotationClass); + } + } + return result; + } + /** * Returns this element's annotation for the specified type if * such an annotation is directly present, else null. @@ -239,6 +275,11 @@ * This method ignores inherited annotations. (Returns null if no * annotations are directly present on this element.) * + * @implSpec The default implementation first performs a null check + * and then loops over the results of {@link + * getDeclaredAnnotations} returning the first annotation whose + * annotation type matches the argument type. + * * @param the type of the annotation to query for and return if directly present * @param annotationClass the Class object corresponding to the * annotation type @@ -247,7 +288,18 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T getDeclaredAnnotation(Class annotationClass); + default T getDeclaredAnnotation(Class annotationClass) { + Objects.requireNonNull(annotationClass); + // Loop over all directly-present annotations looking for a matching one + for (Annotation annotation : getDeclaredAnnotations()) { + if (annotationClass.equals(annotation.annotationType())) { + // More robust to do a dynamic cast at runtime instead + // of compile-time only. + return annotationClass.cast(annotation); + } + } + return null; + } /** * Returns this element's annotation(s) for the specified type if @@ -268,6 +320,19 @@ * The caller of this method is free to modify the returned array; it will * have no effect on the arrays returned to other callers. * + * @implSpec The default implementation may call {@link + * #getDeclaredAnnotation(Class)} one or more times to find a + * directly present annotation and, if the annotation type is + * repeatable, to find a container annotation. If the annotation + * type is both directly and indirectly present, {@link + * getDeclaredAnnotations()} will get called to determine the + * order of the elements in the returned array. Alternatively, + * {@link getDeclaredAnnotations()} may be called a single time + * and the returned array examined for both directly and + * indirectly present annotations. The results of calling {@link + * getDeclaredAnnotations()} are assumed to be consistent with the + * results of calling {@code #getDeclaredAnnotation} + * * @param the type of the annotation to query for and return * if directly or indirectly present * @param annotationClass the Class object corresponding to the @@ -277,7 +342,82 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getDeclaredAnnotationsByType(Class annotationClass); + default T[] getDeclaredAnnotationsByType(Class annotationClass) { + Objects.requireNonNull(annotationClass); + int resultSize = 0; + T directlyPresent = getDeclaredAnnotation(annotationClass); + @SuppressWarnings("unchecked") + T[] indirectlyPresent = (T[]) Array.newInstance(annotationClass, 0); + + if (directlyPresent != null) { + resultSize++; + } + + // If the annotation type is repeatable, look through a + // container if one is present + Repeatable repeatable = annotationClass.getAnnotation(Repeatable.class); + Class containerType = null; + if (repeatable != null) { // T is a repeatable annotation type + containerType = repeatable.value(); + Annotation container = this.getDeclaredAnnotation(containerType); + if (container != null) { + indirectlyPresent = AnnotationSupport.getValueArray(container); + resultSize += indirectlyPresent.length; + } + } + + if (resultSize == indirectlyPresent.length) { + assert resultSize == 0 || directlyPresent == null; + /* + * If resultSize is 0, indirectlyPresent is either + * assigned to the result of the initial Array.newInstance + * call or indirectlyPresent is assigned to a zero-length + * value array from an empty container annotation. In + * either case, a zero-length array is immutable and does + * not need to reallocated before being returned. + * + * If resultSize is nonzero, then indirectlyPresent points + * to the result calling a method on an annotation and + * annotations are required to implement a no sharing + * policy. Therefore, it is not required to copy the + * elements of indirectlyPresent into a new array of the + * same size. + */ + return indirectlyPresent; + } else { + assert resultSize > 0 && (directlyPresent != null || indirectlyPresent.length > 0); + @SuppressWarnings("unchecked") + T[] returnValue = (T[]) Array.newInstance(annotationClass, resultSize); + + if (indirectlyPresent.length == 0) { + assert resultSize == 1; + returnValue[0] = directlyPresent; + } else { + assert directlyPresent != null && indirectlyPresent.length > 0; + // Determine whether the directly present annotation + // comes before or after the indirectly present ones. + + int indirectOffset = 0; + + for (Annotation a : getDeclaredAnnotations()) { + if (a.annotationType().equals(annotationClass)) { + indirectOffset = 1; + break; + } else if (a.annotationType().equals(containerType)) { + break; + } + } + + for (int i = 0; i < resultSize; i++) { + returnValue[i + indirectOffset] = indirectlyPresent[i]; + } + + returnValue[(indirectOffset == 1) ? 0 : resultSize - 1] = directlyPresent; + } + return returnValue; + } + } + /** * Returns annotations that are directly present on this element. --- old/src/share/classes/sun/reflect/annotation/AnnotationSupport.java 2013-10-25 12:06:33.000000000 -0700 +++ new/src/share/classes/sun/reflect/annotation/AnnotationSupport.java 2013-10-25 12:06:33.000000000 -0700 @@ -187,10 +187,12 @@ } - /* Reflectively invoke the values-method of the given annotation - * (container), cast it to an array of annotations and return the result. + /* + * Reflectively invoke the values-method of the given annotation + * (container), cast it to an array of annotations and return the + * result. */ - private static A[] getValueArray(Annotation container) { + public static A[] getValueArray(Annotation container) { try { // According to JLS the container must have an array-valued value // method. Get the AnnotationType, get the "value" method and invoke @@ -211,16 +213,12 @@ // return-value in the method that call this method. @SuppressWarnings("unchecked") A[] values = (A[]) m.invoke(container); - return values; - } catch (IllegalAccessException | // couldn't loosen security IllegalArgumentException | // parameters doesn't match InvocationTargetException | // the value method threw an exception ClassCastException e) { - throw invalidContainerException(container, e); - } }