Minor API improvement when binding fixed values.

byte-buddy-dep/src/main/java/net/bytebuddy/asm/Advice.java

@@ -7837,6 +7837,19 @@ protected WithCustomMapping(Map<Class<? extends Annotation>, DynamicValue<?>> dy
             this.dynamicValues = dynamicValues;
         }
 
+        /**
+         * Binds the supplied annotation to the supplied fixed value.
+         *
+         * @param type  The type of the annotation being bound.
+         * @param value The type reference to bind to this annotation.
+         * @param <T>   The annotation type.
+         * @return A new builder for an advice that considers the supplied annotation type during binding.
+         * @see DynamicValue.ForFixedValue
+         */
+        public <T extends Annotation> WithCustomMapping bind(Class<? extends T> type, TypeDescription value) {
+            return bind(type, new DynamicValue.ForFixedValue(value));
+        }
+
         /**
          * Binds the supplied annotation to the supplied fixed value.
          *
@@ -7846,7 +7859,7 @@ protected WithCustomMapping(Map<Class<? extends Annotation>, DynamicValue<?>> dy
          * @return A new builder for an advice that considers the supplied annotation type during binding.
          * @see DynamicValue.ForFixedValue
          */
-        public <T extends Annotation> WithCustomMapping bind(Class<? extends T> type, Object value) {
+        public <T extends Annotation> WithCustomMapping bind(Class<? extends T> type, Serializable value) {
             return bind(type, new DynamicValue.ForFixedValue(value));
         }
 

byte-buddy-dep/src/test/java/net/bytebuddy/asm/AdviceInconsistentStackSizeTest.java

@@ -17,6 +17,7 @@
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
+import java.io.Serializable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.Arrays;
@@ -33,11 +34,11 @@ public class AdviceInconsistentStackSizeTest {
 
     private final Class<?> type;
 
-    private final Object original, replaced;
+    private final Serializable original, replaced;
 
     private final int opcode;
 
-    public AdviceInconsistentStackSizeTest(Class<?> type, Object original, Object replaced, int opcode) {
+    public AdviceInconsistentStackSizeTest(Class<?> type, Serializable original, Serializable replaced, int opcode) {
         this.type = type;
         this.original = original;
         this.replaced = replaced;
@@ -75,7 +76,7 @@ public void testInconsistentStackSize() throws Exception {
                 .make()
                 .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
                 .getLoaded();
-        assertThat(adviced.getDeclaredMethod(FOO).invoke(adviced.newInstance()), is(replaced));
+        assertThat(adviced.getDeclaredMethod(FOO).invoke(adviced.newInstance()), is((Object) replaced));
     }
 
     @Test

byte-buddy-dep/src/test/java/net/bytebuddy/asm/AdviceTest.java

@@ -14,6 +14,7 @@
 import org.objectweb.asm.MethodVisitor;
 
 import java.io.IOException;
+import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -1547,12 +1548,12 @@ public Object resolve(MethodDescription.InDefinedShape instrumentedMethod,
                                   boolean initialized) {
                 return null;
             }
-        }).bind(Custom.class, null);
+        }).bind(Custom.class, (Serializable) null);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testNotAnnotationType() throws Exception {
-        Advice.withCustomMapping().bind(Annotation.class, null);
+        Advice.withCustomMapping().bind(Annotation.class, (Serializable) null);
     }
 
     @Test(expected = IllegalStateException.class)

byte-buddy-dep/src/test/java/net/bytebuddy/asm/AdviceTypeTest.java

@@ -13,6 +13,7 @@
 import org.objectweb.asm.Type;
 
 import java.io.ObjectInputStream;
+import java.io.Serializable;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -70,9 +71,9 @@ public static Collection<Object[]> data() {
 
     private final Class<?> type;
 
-    private final Object value;
+    private final Serializable value;
 
-    public AdviceTypeTest(Class<?> advice, Class<?> type, Object value) {
+    public AdviceTypeTest(Class<?> advice, Class<?> type, Serializable value) {
         this.advice = advice;
         this.type = type;
         this.value = value;
@@ -90,7 +91,7 @@ public void testAdvice() throws Exception {
                 .make()
                 .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
                 .getLoaded();
-        assertThat(type.getDeclaredMethod(FOO, this.type, this.type).invoke(type.newInstance(), value, value), is(value));
+        assertThat(type.getDeclaredMethod(FOO, this.type, this.type).invoke(type.newInstance(), value, value), is((Object) value));
         assertThat(type.getDeclaredField(ENTER).get(null), is((Object) 1));
         assertThat(type.getDeclaredField(EXIT).get(null), is((Object) 1));
     }
@@ -109,7 +110,7 @@ public void testAdviceWithException() throws Exception {
                 .getLoaded();
         type.getDeclaredField(exception).set(null, true);
         try {
-            assertThat(type.getDeclaredMethod(BAR, this.type, this.type).invoke(type.newInstance(), value, value), is(value));
+            assertThat(type.getDeclaredMethod(BAR, this.type, this.type).invoke(type.newInstance(), value, value), is((Object) value));
             fail();
         } catch (InvocationTargetException exception) {
             assertThat(exception.getCause(), instanceOf(RuntimeException.class));