Added support for receiver type annotations.

Author: Rafael Winterhalter

byte-buddy-dep/src/main/java/net/bytebuddy/description/method/MethodDescription.java

@@ -1013,6 +1013,11 @@ class Latent extends InDefinedShape.AbstractBase {
          */
         private final Object defaultValue;
 
+        /**
+         * The receiver type of this method or {@code null} if the receiver type is defined implicitly.
+         */
+        private final TypeDescription.Generic receiverType;
+
         /**
          * Creates a new latent method description. All provided types are attached to this instance before they are returned.
          *
@@ -1028,7 +1033,8 @@ public Latent(TypeDescription declaringType, MethodDescription.Token token) {
                     token.getParameterTokens(),
                     token.getExceptionTypes(),
                     token.getAnnotations(),
-                    token.getDefaultValue());
+                    token.getDefaultValue(),
+                    token.getReceiverType());
         }
 
         /**
@@ -1043,6 +1049,7 @@ public Latent(TypeDescription declaringType, MethodDescription.Token token) {
          * @param exceptionTypes      This method's exception types.
          * @param declaredAnnotations The annotations of this method.
          * @param defaultValue        The default value of this method or {@code null} if no default annotation value is defined.
+         * @param receiverType        The receiver type of this method or {@code null} if the receiver type is defined implicitly.
          */
         public Latent(TypeDescription declaringType,
                       String internalName,
@@ -1052,7 +1059,8 @@ public Latent(TypeDescription declaringType,
                       List<? extends ParameterDescription.Token> parameterTokens,
                       List<? extends TypeDescription.Generic> exceptionTypes,
                       List<? extends AnnotationDescription> declaredAnnotations,
-                      Object defaultValue) {
+                      Object defaultValue,
+                      TypeDescription.Generic receiverType) {
             this.declaringType = declaringType;
             this.internalName = internalName;
             this.modifiers = modifiers;
@@ -1062,6 +1070,7 @@ public Latent(TypeDescription declaringType,
             this.exceptionTypes = exceptionTypes;
             this.declaredAnnotations = declaredAnnotations;
             this.defaultValue = defaultValue;
+            this.receiverType = receiverType;
         }
 
         @Override
@@ -1109,6 +1118,13 @@ public Object getDefaultValue() {
             return defaultValue;
         }
 
+        @Override
+        public TypeDescription.Generic getReceiverType() {
+            return receiverType == null
+                    ? super.getReceiverType()
+                    : receiverType.accept(TypeDescription.Generic.Visitor.Substitutor.ForAttachment.of(this));
+        }
+
         /**
          * A method description that represents the type initializer.
          */

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

@@ -2539,7 +2539,7 @@ interface Dispatcher {
                  * @param type The type to represent.
                  * @return A suitable annotation reader.
                  */
-                AnnotationReader resolveSuperClass(Class<?> type);
+                AnnotationReader resolveSuperClassType(Class<?> type);
 
                 /**
                  * Resolves a loaded type's interface type's type annotations.
@@ -2548,15 +2548,15 @@ interface Dispatcher {
                  * @param index The index of the interface.
                  * @return A suitable annotation reader.
                  */
-                AnnotationReader resolveInterface(Class<?> type, int index);
+                AnnotationReader resolveInterfaceType(Class<?> type, int index);
 
                 /**
                  * Resolves a loaded field's type's type annotations.
                  *
                  * @param field The field to represent.
                  * @return A suitable annotation reader.
                  */
-                AnnotationReader resolve(Field field);
+                AnnotationReader resolveFieldType(Field field);
 
                 /**
                  * Resolves a loaded method's return type's type annotations.
@@ -2593,6 +2593,14 @@ interface Dispatcher {
                  */
                 Generic resolveReceiverType(AccessibleObject executable);
 
+                /**
+                 * Resolves the annotated type as generic type description.
+                 *
+                 * @param annotatedType The loaded annotated type.
+                 * @return A description of the supplied annotated type.
+                 */
+                Generic resolve(AnnotatedElement annotatedType);
+
                 /**
                  * A dispatcher for {@link AnnotationReader}s on a legacy VM that does not support type annotations.
                  */
@@ -2609,17 +2617,17 @@ public AnnotationReader resolveTypeVariable(TypeVariable<?> typeVariable) {
                     }
 
                     @Override
-                    public AnnotationReader resolveSuperClass(Class<?> type) {
+                    public AnnotationReader resolveSuperClassType(Class<?> type) {
                         return NoOp.INSTANCE;
                     }
 
                     @Override
-                    public AnnotationReader resolveInterface(Class<?> type, int index) {
+                    public AnnotationReader resolveInterfaceType(Class<?> type, int index) {
                         return NoOp.INSTANCE;
                     }
 
                     @Override
-                    public AnnotationReader resolve(Field field) {
+                    public AnnotationReader resolveFieldType(Field field) {
                         return NoOp.INSTANCE;
                     }
 
@@ -2643,6 +2651,11 @@ public Generic resolveReceiverType(AccessibleObject executable) {
                         return UNDEFINED;
                     }
 
+                    @Override
+                    public Generic resolve(AnnotatedElement annotatedType) {
+                        throw new IllegalStateException("Loaded annotated type cannot be represented on this VM");
+                    }
+
                     @Override
                     public String toString() {
                         return "TypeDescription.Generic.AnnotationReader.Dispatcher.ForLegacyVm." + name();
@@ -2753,17 +2766,17 @@ public AnnotationReader resolveTypeVariable(TypeVariable<?> typeVariable) {
                     }
 
                     @Override
-                    public AnnotationReader resolveSuperClass(Class<?> type) {
+                    public AnnotationReader resolveSuperClassType(Class<?> type) {
                         return new AnnotatedSuperClass(type);
                     }
 
                     @Override
-                    public AnnotationReader resolveInterface(Class<?> type, int index) {
+                    public AnnotationReader resolveInterfaceType(Class<?> type, int index) {
                         return new AnnotatedInterfaceType(type, index);
                     }
 
                     @Override
-                    public AnnotationReader resolve(Field field) {
+                    public AnnotationReader resolveFieldType(Field field) {
                         return new AnnotatedFieldType(field);
                     }
 
@@ -2785,14 +2798,24 @@ public AnnotationReader resolveExceptionType(AccessibleObject executable, int in
                     @Override
                     public Generic resolveReceiverType(AccessibleObject executable) {
                         try {
-                            AnnotatedElement annotatedReceiver = (AnnotatedElement) getAnnotatedReceiverType.invoke(executable);
-                            return annotatedReceiver == null
-                                    ? UNDEFINED
-                                    : Sort.describe((java.lang.reflect.Type) getType.invoke(annotatedReceiver), new Resolved(annotatedReceiver));
+                            return resolve((AnnotatedElement) getAnnotatedReceiverType.invoke(executable));
+                        } catch (IllegalAccessException exception) {
+                            throw new IllegalStateException("Cannot access java.lang.reflect.Executable#getAnnotatedReceiverType", exception);
                         } catch (InvocationTargetException exception) {
-                            throw new IllegalStateException("Could not access receiver type", exception);
+                            throw new IllegalStateException("Error invoking java.lang.reflect.Executable#getAnnotatedReceiverType", exception.getCause());
+                        }
+                    }
+
+                    @Override
+                    public Generic resolve(AnnotatedElement annotatedType) {
+                        try {
+                            return annotatedType == null
+                                    ? UNDEFINED
+                                    : Sort.describe((java.lang.reflect.Type) getType.invoke(annotatedType), new Resolved(annotatedType));
                         } catch (IllegalAccessException exception) {
-                            throw new IllegalStateException("Error when accessing receiver type", exception.getCause());
+                            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedType#getType", exception);
+                        } catch (InvocationTargetException exception) {
+                            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedType#getType", exception.getCause());
                         }
                     }
 
@@ -5857,7 +5880,7 @@ public TypeDescription asErasure() {
 
                 @Override
                 protected AnnotationReader getAnnotationReader() {
-                    return AnnotationReader.DISPATCHER.resolveSuperClass(type);
+                    return AnnotationReader.DISPATCHER.resolveSuperClassType(type);
                 }
             }
 
@@ -5892,7 +5915,7 @@ public TypeDescription asErasure() {
 
                 @Override
                 protected AnnotationReader getAnnotationReader() {
-                    return AnnotationReader.DISPATCHER.resolve(field);
+                    return AnnotationReader.DISPATCHER.resolveFieldType(field);
                 }
             }
 

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

@@ -704,7 +704,7 @@ public TypeDescription asErasure() {
 
                 @Override
                 protected AnnotationReader getAnnotationReader() {
-                    return AnnotationReader.DISPATCHER.resolveInterface(type, index);
+                    return AnnotationReader.DISPATCHER.resolveInterfaceType(type, index);
                 }
             }
         }