Added tests and missing matcher. Fixed handling of bootstrap class lo…

…ader for annotation handler.

byte-buddy-dep/src/main/java/net/bytebuddy/description/annotation/AnnotationDescription.java

@@ -7,9 +7,7 @@
 import net.bytebuddy.description.type.TypeList;
 import net.bytebuddy.utility.PropertyDispatcher;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.AnnotationTypeMismatchException;
-import java.lang.annotation.IncompleteAnnotationException;
+import java.lang.annotation.*;
 import java.lang.reflect.*;
 import java.util.*;
 
@@ -70,6 +68,24 @@ public interface AnnotationDescription {
      */
     <T extends Annotation> Loadable<T> prepare(Class<T> annotationType);
 
+    RetentionPolicy getRetention();
+
+    /**
+     * Checks if this annotation is inherited.
+     *
+     * @return {@code true} if this annotation is inherited.
+     * @see Inherited
+     */
+    boolean isInherited();
+
+    /**
+     * Checks if this annotation is documented.
+     *
+     * @return {@code true} if this annotation is documented.
+     * @see Documented
+     */
+    boolean isDocumented();
+
     /**
      * A description of an annotation's value.
      *
@@ -1074,11 +1090,6 @@ class AnnotationInvocationHandler<T extends Annotation> implements InvocationHan
          */
         private static final String TO_STRING = "toString";
 
-        /**
-         * The class loader to use.
-         */
-        private final ClassLoader classLoader;
-
         /**
          * The loaded annotation type.
          */
@@ -1092,14 +1103,10 @@ class AnnotationInvocationHandler<T extends Annotation> implements InvocationHan
         /**
          * Creates a new invocation handler.
          *
-         * @param classLoader    The class loader for loading this value.
          * @param annotationType The loaded annotation type.
          * @param values         A sorted list of values of this annotation.
          */
-        protected AnnotationInvocationHandler(ClassLoader classLoader,
-                                              Class<T> annotationType,
-                                              LinkedHashMap<Method, AnnotationValue.Loaded<?>> values) {
-            this.classLoader = classLoader;
+        protected AnnotationInvocationHandler(Class<T> annotationType, LinkedHashMap<Method, AnnotationValue.Loaded<?>> values) {
             this.annotationType = annotationType;
             this.values = values;
         }
@@ -1122,9 +1129,9 @@ public static <S extends Annotation> InvocationHandler of(ClassLoader classLoade
                 AnnotationDescription.AnnotationValue<?, ?> annotationValue = values.get(method.getName());
                 loadedValues.put(method, annotationValue == null
                         ? DefaultValue.of(method)
-                        : annotationValue.load(classLoader));
+                        : annotationValue.load(classLoader == null ? ClassLoader.getSystemClassLoader() : classLoader));
             }
-            return new AnnotationInvocationHandler<S>(classLoader, annotationType, loadedValues);
+            return new AnnotationInvocationHandler<S>(annotationType, loadedValues);
         }
 
         /**
@@ -1292,7 +1299,6 @@ public int hashCode() {
         public String toString() {
             return "TypePool.LazyTypeDescription.AnnotationInvocationHandler{" +
                     "annotationType=" + annotationType +
-                    ", classLoader=" + classLoader +
                     ", values=" + values +
                     '}';
         }
@@ -1410,6 +1416,24 @@ public Void resolve() {
      */
     abstract class AbstractAnnotationDescription implements AnnotationDescription {
 
+        @Override
+        public RetentionPolicy getRetention() {
+            AnnotationDescription.Loadable<Retention> retention = getAnnotationType().getDeclaredAnnotations().ofType(Retention.class);
+            return retention == null
+                    ? RetentionPolicy.SOURCE
+                    : retention.loadSilent().value();
+        }
+
+        @Override
+        public boolean isInherited() {
+            return getAnnotationType().getDeclaredAnnotations().isAnnotationPresent(Inherited.class);
+        }
+
+        @Override
+        public boolean isDocumented() {
+            return getAnnotationType().getDeclaredAnnotations().isAnnotationPresent(Documented.class);
+        }
+
         @Override
         public <T> T getValue(MethodDescription methodDescription, Class<T> type) {
             return type.cast(getValue(methodDescription));

byte-buddy-dep/src/main/java/net/bytebuddy/description/annotation/AnnotationList.java

@@ -1,11 +1,15 @@
 package net.bytebuddy.description.annotation;
 
 import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
 import net.bytebuddy.matcher.FilterableList;
 
 import java.lang.annotation.Annotation;
-import java.lang.annotation.Inherited;
-import java.util.*;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
 
 /**
  * Defines a list of annotation instances.
@@ -46,6 +50,14 @@ public interface AnnotationList extends FilterableList<AnnotationDescription, An
      */
     AnnotationList inherited(Set<? extends TypeDescription> ignoredTypes);
 
+    /**
+     * Only retains annotations with the given retention policy.
+     *
+     * @param matcher A matcher for the required retention policy.
+     * @return A of annotations only with elements
+     */
+    AnnotationList visibility(ElementMatcher<? super RetentionPolicy> matcher);
+
     /**
      * An abstract base implementation of an annotation list.
      */
@@ -64,7 +76,7 @@ public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
         @Override
         public boolean isAnnotationPresent(TypeDescription annotationType) {
             for (AnnotationDescription annotation : this) {
-                if (annotation.getAnnotationType().represents(annotation.getClass())) {
+                if (annotation.getAnnotationType().equals(annotationType)) {
                     return true;
                 }
             }
@@ -83,16 +95,26 @@ public <T extends Annotation> AnnotationDescription.Loadable<T> ofType(Class<T>
 
         @Override
         public AnnotationList inherited(Set<? extends TypeDescription> ignoredTypes) {
-            List<AnnotationDescription> inherited = new LinkedList<AnnotationDescription>();
+            List<AnnotationDescription> inherited = new ArrayList<AnnotationDescription>(size());
             for (AnnotationDescription annotation : this) {
-                if (!ignoredTypes.contains(annotation.getAnnotationType())
-                        && annotation.getAnnotationType().getDeclaredAnnotations().isAnnotationPresent(Inherited.class)) {
+                if (!ignoredTypes.contains(annotation.getAnnotationType()) && annotation.isInherited()) {
                     inherited.add(annotation);
                 }
             }
             return wrap(inherited);
         }
 
+        @Override
+        public AnnotationList visibility(ElementMatcher<? super RetentionPolicy> matcher) {
+            List<AnnotationDescription> annotationDescriptions = new ArrayList<AnnotationDescription>(size());
+            for (AnnotationDescription annotation : this) {
+                if (matcher.matches(annotation.getRetention())) {
+                    annotationDescriptions.add(annotation);
+                }
+            }
+            return wrap(annotationDescriptions);
+        }
+
         @Override
         protected AnnotationList wrap(List<AnnotationDescription> values) {
             return new Explicit(values);
@@ -234,5 +256,10 @@ public <T extends Annotation> AnnotationDescription.Loadable<T> ofType(Class<T>
         public AnnotationList inherited(Set<? extends TypeDescription> ignoredTypes) {
             return this;
         }
+
+        @Override
+        public AnnotationList visibility(ElementMatcher<? super RetentionPolicy> matcher) {
+            return this;
+        }
     }
 }

byte-buddy-dep/src/main/java/net/bytebuddy/description/type/TypeList.java

@@ -43,7 +43,7 @@ public interface TypeList extends FilterableList<TypeDescription, TypeList> {
      * @param visitor The visitor to apply to each type.
      * @return This type list with all types transformed by the supplied visitor.
      */
-    TypeList accept(GenericTypeDescription.Visitor<? extends TypeDescription> visitor);
+    GenericTypeList accept(GenericTypeDescription.Visitor<? extends GenericTypeDescription> visitor);
 
     /**
      * An abstract base implementation of a type list.
@@ -56,12 +56,12 @@ protected TypeList wrap(List<TypeDescription> values) {
         }
 
         @Override
-        public TypeList accept(GenericTypeDescription.Visitor<? extends TypeDescription> visitor) {
-            List<TypeDescription> visited = new ArrayList<TypeDescription>(size());
+        public GenericTypeList accept(GenericTypeDescription.Visitor<? extends GenericTypeDescription> visitor) {
+            List<GenericTypeDescription> visited = new ArrayList<GenericTypeDescription>(size());
             for (TypeDescription typeDescription : this) {
                 visited.add(typeDescription.accept(visitor));
             }
-            return new Explicit(visited);
+            return new GenericTypeList.Explicit(visited);
         }
     }
 
@@ -199,8 +199,8 @@ public GenericTypeList asGenericTypes() {
         }
 
         @Override
-        public TypeList accept(GenericTypeDescription.Visitor<? extends TypeDescription> visitor) {
-            return this;
+        public GenericTypeList accept(GenericTypeDescription.Visitor<? extends GenericTypeDescription> visitor) {
+            return new GenericTypeList.Empty();
         }
     }
 }

byte-buddy-dep/src/main/java/net/bytebuddy/matcher/ElementMatchers.java

@@ -7,6 +7,7 @@
 import net.bytebuddy.description.annotation.AnnotationDescription;
 import net.bytebuddy.description.annotation.AnnotationList;
 import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
 import net.bytebuddy.description.method.MethodDescription;
 import net.bytebuddy.description.method.MethodList;
 import net.bytebuddy.description.method.ParameterDescription;
@@ -284,6 +285,18 @@ public static <T extends MethodDescription> ElementMatcher.Junction<T> anyOf(Met
         return anyOf(new MethodList.ForLoadedType(new Constructor<?>[0], nonNull(value)));
     }
 
+    /**
+     * Creates a matcher that matches any of the given fields as {@link FieldDescription}s
+     * by the {@link java.lang.Object#equals(Object)} method. None of the values must be {@code null}.
+     *
+     * @param value The input values to be compared against.
+     * @param <T>   The type of the matched object.
+     * @return A matcher that checks for the equality with any of the given objects.
+     */
+    public static <T extends FieldDescription> ElementMatcher.Junction<T> anyOf(Field... value) {
+        return anyOf(new FieldList.ForLoadedField(nonNull(value)));
+    }
+
     /**
      * Creates a matcher that matches any of the given annotations as {@link AnnotationDescription}s
      * by the {@link java.lang.Object#equals(Object)} method. None of the values must be {@code null}.

byte-buddy-dep/src/main/java/net/bytebuddy/pool/TypePool.java

@@ -5244,7 +5244,7 @@ public S load() throws ClassNotFoundException {
                 public S load(ClassLoader classLoader) throws ClassNotFoundException {
                     return (S) Proxy.newProxyInstance(classLoader,
                             new Class<?>[]{annotationType},
-                            AnnotationInvocationHandler.of(annotationType.getClassLoader(), annotationType, values));
+                            AnnotationInvocationHandler.of(classLoader, annotationType, values));
                 }
 
                 @Override

byte-buddy-dep/src/test/java/net/bytebuddy/description/annotation/AbstractAnnotationDescriptionTest.java

@@ -13,9 +13,7 @@
 import org.mockito.stubbing.Answer;
 import org.objectweb.asm.Opcodes;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.*;
 import java.lang.reflect.Method;
 import java.util.Collections;
 
@@ -375,6 +373,23 @@ public void testValuesDefaults() throws Exception {
         assertValue(defaultSecond, "annotationArrayValue", new AnnotationDescription[]{AnnotationDescription.ForLoadedAnnotation.of(OTHER_ANNOTATION)}, OTHER_ANNOTATION_ARRAY);
     }
 
+    @Test
+    public void testRetention() throws Exception {
+        assertThat(describe(first).getRetention(), is(RetentionPolicy.RUNTIME));
+    }
+
+    @Test
+    public void testInheritance() throws Exception {
+        assertThat(describe(first).isInherited(), is(false));
+        assertThat(describe(defaultFirst).isInherited(), is(true));
+    }
+
+    @Test
+    public void testDocumented() throws Exception {
+        assertThat(describe(first).isDocumented(), is(false));
+        assertThat(describe(defaultFirst).isDocumented(), is(true));
+    }
+
     private void assertValue(Annotation annotation, String methodName, Object rawValue, Object loadedValue) throws Exception {
         assertThat(describe(annotation).getValue(new MethodDescription
                 .ForLoadedMethod(annotation.annotationType().getDeclaredMethod(methodName))), is(rawValue));
@@ -450,6 +465,8 @@ public enum SampleEnumeration {
         Other[] annotationArrayValue();
     }
 
+    @Documented
+    @Inherited
     @Retention(RetentionPolicy.RUNTIME)
     public @interface SampleDefault {