Added more sorts for bridge methods to better reflect Java 8 properti…

…es and specific bridge methods. Fixed implementation accordingly and added further tests.

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

@@ -1154,12 +1154,8 @@ public static <T extends MethodDescription> ElementMatcher.Junction<T> isTypeIni
         return new MethodSortMatcher<T>(MethodSortMatcher.Sort.TYPE_INITIALIZER);
     }
 
-    public static <T extends MethodDescription> ElementMatcher.Junction<T> isReturnTypeBridge() {
-        return new MethodSortMatcher<T>(MethodSortMatcher.Sort.RETURN_TYPE_BRIDGE);
-    }
-
-    public static <T extends MethodDescription> ElementMatcher.Junction<T> isTypeVariableBridge() {
-        return new MethodSortMatcher<T>(MethodSortMatcher.Sort.TYPE_VARIABLE_BRIDGE);
+    public static <T extends MethodDescription> ElementMatcher.Junction<T> isTypeBridge() {
+        return new MethodSortMatcher<T>(MethodSortMatcher.Sort.TYPE_BRIDGE);
     }
 
     /**

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

@@ -101,19 +101,22 @@ protected boolean isSort(MethodDescription target) {
         VISIBILITY_BRIDGE("isVisibilityBridge()") {
             @Override
             protected boolean isSort(MethodDescription target) {
-                return target.isBridge()
-                        && !TYPE_VARIABLE_BRIDGE.isSort(target)
-                        && !RETURN_TYPE_BRIDGE.isSort(target);
+                return target.isBridge() && !TYPE_BRIDGE.isSort(target);
             }
         },
 
-        TYPE_VARIABLE_BRIDGE("isTypeVariableBridge()") {
+        TYPE_BRIDGE("isTypeBridge()") {
             @Override
             protected boolean isSort(MethodDescription target) {
-                if (target.isBridge() && !RETURN_TYPE_BRIDGE.isSort(target)) {
+                if (target.isBridge()) {
                     if (target.getDeclaringType().asRawType().isInterface()) {
                         return true;
                     }
+                    if (!target.getDeclaringType().getDeclaredMethods().filter(not(is(target))
+                            .and(hasMethodName(target.getInternalName()))
+                            .and(takesArguments(target.getParameters().asTypeList().asRawTypes()))).isEmpty()) {
+                        return true;
+                    }
                     GenericTypeDescription currentType = target.getDeclaringType().getSuperType();
                     while (currentType != null) {
                         for (MethodDescription methodDescription : currentType.getDeclaredMethods()) {
@@ -128,16 +131,6 @@ protected boolean isSort(MethodDescription target) {
             }
         },
 
-        RETURN_TYPE_BRIDGE("isReturnTypeBridge()") {
-            @Override
-            protected boolean isSort(MethodDescription target) {
-                return target.isBridge() && !target.getDeclaringType().getDeclaredMethods()
-                        .filter(not(is(target))
-                                .and(hasMethodName(target.getInternalName()))
-                                .and(takesArguments(target.getParameters().asTypeList().asRawTypes()))).isEmpty();
-            }
-        },
-
         /**
          * Matches method descriptions that represent Java 8 default methods.
          */

byte-buddy-dep/src/test/java/net/bytebuddy/matcher/ElementMatchersTest.java

@@ -8,6 +8,8 @@
 import net.bytebuddy.description.method.ParameterDescription;
 import net.bytebuddy.description.type.TypeDescription;
 import net.bytebuddy.description.type.generic.GenericTypeDescription;
+import net.bytebuddy.test.precompiled.ReturnTypeInterfaceBridge;
+import net.bytebuddy.test.precompiled.TypeVariableInterfaceBridge;
 import net.bytebuddy.test.utility.JavaVersionRule;
 import net.bytebuddy.test.utility.PrecompiledTypeClassLoader;
 import org.junit.Before;
@@ -30,6 +32,7 @@
 import java.sql.SQLException;
 import java.util.Collections;
 
+import static net.bytebuddy.matcher.ElementMatchers.named;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.fail;
@@ -43,6 +46,10 @@ public class ElementMatchersTest {
 
     private static final String PARAMETER_NAMES = "net.bytebuddy.test.precompiled.ParameterNames";
 
+    private static final String RETURN_TYPE_INTERFACE_BRIDGE = "net.bytebuddy.test.precompiled.ReturnTypeInterfaceBridge";
+
+    private static final String TYPE_VARIABLE_INTERFACE_BRIDGE = "net.bytebuddy.test.precompiled.TypeVariableInterfaceBridge";
+
     @Rule
     public MethodRule javaVersionRule = new JavaVersionRule();
 
@@ -259,17 +266,17 @@ public void testRawTypes() throws Exception {
     public void testMethodName() throws Exception {
         assertThat(ElementMatchers.hasMethodName(MethodDescription.TYPE_INITIALIZER_INTERNAL_NAME), is(ElementMatchers.isTypeInitializer()));
         assertThat(ElementMatchers.hasMethodName(MethodDescription.CONSTRUCTOR_INTERNAL_NAME), is(ElementMatchers.isConstructor()));
-        ElementMatcher<MethodDescription> nameMatcher = ElementMatchers.named(FOO);
+        ElementMatcher<MethodDescription> nameMatcher = named(FOO);
         assertThat(ElementMatchers.hasMethodName(FOO), is(nameMatcher));
     }
 
     @Test
     public void testNamed() throws Exception {
         ByteCodeElement byteCodeElement = mock(ByteCodeElement.class);
         when(byteCodeElement.getSourceCodeName()).thenReturn(FOO);
-        assertThat(ElementMatchers.named(FOO).matches(byteCodeElement), is(true));
-        assertThat(ElementMatchers.named(FOO.toUpperCase()).matches(byteCodeElement), is(false));
-        assertThat(ElementMatchers.named(BAR).matches(byteCodeElement), is(false));
+        assertThat(named(FOO).matches(byteCodeElement), is(true));
+        assertThat(named(FOO.toUpperCase()).matches(byteCodeElement), is(false));
+        assertThat(named(BAR).matches(byteCodeElement), is(false));
     }
 
     @Test
@@ -562,8 +569,8 @@ public void testTakesArgumentsLength() throws Exception {
     public void testHasParameter() throws Exception {
         MethodDescription methodDescription = new MethodDescription.ForLoadedMethod(classLoader.loadClass(PARAMETER_NAMES)
                 .getDeclaredMethod(FOO, String.class, long.class, int.class));
-        assertThat(ElementMatchers.hasParameter(ElementMatchers.named(FOO)).matches(methodDescription), is(false));
-        assertThat(ElementMatchers.hasParameter(ElementMatchers.named("first")).matches(methodDescription), is(true));
+        assertThat(ElementMatchers.hasParameter(named(FOO)).matches(methodDescription), is(false));
+        assertThat(ElementMatchers.hasParameter(named("first")).matches(methodDescription), is(true));
     }
 
     @Test
@@ -660,28 +667,18 @@ public void testSortIsTypeInitializer() throws Exception {
     }
 
     @Test
-    public void testSortIsTypeVariableBridge() throws Exception {
-        assertThat(ElementMatchers.isTypeVariableBridge()
+    public void testSortIsTypeBridge() throws Exception {
+        assertThat(ElementMatchers.isTypeBridge()
                 .matches(new MethodDescription.ForLoadedMethod(IsVisibilityBridge.class.getDeclaredMethod(FOO))), is(false));
-        assertThat(ElementMatchers.isTypeVariableBridge()
+        assertThat(ElementMatchers.isTypeBridge()
                 .matches(new MethodDescription.ForLoadedMethod(IsTypeVariableBridge.class.getDeclaredMethod(FOO, Object.class))), is(true));
-        assertThat(ElementMatchers.isTypeVariableBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
-                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
-        assertThat(ElementMatchers.isTypeVariableBridge()
-                .matches(new MethodDescription.ForLoadedMethod(Object.class.getDeclaredMethod("toString"))), is(false));
-    }
-
-    @Test
-    public void testSortIsReturnTypeBridge() throws Exception {
-        assertThat(ElementMatchers.isReturnTypeBridge()
-                .matches(new MethodDescription.ForLoadedMethod(IsVisibilityBridge.class.getDeclaredMethod(FOO))), is(false));
-        assertThat(ElementMatchers.isReturnTypeBridge()
-                .matches(new MethodDescription.ForLoadedMethod(IsTypeVariableBridge.class.getDeclaredMethod(FOO, Object.class))), is(false));
-        assertThat(ElementMatchers.isReturnTypeBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
-                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
-        assertThat(ElementMatchers.isReturnTypeBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
-                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(String.class))).getOnly()), is(false));
-        assertThat(ElementMatchers.isReturnTypeBridge()
+        assertThat(ElementMatchers.isTypeBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
+        assertThat(ElementMatchers.isTypeBridge().matches(new TypeDescription.ForLoadedType(IsTypeVariableReturnTypeBridge.class)
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
+        assertThat(ElementMatchers.isTypeBridge().matches(new TypeDescription.ForLoadedType(IsTypeVariableReturnTypeOverrideBridge.class)
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
+        assertThat(ElementMatchers.isTypeBridge()
                 .matches(new MethodDescription.ForLoadedMethod(Object.class.getDeclaredMethod("toString"))), is(false));
     }
 
@@ -692,19 +689,36 @@ public void testSortIsVisibilityBridge() throws Exception {
         assertThat(ElementMatchers.isVisibilityBridge()
                 .matches(new MethodDescription.ForLoadedMethod(IsTypeVariableBridge.class.getDeclaredMethod(FOO, Object.class))), is(false));
         assertThat(ElementMatchers.isVisibilityBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
-                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
+        assertThat(ElementMatchers.isVisibilityBridge().matches(new TypeDescription.ForLoadedType(IsTypeVariableReturnTypeBridge.class)
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
+        assertThat(ElementMatchers.isVisibilityBridge().matches(new TypeDescription.ForLoadedType(IsTypeVariableReturnTypeOverrideBridge.class)
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
         assertThat(ElementMatchers.isVisibilityBridge()
                 .matches(new MethodDescription.ForLoadedMethod(Object.class.getDeclaredMethod("toString"))), is(false));
     }
 
+    @Test
+    @JavaVersionRule.Enforce(8)
+    public void testSortInterfaceBridgeType() throws Exception {
+        assertThat(ElementMatchers.isTypeBridge().matches(new TypeDescription.ForLoadedType(classLoader.loadClass(RETURN_TYPE_INTERFACE_BRIDGE))
+                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
+        assertThat(ElementMatchers.isTypeBridge().matches(new MethodDescription.ForLoadedMethod(classLoader.loadClass(TYPE_VARIABLE_INTERFACE_BRIDGE)
+                .getDeclaredMethod(FOO, Object.class))), is(true));
+        assertThat(ElementMatchers.isVisibilityBridge().matches(new TypeDescription.ForLoadedType(classLoader.loadClass(RETURN_TYPE_INTERFACE_BRIDGE))
+                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(false));
+        assertThat(ElementMatchers.isVisibilityBridge().matches(new MethodDescription.ForLoadedMethod(classLoader.loadClass(TYPE_VARIABLE_INTERFACE_BRIDGE)
+                .getDeclaredMethod(FOO, Object.class))), is(false));
+    }
+
     @Test
     public void testSortIsBridge() throws Exception {
         assertThat(ElementMatchers.isBridge()
                 .matches(new MethodDescription.ForLoadedMethod(IsVisibilityBridge.class.getDeclaredMethod(FOO))), is(true));
         assertThat(ElementMatchers.isBridge()
                 .matches(new MethodDescription.ForLoadedMethod(IsTypeVariableBridge.class.getDeclaredMethod(FOO, Object.class))), is(true));
         assertThat(ElementMatchers.isBridge().matches(new TypeDescription.ForLoadedType(IsReturnTypeBridge.class)
-                .getDeclaredMethods().filter(ElementMatchers.named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
+                .getDeclaredMethods().filter(named(FOO).and(ElementMatchers.returns(Object.class))).getOnly()), is(true));
         assertThat(ElementMatchers.isBridge()
                 .matches(new MethodDescription.ForLoadedMethod(Object.class.getDeclaredMethod("toString"))), is(false));
     }
@@ -1046,6 +1060,36 @@ public String foo() {
         }
     }
 
+    public static class TypeVariableReturnTypeBridgeBase<T> {
+
+        public T foo() {
+            return null;
+        }
+    }
+
+    public static class IsTypeVariableReturnTypeBridge extends TypeVariableReturnTypeBridgeBase<String> {
+
+        @Override
+        public String foo() {
+            return null;
+        }
+    }
+
+    public static class TypeVariableReturnTypeOverrideBridgeBase<T, S extends T> {
+
+        public T foo() {
+            return null;
+        }
+    }
+
+    public static class IsTypeVariableReturnTypeOverrideBridge<S extends Number> extends TypeVariableReturnTypeOverrideBridgeBase<Number, S> {
+
+        @Override
+        public S foo() {
+            return null;
+        }
+    }
+
     private static class ObjectMethods {
 
         @Override

byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/ReturnTypeInterfaceBridge.java

@@ -0,0 +1,11 @@
+package net.bytebuddy.test.precompiled;
+
+public interface ReturnTypeInterfaceBridge extends ReturnTypeInterfaceBridgeBase {
+
+    String BAR = "bar";
+
+    @Override
+    default String foo() {
+        return BAR;
+    }
+}

byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/ReturnTypeInterfaceBridgeBase.java

@@ -0,0 +1,10 @@
+package net.bytebuddy.test.precompiled;
+
+public interface ReturnTypeInterfaceBridgeBase {
+
+    String FOO = "foo";
+
+    default Object foo() {
+        return FOO;
+    }
+}

byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/TypeVariableInterfaceBridge.java

@@ -0,0 +1,11 @@
+package net.bytebuddy.test.precompiled;
+
+public interface TypeVariableInterfaceBridge extends TypeVariableInterfaceBridgeBase<String> {
+
+    String FOO = "foo";
+
+    @Override
+    default String foo(String s) {
+        return FOO;
+    }
+}

byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/TypeVariableInterfaceBridgeBase.java

@@ -0,0 +1,8 @@
+package net.bytebuddy.test.precompiled;
+
+public interface TypeVariableInterfaceBridgeBase<T> {
+
+    default T foo(T t) {
+        return t;
+    }
+}