src/java.base/share/classes/sun/reflect/annotation/AnnotationSupport.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.reflect.annotation;

 import java.lang.annotation.*;
 import java.lang.reflect.*;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;

 import jdk.internal.access.SharedSecrets;
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.reflect.ReflectionFactory;

 public final class AnnotationSupport {
     private static final JavaLangAccess LANG_ACCESS = SharedSecrets.getJavaLangAccess();

     /**
      * Finds and returns all annotations in {@code annotations} matching
      * the given {@code annoClass}.
      *
      * Apart from annotations directly present in {@code annotations} this
      * method searches for annotations inside containers i.e. indirectly
      * present annotations.
      *
      * The order of the elements in the array returned depends on the iteration
      * order of the provided map. Specifically, the directly present annotations
      * come before the indirectly present annotations if and only if the
      * directly present annotations come before the indirectly present
      * annotations in the map.
      *
      * @param annotations the {@code Map} in which to search for annotations
      * @param annoClass the type of annotation to search for
      *
      * @return an array of instances of {@code annoClass} or an empty
      *         array if none were found
      */
     public static <A extends Annotation> A[] getDirectlyAndIndirectlyPresent(
             Map<Class<? extends Annotation>, Annotation> annotations,
             Class<A> annoClass) {
         List<A> result = new ArrayList<>();

         @SuppressWarnings("unchecked")
         A direct = (A) annotations.get(annoClass);
         if (direct != null)
             result.add(direct);

         A[] indirect = getIndirectlyPresent(annotations, annoClass);
         if (indirect != null && indirect.length != 0) {
             boolean indirectFirst = direct == null ||
                                     containerBeforeContainee(annotations, annoClass);

             result.addAll((indirectFirst ? 0 : 1), Arrays.asList(indirect));
         }

         @SuppressWarnings("unchecked")
         A[] arr = (A[]) Array.newInstance(annoClass, result.size());
         return result.toArray(arr);
     }

     /**
      * Finds and returns all annotations matching the given {@code annoClass}
      * indirectly present in {@code annotations}.
      *
      * @param annotations annotations to search indexed by their types
      * @param annoClass the type of annotation to search for
      *
      * @return an array of instances of {@code annoClass} or an empty array if no
      *         indirectly present annotations were found
      */
     private static <A extends Annotation> A[] getIndirectlyPresent(
             Map<Class<? extends Annotation>, Annotation> annotations,
             Class<A> annoClass) {

         Repeatable repeatable = annoClass.getDeclaredAnnotation(Repeatable.class);
         if (repeatable == null)
             return null;  // Not repeatable -> no indirectly present annotations

         Class<? extends Annotation> containerClass = repeatable.value();

         Annotation container = annotations.get(containerClass);
         if (container == null)
             return null;

         // Unpack container
         A[] valueArray = getValueArray(container);
         checkTypes(valueArray, container, annoClass);

         return valueArray;
     }


     /**
      * Figures out if container class comes before containee class among the
      * keys of the given map.
      *
      * @return true if container class is found before containee class when
      *         iterating over annotations.keySet().
      */
     private static <A extends Annotation> boolean containerBeforeContainee(
             Map<Class<? extends Annotation>, Annotation> annotations,
             Class<A> annoClass) {

         Class<? extends Annotation> containerClass =
                 annoClass.getDeclaredAnnotation(Repeatable.class).value();

         for (Class<? extends Annotation> c : annotations.keySet()) {
             if (c == containerClass) return true;
             if (c == annoClass) return false;
         }

         // Neither containee nor container present
         return false;
     }


     /**
      * Finds and returns all associated annotations matching the given class.
      *
      * The order of the elements in the array returned depends on the iteration
      * order of the provided maps. Specifically, the directly present annotations
      * come before the indirectly present annotations if and only if the
      * directly present annotations come before the indirectly present
      * annotations in the relevant map.
      *
      * @param declaredAnnotations the declared annotations indexed by their types
      * @param decl the class declaration on which to search for annotations
      * @param annoClass the type of annotation to search for
      *
      * @return an array of instances of {@code annoClass} or an empty array if none were found.
      */
     public static <A extends Annotation> A[] getAssociatedAnnotations(
             Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
             Class<?> decl,
             Class<A> annoClass) {
         Objects.requireNonNull(decl);

         // Search declared
         A[] result = getDirectlyAndIndirectlyPresent(declaredAnnotations, annoClass);

         // Search inherited
         if(AnnotationType.getInstance(annoClass).isInherited()) {
             Class<?> superDecl = decl.getSuperclass();
             while (result.length == 0 && superDecl != null) {
                 result = getDirectlyAndIndirectlyPresent(LANG_ACCESS.getDeclaredAnnotationMap(superDecl), annoClass);
                 superDecl = superDecl.getSuperclass();
             }
         }

         return result;
     }


     /* Reflectively invoke the values-method of the given annotation
      * (container), cast it to an array of annotations and return the result.
      */
     @SuppressWarnings("removal")
     private static <A extends Annotation> 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
             // it to get the content.

             Class<? extends Annotation> containerClass = container.annotationType();
             AnnotationType annoType = AnnotationType.getInstance(containerClass);
             if (annoType == null)
                 throw invalidContainerException(container, null);
             Method m = annoType.members().get("value");
             if (m == null)
                 throw invalidContainerException(container, null);

             if (Proxy.isProxyClass(container.getClass())) {
                 // Invoke by invocation handler
                 InvocationHandler handler = Proxy.getInvocationHandler(container);

                 try {
                     // This will erase to (Annotation[]) but we do a runtime cast on the
                     // return-value in the method that call this method.
                     @SuppressWarnings("unchecked")
                     A[] values = (A[]) handler.invoke(container, m, null);
                     return values;
                 } catch (Throwable t) { // from InvocationHandler::invoke
                     throw invalidContainerException(container, t);
                 }
             } else {
                 // In theory there might be instances of Annotations that are not
                 // implemented using Proxies. Try to invoke the "value" element with
                 // reflection.

                 // Declaring class should be an annotation type
                 Class<?> iface = m.getDeclaringClass();
                 if (!iface.isAnnotation())
                     throw new UnsupportedOperationException("Unsupported container annotation type.");
                 // Method must be public
                 if (!Modifier.isPublic(m.getModifiers()))
                     throw new UnsupportedOperationException("Unsupported value member.");

                 // Interface might not be public though
                 final Method toInvoke;
                 if (!Modifier.isPublic(iface.getModifiers())) {
                     if (System.getSecurityManager() != null) {
                         toInvoke = AccessController.doPrivileged(new PrivilegedAction<Method>() {
                             @Override
                             public Method run() {
                                 Method res = ReflectionFactory.getReflectionFactory().leafCopyMethod(m);
                                 res.setAccessible(true);
                                 return res;
                             }
                         });
                     } else {
                         toInvoke = ReflectionFactory.getReflectionFactory().leafCopyMethod(m);
                         toInvoke.setAccessible(true);
                     }
                 } else {
                     toInvoke = m;
                 }

                 // This will erase to (Annotation[]) but we do a runtime cast on the
                 // return-value in the method that call this method.
                 @SuppressWarnings("unchecked")
                 A[] values = (A[]) toInvoke.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);
         }
     }


     private static AnnotationFormatError invalidContainerException(Annotation anno,
                                                                    Throwable cause) {
         return new AnnotationFormatError(
                 anno + " is an invalid container for repeating annotations",
                 cause);
     }


     /* Sanity check type of all the annotation instances of type {@code annoClass}
      * from {@code container}.
      */
     private static <A extends Annotation> void checkTypes(A[] annotations,
                                                           Annotation container,
                                                           Class<A> annoClass) {
         for (A a : annotations) {
             if (!annoClass.isInstance(a)) {
                 throw new AnnotationFormatError(
                         String.format("%s is an invalid container for " +
                                       "repeating annotations of type: %s",
                                       container, annoClass));
             }
         }
     }
 }
	/*
	* Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.reflect.annotation;

	import java.lang.annotation.*;
	import java.lang.reflect.*;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;

	import jdk.internal.access.SharedSecrets;
	import jdk.internal.access.JavaLangAccess;
	import jdk.internal.reflect.ReflectionFactory;

	public final class AnnotationSupport {
	private static final JavaLangAccess LANG_ACCESS = SharedSecrets.getJavaLangAccess();

	/**
	* Finds and returns all annotations in {@code annotations} matching
	* the given {@code annoClass}.
	*
	* Apart from annotations directly present in {@code annotations} this
	* method searches for annotations inside containers i.e. indirectly
	* present annotations.
	*
	* The order of the elements in the array returned depends on the iteration
	* order of the provided map. Specifically, the directly present annotations
	* come before the indirectly present annotations if and only if the
	* directly present annotations come before the indirectly present
	* annotations in the map.
	*
	* @param annotations the {@code Map} in which to search for annotations
	* @param annoClass the type of annotation to search for
	*
	* @return an array of instances of {@code annoClass} or an empty
	* array if none were found
	*/
	public static <A extends Annotation> A[] getDirectlyAndIndirectlyPresent(
	Map<Class<? extends Annotation>, Annotation> annotations,
	Class<A> annoClass) {
	List<A> result = new ArrayList<>();

	@SuppressWarnings("unchecked")
	A direct = (A) annotations.get(annoClass);
	if (direct != null)
	result.add(direct);

	A[] indirect = getIndirectlyPresent(annotations, annoClass);
	if (indirect != null && indirect.length != 0) {
	boolean indirectFirst = direct == null \|\|
	containerBeforeContainee(annotations, annoClass);

	result.addAll((indirectFirst ? 0 : 1), Arrays.asList(indirect));
	}

	@SuppressWarnings("unchecked")
	A[] arr = (A[]) Array.newInstance(annoClass, result.size());
	return result.toArray(arr);
	}

	/**
	* Finds and returns all annotations matching the given {@code annoClass}
	* indirectly present in {@code annotations}.
	*
	* @param annotations annotations to search indexed by their types
	* @param annoClass the type of annotation to search for
	*
	* @return an array of instances of {@code annoClass} or an empty array if no
	* indirectly present annotations were found
	*/
	private static <A extends Annotation> A[] getIndirectlyPresent(
	Map<Class<? extends Annotation>, Annotation> annotations,
	Class<A> annoClass) {

	Repeatable repeatable = annoClass.getDeclaredAnnotation(Repeatable.class);
	if (repeatable == null)
	return null; // Not repeatable -> no indirectly present annotations

	Class<? extends Annotation> containerClass = repeatable.value();

	Annotation container = annotations.get(containerClass);
	if (container == null)
	return null;

	// Unpack container
	A[] valueArray = getValueArray(container);
	checkTypes(valueArray, container, annoClass);

	return valueArray;
	}


	/**
	* Figures out if container class comes before containee class among the
	* keys of the given map.
	*
	* @return true if container class is found before containee class when
	* iterating over annotations.keySet().
	*/
	private static <A extends Annotation> boolean containerBeforeContainee(
	Map<Class<? extends Annotation>, Annotation> annotations,
	Class<A> annoClass) {

	Class<? extends Annotation> containerClass =
	annoClass.getDeclaredAnnotation(Repeatable.class).value();

	for (Class<? extends Annotation> c : annotations.keySet()) {
	if (c == containerClass) return true;
	if (c == annoClass) return false;
	}

	// Neither containee nor container present
	return false;
	}


	/**
	* Finds and returns all associated annotations matching the given class.
	*
	* The order of the elements in the array returned depends on the iteration
	* order of the provided maps. Specifically, the directly present annotations
	* come before the indirectly present annotations if and only if the
	* directly present annotations come before the indirectly present
	* annotations in the relevant map.
	*
	* @param declaredAnnotations the declared annotations indexed by their types
	* @param decl the class declaration on which to search for annotations
	* @param annoClass the type of annotation to search for
	*
	* @return an array of instances of {@code annoClass} or an empty array if none were found.
	*/
	public static <A extends Annotation> A[] getAssociatedAnnotations(
	Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
	Class<?> decl,
	Class<A> annoClass) {
	Objects.requireNonNull(decl);

	// Search declared
	A[] result = getDirectlyAndIndirectlyPresent(declaredAnnotations, annoClass);

	// Search inherited
	if(AnnotationType.getInstance(annoClass).isInherited()) {
	Class<?> superDecl = decl.getSuperclass();
	while (result.length == 0 && superDecl != null) {
	result = getDirectlyAndIndirectlyPresent(LANG_ACCESS.getDeclaredAnnotationMap(superDecl), annoClass);
	superDecl = superDecl.getSuperclass();
	}
	}

	return result;
	}


	/* Reflectively invoke the values-method of the given annotation
	* (container), cast it to an array of annotations and return the result.
	*/
	@SuppressWarnings("removal")
	private static <A extends Annotation> 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
	// it to get the content.

	Class<? extends Annotation> containerClass = container.annotationType();
	AnnotationType annoType = AnnotationType.getInstance(containerClass);
	if (annoType == null)
	throw invalidContainerException(container, null);
	Method m = annoType.members().get("value");
	if (m == null)
	throw invalidContainerException(container, null);

	if (Proxy.isProxyClass(container.getClass())) {
	// Invoke by invocation handler
	InvocationHandler handler = Proxy.getInvocationHandler(container);

	try {
	// This will erase to (Annotation[]) but we do a runtime cast on the
	// return-value in the method that call this method.
	@SuppressWarnings("unchecked")
	A[] values = (A[]) handler.invoke(container, m, null);
	return values;
	} catch (Throwable t) { // from InvocationHandler::invoke
	throw invalidContainerException(container, t);
	}
	} else {
	// In theory there might be instances of Annotations that are not
	// implemented using Proxies. Try to invoke the "value" element with
	// reflection.

	// Declaring class should be an annotation type
	Class<?> iface = m.getDeclaringClass();
	if (!iface.isAnnotation())
	throw new UnsupportedOperationException("Unsupported container annotation type.");
	// Method must be public
	if (!Modifier.isPublic(m.getModifiers()))
	throw new UnsupportedOperationException("Unsupported value member.");

	// Interface might not be public though
	final Method toInvoke;
	if (!Modifier.isPublic(iface.getModifiers())) {
	if (System.getSecurityManager() != null) {
	toInvoke = AccessController.doPrivileged(new PrivilegedAction<Method>() {
	@Override
	public Method run() {
	Method res = ReflectionFactory.getReflectionFactory().leafCopyMethod(m);
	res.setAccessible(true);
	return res;
	}
	});
	} else {
	toInvoke = ReflectionFactory.getReflectionFactory().leafCopyMethod(m);
	toInvoke.setAccessible(true);
	}
	} else {
	toInvoke = m;
	}

	// This will erase to (Annotation[]) but we do a runtime cast on the
	// return-value in the method that call this method.
	@SuppressWarnings("unchecked")
	A[] values = (A[]) toInvoke.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);
	}
	}


	private static AnnotationFormatError invalidContainerException(Annotation anno,
	Throwable cause) {
	return new AnnotationFormatError(
	anno + " is an invalid container for repeating annotations",
	cause);
	}


	/* Sanity check type of all the annotation instances of type {@code annoClass}
	* from {@code container}.
	*/
	private static <A extends Annotation> void checkTypes(A[] annotations,
	Annotation container,
	Class<A> annoClass) {
	for (A a : annotations) {
	if (!annoClass.isInstance(a)) {
	throw new AnnotationFormatError(
	String.format("%s is an invalid container for " +
	"repeating annotations of type: %s",
	container, annoClass));
	}
	}
	}
	}