diff --git a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java
index 18be907f5e3..7729c02ccba 100644
--- a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java
+++ b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java
@@ -23,7 +23,6 @@
 import javax.annotation.Nullable;
 import java.lang.annotation.Annotation;
 import java.lang.annotation.Repeatable;
-import java.lang.reflect.AnnotatedElement;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -43,7 +42,7 @@
  * @author Graeme Rocher
  * @since 1.0
  */
-public interface AnnotationMetadata extends AnnotatedElement {
+public interface AnnotationMetadata extends AnnotationSource {
     /**
      * A constant for representing empty metadata.
      */
@@ -179,6 +178,22 @@ public interface AnnotationMetadata extends AnnotatedElement {
      */
     List<AnnotationValue> getDeclaredAnnotationValuesByType(Class<? extends Annotation> annotationType);
 
+    /**
+     * @see AnnotationSource#isAnnotationPresent(Class)
+     */
+    @Override
+    default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return hasAnnotation(annotationClass);
+    }
+
+    /**
+     * @see AnnotationSource#isAnnotationPresent(Class)
+     */
+    @Override
+    default boolean isDeclaredAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return hasDeclaredAnnotation(annotationClass);
+    }
+
     /**
      * Return the default value for the given annotation member.
      *
diff --git a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataDelegate.java b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataDelegate.java
index f8d9841cc32..8882b06588d 100644
--- a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataDelegate.java
+++ b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataDelegate.java
@@ -19,10 +19,9 @@
 import io.micronaut.core.convert.value.ConvertibleValues;
 import io.micronaut.core.value.OptionalValues;
 
+import javax.annotation.Nullable;
 import java.lang.annotation.Annotation;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 
 /**
  * An interface that can be implemented by other classes that delegate the resolution of the {@link AnnotationMetadata}
@@ -33,6 +32,226 @@
  */
 public interface AnnotationMetadataDelegate extends AnnotationMetadataProvider, AnnotationMetadata {
 
+    @Override
+    default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return getAnnotationMetadata().isAnnotationPresent(annotationClass);
+    }
+
+    @Override
+    default boolean isDeclaredAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return getAnnotationMetadata().isDeclaredAnnotationPresent(annotationClass);
+    }
+
+    @Override
+    default <T> Optional<T> getDefaultValue(Class<? extends Annotation> annotation, String member, Class<T> requiredType) {
+        return getAnnotationMetadata().getDefaultValue(annotation, member, requiredType);
+    }
+
+    @Override
+    default <T> Optional<T> getValue(Class<? extends Annotation> annotation, String member, Class<T> requiredType) {
+        return getAnnotationMetadata().getValue(annotation, member, requiredType);
+    }
+
+    @Override
+    default Optional<String> getAnnotationNameByStereotype(String stereotype) {
+        return getAnnotationMetadata().getAnnotationNameByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<String> getDeclaredAnnotationNameTypeByStereotype(String stereotype) {
+        return getAnnotationMetadata().getDeclaredAnnotationNameTypeByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<Class<? extends Annotation>> getAnnotationTypeByStereotype(Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().getAnnotationTypeByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<Class<? extends Annotation>> getDeclaredAnnotationTypeByStereotype(Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().getDeclaredAnnotationTypeByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<Class<? extends Annotation>> getDeclaredAnnotationTypeByStereotype(String stereotype) {
+        return getAnnotationMetadata().getDeclaredAnnotationTypeByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<Class<? extends Annotation>> getAnnotationTypeByStereotype(String stereotype) {
+        return getAnnotationMetadata().getAnnotationTypeByStereotype(stereotype);
+    }
+
+    @Override
+    default Optional<String> getAnnotationNameByStereotype(Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().getAnnotationNameByStereotype(stereotype);
+    }
+
+    @Override
+    default <T> OptionalValues<T> getValues(Class<? extends Annotation> annotation, Class<T> valueType) {
+        return getAnnotationMetadata().getValues(annotation, valueType);
+    }
+
+    @Override
+    default List<String> getAnnotationNamesByStereotype(Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().getAnnotationNamesByStereotype(stereotype);
+    }
+
+    @Override
+    default List<Class<? extends Annotation>> getAnnotationTypesByStereotype(Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().getAnnotationTypesByStereotype(stereotype);
+    }
+
+    @Override
+    default ConvertibleValues<Object> getValues(Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().getValues(annotation);
+    }
+
+    @Override
+    default <T> Optional<T> getValue(String annotation, String member, Class<T> requiredType) {
+        return getAnnotationMetadata().getValue(annotation, member, requiredType);
+    }
+
+    @Override
+    default OptionalLong longValue(String annotation, String member) {
+        return getAnnotationMetadata().longValue(annotation, member);
+    }
+
+    @Override
+    default Optional<Class> classValue(String annotation) {
+        return getAnnotationMetadata().classValue(annotation);
+    }
+
+    @Override
+    default Optional<Class> classValue(String annotation, String member) {
+        return getAnnotationMetadata().classValue(annotation, member);
+    }
+
+    @Override
+    default Optional<Class> classValue(Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().classValue(annotation);
+    }
+
+    @Override
+    default Optional<Class> classValue(Class<? extends Annotation> annotation, String member) {
+        return getAnnotationMetadata().classValue(annotation, member);
+    }
+
+    @Override
+    default OptionalInt intValue(String annotation, String member) {
+        return getAnnotationMetadata().intValue(annotation, member);
+    }
+
+    @Override
+    default OptionalDouble doubleValue(String annotation, String member) {
+        return getAnnotationMetadata().doubleValue(annotation, member);
+    }
+
+    @Override
+    default <T> Optional<T> getValue(String annotation, Class<T> requiredType) {
+        return getAnnotationMetadata().getValue(annotation, requiredType);
+    }
+
+    @Override
+    default Optional<Object> getValue(String annotation, String member) {
+        return getAnnotationMetadata().getValue(annotation, member);
+    }
+
+    @Override
+    default Optional<Object> getValue(Class<? extends Annotation> annotation, String member) {
+        return getAnnotationMetadata().getValue(annotation, member);
+    }
+
+    @Override
+    default boolean isTrue(String annotation, String member) {
+        return getAnnotationMetadata().isTrue(annotation, member);
+    }
+
+    @Override
+    default boolean isTrue(Class<? extends Annotation> annotation, String member) {
+        return getAnnotationMetadata().isTrue(annotation, member);
+    }
+
+    @Override
+    default boolean isPresent(String annotation, String member) {
+        return getAnnotationMetadata().isPresent(annotation, member);
+    }
+
+    @Override
+    default boolean isPresent(Class<? extends Annotation> annotation, String member) {
+        return getAnnotationMetadata().isPresent(annotation, member);
+    }
+
+    @Override
+    default boolean isFalse(Class<? extends Annotation> annotation, String member) {
+        return getAnnotationMetadata().isFalse(annotation, member);
+    }
+
+    @Override
+    default boolean isFalse(String annotation, String member) {
+        return getAnnotationMetadata().isFalse(annotation, member);
+    }
+
+    @Override
+    default Optional<Object> getValue(String annotation) {
+        return getAnnotationMetadata().getValue(annotation);
+    }
+
+    @Override
+    default Optional<Object> getValue(Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().getValue(annotation);
+    }
+
+    @Override
+    default <T> Optional<T> getValue(Class<? extends Annotation> annotation, Class<T> requiredType) {
+        return getAnnotationMetadata().getValue(annotation, requiredType);
+    }
+
+    @Override
+    default boolean hasAnnotation(@Nullable Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().hasAnnotation(annotation);
+    }
+
+    @Override
+    default boolean hasStereotype(@Nullable Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().hasStereotype(annotation);
+    }
+
+    @Override
+    default boolean hasStereotype(Class<? extends Annotation>... annotations) {
+        return getAnnotationMetadata().hasStereotype(annotations);
+    }
+
+    @Override
+    default boolean hasStereotype(String[] annotations) {
+        return getAnnotationMetadata().hasStereotype(annotations);
+    }
+
+    @Override
+    default boolean hasDeclaredAnnotation(@Nullable Class<? extends Annotation> annotation) {
+        return getAnnotationMetadata().hasDeclaredAnnotation(annotation);
+    }
+
+    @Override
+    default boolean hasDeclaredStereotype(@Nullable Class<? extends Annotation> stereotype) {
+        return getAnnotationMetadata().hasDeclaredStereotype(stereotype);
+    }
+
+    @Override
+    default boolean hasDeclaredStereotype(Class<? extends Annotation>... annotations) {
+        return getAnnotationMetadata().hasDeclaredStereotype(annotations);
+    }
+
+    @Override
+    default boolean isEmpty() {
+        return getAnnotationMetadata().isEmpty();
+    }
+
+    @Override
+    default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
+        return getAnnotationMetadata().getDeclaredAnnotation(annotationClass);
+    }
+
     @Override
     default boolean hasDeclaredAnnotation(String annotation) {
         return getAnnotationMetadata().hasDeclaredAnnotation(annotation);
diff --git a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataProvider.java b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataProvider.java
index 55634b3ca19..4a0b2ee6d2b 100644
--- a/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataProvider.java
+++ b/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadataProvider.java
@@ -16,13 +16,15 @@
 
 package io.micronaut.core.annotation;
 
+import java.lang.annotation.Annotation;
+
 /**
  * An interface for a type that provides {@link AnnotationMetadata}.
  *
  * @author Graeme Rocher
  * @since 1.0
  */
-public interface AnnotationMetadataProvider {
+public interface AnnotationMetadataProvider extends AnnotationSource {
 
     /**
      * Supplies the metadata. Defaults to {@link AnnotationMetadata#EMPTY_METADATA}.
@@ -32,4 +34,44 @@ public interface AnnotationMetadataProvider {
     default AnnotationMetadata getAnnotationMetadata() {
         return AnnotationMetadata.EMPTY_METADATA;
     }
+
+    @Override
+    default <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+        return getAnnotationMetadata().getAnnotation(annotationClass);
+    }
+
+    @Override
+    default Annotation[] getAnnotations() {
+        return getAnnotationMetadata().getAnnotations();
+    }
+
+    @Override
+    default Annotation[] getDeclaredAnnotations() {
+        return getAnnotationMetadata().getDeclaredAnnotations();
+    }
+
+    @Override
+    default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return getAnnotationMetadata().isAnnotationPresent(annotationClass);
+    }
+
+    @Override
+    default boolean isDeclaredAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return getAnnotationMetadata().isDeclaredAnnotationPresent(annotationClass);
+    }
+
+    @Override
+    default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
+        return getAnnotationMetadata().getAnnotationsByType(annotationClass);
+    }
+
+    @Override
+    default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
+        return getAnnotationMetadata().getDeclaredAnnotation(annotationClass);
+    }
+
+    @Override
+    default <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
+        return getAnnotationMetadata().getDeclaredAnnotationsByType(annotationClass);
+    }
 }
diff --git a/core/src/main/java/io/micronaut/core/annotation/AnnotationSource.java b/core/src/main/java/io/micronaut/core/annotation/AnnotationSource.java
index e5ad037b93a..aa193744d59 100644
--- a/core/src/main/java/io/micronaut/core/annotation/AnnotationSource.java
+++ b/core/src/main/java/io/micronaut/core/annotation/AnnotationSource.java
@@ -21,21 +21,7 @@
 import java.util.*;
 
 /**
- * <p>
- * An abstract interface around an source of {@link Annotation} instances. Since bean definition instances
- * can read annotations from many potential sources (factory beans, factory methods, method level, class level etc.). This
- * abstraction allows a simplified view for annotation discovery.
- * </p>
- * <p>
- * <p>Generally annotation sources are prioritized in the following order:</p>
- * <p>
- * <ol>
- *     <li>Method Level</li>
- *     <li>Class Level</li>
- *     <li>Factory Method</li>
- *     <li>Factory Class</li>
- * </ol>
- * <p>
+ * Subclass of {@link AnnotatedElement} that provides default implementations.
  *
  * @author Graeme Rocher
  * @since 1.0
@@ -44,92 +30,45 @@ public interface AnnotationSource extends AnnotatedElement {
     /**
      * An empty annotation source.
      */
-    AnnotationSource EMPTY = () -> AnnotationUtil.ZERO_ANNOTATED_ELEMENTS;
-    /**
-     * <p>The annotated elements that this {@link AnnotationSource} is able to resolve annotations from</p>.
-     *
-     * @return An array of {@link AnnotatedElement} instances
-     */
-    AnnotatedElement[] getAnnotatedElements();
-
+    AnnotationSource EMPTY = new AnnotationSource() { };
 
     /**
-     * Get a concrete annotation for the given annotation type searching all of the {@link #getAnnotatedElements()}.
+     * Returns null by default.
      *
-     * @param annotationClass The annotation class
-     * @param <T>             The annotation generic type
-     * @return The annotation or null if it doesn't exist
+     * @see AnnotatedElement#getAnnotation(Class)
      */
     @Override
     default <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        AnnotationMetadata annotationMetadata = null;
-        if (this instanceof AnnotationMetadataProvider) {
-            annotationMetadata = ((AnnotationMetadataProvider) this).getAnnotationMetadata();
-        } else if (this instanceof AnnotationMetadata) {
-            annotationMetadata = (AnnotationMetadata) this;
-        }
-
-        if (annotationMetadata != null && annotationMetadata != AnnotationMetadata.EMPTY_METADATA) {
-            return annotationMetadata.getAnnotation(annotationClass);
-        } else {
-            // slow path
-            for (AnnotatedElement annotatedElement : getAnnotatedElements()) {
-                try {
-                    T annotation = annotatedElement.getAnnotation(annotationClass);
-                    if (annotation != null) {
-                        return annotation;
-                    }
-                } catch (ArrayStoreException | TypeNotPresentException e) {
-                    // ignore, annotation that references a class not on the classpath
-                }
-            }
-            return null;
-        }
-
+        return null;
     }
 
     /**
-     * @return A merged view of all of the annotations from {@link  #getAnnotatedElements()}
+     * @see AnnotatedElement#getAnnotations()
      */
     @Override
     default Annotation[] getAnnotations() {
-        AnnotationMetadata annotationMetadata = null;
-        if (this instanceof AnnotationMetadataProvider) {
-            annotationMetadata = ((AnnotationMetadataProvider) this).getAnnotationMetadata();
-        } else if (this instanceof AnnotationMetadata) {
-            annotationMetadata = (AnnotationMetadata) this;
-        }
-
-        if (annotationMetadata != null && annotationMetadata != AnnotationMetadata.EMPTY_METADATA) {
-            return annotationMetadata.getAnnotations();
-        } else {
-            AnnotatedElement[] elements = getAnnotatedElements();
-            return Arrays.stream(elements)
-                    .flatMap(element -> Arrays.stream(element.getAnnotations()))
-                    .toArray(Annotation[]::new);
-        }
+        return AnnotationUtil.ZERO_ANNOTATIONS;
     }
 
     /**
-     * @return A merged view of all of the declared annotations from {@link  #getAnnotatedElements()}
+     * @see AnnotatedElement#getDeclaredAnnotations()
      */
     @Override
     default Annotation[] getDeclaredAnnotations() {
-        AnnotationMetadata annotationMetadata = null;
-        if (this instanceof AnnotationMetadataProvider) {
-            annotationMetadata = ((AnnotationMetadataProvider) this).getAnnotationMetadata();
-        } else if (this instanceof AnnotationMetadata) {
-            annotationMetadata = (AnnotationMetadata) this;
-        }
+        return AnnotationUtil.ZERO_ANNOTATIONS;
+    }
 
-        if (annotationMetadata != null && annotationMetadata != AnnotationMetadata.EMPTY_METADATA) {
-            return annotationMetadata.getDeclaredAnnotations();
-        } else {
-            AnnotatedElement[] elements = getAnnotatedElements();
-            return Arrays.stream(elements)
-                    .flatMap(element -> Arrays.stream(element.getDeclaredAnnotations()))
-                    .toArray(Annotation[]::new);
-        }
+    @Override
+    default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return false;
     }
 
+    /**
+     * Variation of {@link #isAnnotationPresent(Class)} for declared annotations
+     * @param annotationClass The annotation class
+     * @return True if it is
+     */
+    default boolean isDeclaredAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return false;
+    }
 }
diff --git a/core/src/main/java/io/micronaut/core/convert/ConversionContext.java b/core/src/main/java/io/micronaut/core/convert/ConversionContext.java
index 6e281d88b0b..ac0bc626e10 100644
--- a/core/src/main/java/io/micronaut/core/convert/ConversionContext.java
+++ b/core/src/main/java/io/micronaut/core/convert/ConversionContext.java
@@ -17,14 +17,12 @@
 package io.micronaut.core.convert;
 
 import io.micronaut.core.annotation.AnnotationSource;
-import io.micronaut.core.annotation.AnnotationUtil;
 import io.micronaut.core.type.Argument;
 import io.micronaut.core.type.TypeVariableResolver;
 import io.micronaut.core.util.ArrayUtils;
 
 import javax.annotation.Nullable;
 import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.Collections;
@@ -72,11 +70,6 @@ default Charset getCharset() {
         return StandardCharsets.UTF_8;
     }
 
-    @Override
-    default AnnotatedElement[] getAnnotatedElements() {
-        return AnnotationUtil.ZERO_ANNOTATED_ELEMENTS;
-    }
-
     /**
      * Augment this context with data for the given argument.
      *
diff --git a/core/src/main/java/io/micronaut/core/convert/DefaultArgumentConversionContext.java b/core/src/main/java/io/micronaut/core/convert/DefaultArgumentConversionContext.java
index 15a88228222..6f5575eef3d 100644
--- a/core/src/main/java/io/micronaut/core/convert/DefaultArgumentConversionContext.java
+++ b/core/src/main/java/io/micronaut/core/convert/DefaultArgumentConversionContext.java
@@ -19,7 +19,6 @@
 import io.micronaut.core.annotation.Internal;
 import io.micronaut.core.type.Argument;
 
-import java.lang.reflect.AnnotatedElement;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -64,11 +63,6 @@ public Map<String, Argument<?>> getTypeVariables() {
         return argument.getTypeVariables();
     }
 
-    @Override
-    public AnnotatedElement[] getAnnotatedElements() {
-        return new AnnotatedElement[]{argument};
-    }
-
     @Override
     public Locale getLocale() {
         return finalLocale;
diff --git a/core/src/main/java/io/micronaut/core/type/Argument.java b/core/src/main/java/io/micronaut/core/type/Argument.java
index 56de02b5524..9dd6d4a71d9 100644
--- a/core/src/main/java/io/micronaut/core/type/Argument.java
+++ b/core/src/main/java/io/micronaut/core/type/Argument.java
@@ -18,7 +18,6 @@
 
 import io.micronaut.core.annotation.AnnotationMetadata;
 import io.micronaut.core.annotation.AnnotationMetadataProvider;
-import io.micronaut.core.annotation.AnnotationSource;
 import io.micronaut.core.naming.NameUtils;
 import io.micronaut.core.naming.Named;
 import io.micronaut.core.reflect.ReflectionUtils;
@@ -36,7 +35,7 @@
  * @author Graeme Rocher
  * @since 1.0
  */
-public interface Argument<T> extends AnnotationSource, TypeVariableResolver, Named, AnnotationMetadataProvider {
+public interface Argument<T> extends TypeVariableResolver, Named, AnnotationMetadataProvider {
 
     /**
      * Constant representing zero arguments.
@@ -75,11 +74,6 @@ public interface Argument<T> extends AnnotationSource, TypeVariableResolver, Nam
      */
     int typeHashCode();
 
-    @Override
-    default AnnotatedElement[] getAnnotatedElements() {
-        return new AnnotatedElement[] { getAnnotationMetadata() };
-    }
-
     /**
      * Returns the string representation of the argument type, including generics.
      *
@@ -246,5 +240,4 @@ static <T> Argument<T> of(Class<T> type, @Nullable Class<?>... typeParameters) {
         }
     }
 
-
 }
diff --git a/core/src/main/java/io/micronaut/core/type/DefaultArgument.java b/core/src/main/java/io/micronaut/core/type/DefaultArgument.java
index 987cda5e63d..51e1dd5355b 100644
--- a/core/src/main/java/io/micronaut/core/type/DefaultArgument.java
+++ b/core/src/main/java/io/micronaut/core/type/DefaultArgument.java
@@ -89,11 +89,6 @@ public Class<T> getType() {
         return type;
     }
 
-    @Override
-    public AnnotatedElement[] getAnnotatedElements() {
-        return new AnnotatedElement[]{annotatedElement};
-    }
-
     @Override
     public String getName() {
         return name;
diff --git a/core/src/main/java/io/micronaut/core/type/DefaultArgumentValue.java b/core/src/main/java/io/micronaut/core/type/DefaultArgumentValue.java
index 4eab612ecc7..4ca6500799b 100644
--- a/core/src/main/java/io/micronaut/core/type/DefaultArgumentValue.java
+++ b/core/src/main/java/io/micronaut/core/type/DefaultArgumentValue.java
@@ -16,10 +16,10 @@
 
 package io.micronaut.core.type;
 
+import io.micronaut.core.annotation.AnnotationMetadata;
 import io.micronaut.core.annotation.Internal;
 
 import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
 import java.util.Map;
 import java.util.Optional;
 
@@ -74,11 +74,6 @@ public V getValue() {
         return value;
     }
 
-    @Override
-    public AnnotatedElement[] getAnnotatedElements() {
-        return argument.getAnnotatedElements();
-    }
-
     @Override
     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
         return argument.getAnnotation(annotationClass);
@@ -103,4 +98,9 @@ public boolean equalsType(Argument<?> o) {
     public int typeHashCode() {
         return argument.typeHashCode();
     }
+
+    @Override
+    public AnnotationMetadata getAnnotationMetadata() {
+        return argument.getAnnotationMetadata();
+    }
 }
diff --git a/core/src/main/java/io/micronaut/core/type/ReturnType.java b/core/src/main/java/io/micronaut/core/type/ReturnType.java
index 2b9a039148a..da5e6627bb6 100644
--- a/core/src/main/java/io/micronaut/core/type/ReturnType.java
+++ b/core/src/main/java/io/micronaut/core/type/ReturnType.java
@@ -17,9 +17,7 @@
 package io.micronaut.core.type;
 
 import io.micronaut.core.annotation.AnnotationSource;
-import io.micronaut.core.annotation.AnnotationUtil;
 
-import java.lang.reflect.AnnotatedElement;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -65,11 +63,6 @@ public Class<T1> getType() {
                 return type;
             }
 
-            @Override
-            public AnnotatedElement[] getAnnotatedElements() {
-                return AnnotationUtil.ZERO_ANNOTATED_ELEMENTS;
-            }
-
             @Override
             public Argument[] getTypeParameters() {
                 return typeArguments;
diff --git a/function-web/src/main/java/io/micronaut/function/web/AnnotatedFunctionRouteBuilder.java b/function-web/src/main/java/io/micronaut/function/web/AnnotatedFunctionRouteBuilder.java
index 2d288c8476f..8ca1f042521 100644
--- a/function-web/src/main/java/io/micronaut/function/web/AnnotatedFunctionRouteBuilder.java
+++ b/function-web/src/main/java/io/micronaut/function/web/AnnotatedFunctionRouteBuilder.java
@@ -88,11 +88,10 @@ public AnnotatedFunctionRouteBuilder(
     @SuppressWarnings("unchecked")
     @Override
     public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> method) {
-        FunctionBean annotation = beanDefinition.getAnnotation(FunctionBean.class);
-        if (annotation != null) {
+        if (beanDefinition.hasAnnotation(FunctionBean.class)) {
             String methodName = method.getMethodName();
             Class<?> declaringType = method.getDeclaringType();
-            String functionName = annotation.value();
+            String functionName = beanDefinition.getValue(FunctionBean.class, String.class).orElse(methodName);
 
             UriRoute route = null;
             if (Stream.of(java.util.function.Function.class, Consumer.class, BiFunction.class, BiConsumer.class).anyMatch(type -> type.isAssignableFrom(declaringType))) {
@@ -103,7 +102,7 @@ public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> met
                 String functionPath = resolveFunctionPath(methodName, declaringType, functionName);
                 route = GET(functionPath, method);
             } else {
-                String functionMethod = annotation.method();
+                String functionMethod = beanDefinition.getValue(FunctionBean.class, "method", String.class).orElse(null);
                 if (StringUtils.isNotEmpty(functionMethod)) {
                     if (functionMethod.equals(methodName)) {
                         int argCount = method.getArguments().length;
diff --git a/http-server/src/main/java/io/micronaut/http/server/binding/RequestArgumentSatisfier.java b/http-server/src/main/java/io/micronaut/http/server/binding/RequestArgumentSatisfier.java
index d9cb1515830..a5c3b2bc742 100644
--- a/http-server/src/main/java/io/micronaut/http/server/binding/RequestArgumentSatisfier.java
+++ b/http-server/src/main/java/io/micronaut/http/server/binding/RequestArgumentSatisfier.java
@@ -127,7 +127,7 @@ protected Optional<Object> getValueForArgument(Argument argument, HttpRequest<?>
                     }
                 } else if (bindingResult.isPresentAndSatisfied()) {
                     value = bindingResult.get();
-                } else if (HttpMethod.requiresRequestBody(request.getMethod()) || argument.getDeclaredAnnotation(Nullable.class) != null) {
+                } else if (HttpMethod.requiresRequestBody(request.getMethod()) || argument.isDeclaredAnnotationPresent(Nullable.class)) {
                     value = (UnresolvedArgument) () -> {
                         ArgumentBinder.BindingResult result = argumentBinder.bind(conversionContext, request);
                         Optional<ConversionError> lastError = conversionContext.getLastError();
diff --git a/inject/src/main/java/io/micronaut/context/AbstractBeanDefinition.java b/inject/src/main/java/io/micronaut/context/AbstractBeanDefinition.java
index 53a93a43c05..f227b74b2aa 100644
--- a/inject/src/main/java/io/micronaut/context/AbstractBeanDefinition.java
+++ b/inject/src/main/java/io/micronaut/context/AbstractBeanDefinition.java
@@ -730,7 +730,7 @@ protected final Object getValueForMethodArgument(BeanResolutionContext resolutio
                         if (value.isPresent()) {
                             return value.get();
                         } else {
-                            if (argument.getDeclaredAnnotation(Nullable.class) != null) {
+                            if (argument.isDeclaredAnnotationPresent(Nullable.class)) {
                                 return null;
                             }
                             throw new DependencyInjectionException(resolutionContext, injectionPoint, conversionContext, valString);
@@ -917,7 +917,7 @@ protected final Object getBeanForConstructorArgument(BeanResolutionContext resol
         } else {
             BeanResolutionContext.Path path = resolutionContext.getPath();
             BeanResolutionContext.Segment current = path.peek();
-            boolean isNullable = argument.getDeclaredAnnotation(Nullable.class) != null;
+            boolean isNullable = argument.isDeclaredAnnotationPresent(Nullable.class);
             if (isNullable && current != null && current.getArgument().equals(argument)) {
                 return null;
             } else {
@@ -1115,7 +1115,7 @@ protected final Object getValueForField(BeanResolutionContext resolutionContext,
                         if (value.isPresent()) {
                             return value.get();
                         } else {
-                            if (fieldArgument.getDeclaredAnnotation(Nullable.class) != null) {
+                            if (fieldArgument.isDeclaredAnnotationPresent(Nullable.class)) {
                                 return null;
                             }
                             throw new DependencyInjectionException(resolutionContext, injectionPoint, "Error resolving field value [" + valString + "]. Property doesn't exist or cannot be converted");
@@ -1273,7 +1273,7 @@ protected final Object getBeanForField(BeanResolutionContext resolutionContext,
                 path.pop();
                 return bean;
             } catch (NoSuchBeanException e) {
-                if (injectionPoint.getDeclaredAnnotation(Nullable.class) != null) {
+                if (injectionPoint.isDeclaredAnnotationPresent(Nullable.class)) {
                     path.pop();
                     return null;
                 }
@@ -1433,7 +1433,7 @@ private Object getBeanForMethodArgument(BeanResolutionContext resolutionContext,
                 path.pop();
                 return bean;
             } catch (NoSuchBeanException e) {
-                if (argument.getDeclaredAnnotation(Nullable.class) != null) {
+                if (argument.isDeclaredAnnotationPresent(Nullable.class)) {
                     path.pop();
                     return null;
                 }
diff --git a/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java b/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java
index 2900631c4d5..3f61cd58224 100644
--- a/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java
+++ b/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java
@@ -18,7 +18,6 @@
 
 import io.micronaut.context.env.Environment;
 import io.micronaut.core.annotation.AnnotationMetadata;
-import io.micronaut.core.annotation.AnnotationUtil;
 import io.micronaut.core.annotation.Internal;
 import io.micronaut.core.reflect.ReflectionUtils;
 import io.micronaut.core.type.Argument;
@@ -28,8 +27,6 @@
 import io.micronaut.inject.annotation.DefaultAnnotationMetadata;
 
 import javax.annotation.Nullable;
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Map;
@@ -209,20 +206,6 @@ public Class<Object> getType() {
             }
         }
 
-        @Override
-        public AnnotatedElement[] getAnnotatedElements() {
-            Method method = getTargetMethod();
-            if (method != null) {
-                return new AnnotatedElement[]{method.getAnnotatedReturnType(), method};
-            } else {
-                if (genericReturnType != null) {
-                    return genericReturnType.getAnnotatedElements();
-                } else {
-                    return AnnotationUtil.ZERO_ANNOTATED_ELEMENTS;
-                }
-            }
-        }
-
         @Override
         public Argument[] getTypeParameters() {
             if (genericReturnType != null) {
diff --git a/inject/src/main/java/io/micronaut/inject/FieldInjectionPoint.java b/inject/src/main/java/io/micronaut/inject/FieldInjectionPoint.java
index 8fd793709c9..8708c994e5a 100644
--- a/inject/src/main/java/io/micronaut/inject/FieldInjectionPoint.java
+++ b/inject/src/main/java/io/micronaut/inject/FieldInjectionPoint.java
@@ -29,7 +29,7 @@
  * @author Graeme Rocher
  * @since 1.0
  */
-public interface FieldInjectionPoint<T> extends InjectionPoint, AnnotatedElement, AnnotationMetadataProvider {
+public interface FieldInjectionPoint<T> extends InjectionPoint, AnnotationMetadataProvider {
 
     /**
      * @return The name of the field
diff --git a/router/src/main/java/io/micronaut/web/router/AbstractRouteMatch.java b/router/src/main/java/io/micronaut/web/router/AbstractRouteMatch.java
index b736eb4b7dc..132a47bbded 100644
--- a/router/src/main/java/io/micronaut/web/router/AbstractRouteMatch.java
+++ b/router/src/main/java/io/micronaut/web/router/AbstractRouteMatch.java
@@ -256,7 +256,7 @@ public R execute(Map<String, Object> argumentValues) {
                             argumentList.add(resolveValueOrError(argument, conversionContext, result));
                         }
                     } else {
-                        if (argument.getDeclaredAnnotation(Nullable.class) != null) {
+                        if (argument.isDeclaredAnnotationPresent(Nullable.class)) {
                             argumentList.add(null);
                             continue;
                         } else {
@@ -330,7 +330,7 @@ public RouteMatch<R> fulfill(Map<String, Object> argumentValues) {
     protected Object resolveValueOrError(Argument argument, ConversionContext conversionContext, Optional<?> result) {
         if (!result.isPresent()) {
             Optional<ConversionError> lastError = conversionContext.getLastError();
-            if (!lastError.isPresent() && argument.getDeclaredAnnotation(Nullable.class) != null) {
+            if (!lastError.isPresent() && argument.isDeclaredAnnotationPresent(Nullable.class)) {
                 return null;
             }
             throw lastError.map(conversionError ->
diff --git a/router/src/main/java/io/micronaut/web/router/AnnotatedFilterRouteBuilder.java b/router/src/main/java/io/micronaut/web/router/AnnotatedFilterRouteBuilder.java
index f6738ca3b57..d0d29293298 100644
--- a/router/src/main/java/io/micronaut/web/router/AnnotatedFilterRouteBuilder.java
+++ b/router/src/main/java/io/micronaut/web/router/AnnotatedFilterRouteBuilder.java
@@ -70,10 +70,9 @@ public void process() {
                 // ignore http client filters
                 continue;
             }
-            Filter filterAnn = beanDefinition.getAnnotation(Filter.class);
-            String[] patterns = filterAnn.value();
+            String[] patterns = beanDefinition.getValue(Filter.class, String[].class).orElse(null);
             if (ArrayUtils.isNotEmpty(patterns)) {
-                HttpMethod[] methods = filterAnn.methods();
+                HttpMethod[] methods = beanDefinition.getValue(Filter.class, "methods", HttpMethod[].class).orElse(null);
                 String first = patterns[0];
                 FilterRoute filterRoute = addFilter(first, () -> beanContext.getBean((Class<HttpFilter>) beanDefinition.getBeanType()));
                 if (patterns.length > 1) {