Modified generic signature that is written by method descriptions to …

…not include generic types if no exception type is generic.
raphw · Oct 14, 2015 · 04e4a52 · 04e4a52
1 parent c647b30
commit 04e4a52
Show file tree

Hide file tree

Showing 2 changed files with 30 additions and 7 deletions.
diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/description/method/MethodDescription.java b/byte-buddy-dep/src/main/java/net/bytebuddy/description/method/MethodDescription.java
@@ -28,8 +28,7 @@
 import java.util.Iterator;
 import java.util.List;
 
-import static net.bytebuddy.matcher.ElementMatchers.named;
-import static net.bytebuddy.matcher.ElementMatchers.none;
+import static net.bytebuddy.matcher.ElementMatchers.*;
 
 /**
  * Implementations of this interface describe a Java method, i.e. a method or a constructor. Implementations of this
@@ -360,9 +359,12 @@ public String getGenericSignature() {
                 GenericTypeDescription returnType = getReturnType();
                 returnType.accept(new GenericTypeDescription.Visitor.ForSignatureVisitor(signatureWriter.visitReturnType()));
                 generic = generic || !returnType.getSort().isNonGeneric();
-                for (GenericTypeDescription exceptionType : getExceptionTypes()) {
-                    exceptionType.accept(new GenericTypeDescription.Visitor.ForSignatureVisitor(signatureWriter.visitExceptionType()));
-                    generic = generic || !exceptionType.getSort().isNonGeneric();
+                GenericTypeList exceptionTypes = getExceptionTypes();
+                if (!exceptionTypes.filter(not(ofSort(GenericTypeDescription.Sort.NON_GENERIC))).isEmpty()) {
+                    for (GenericTypeDescription exceptionType : exceptionTypes) {
+                        exceptionType.accept(new GenericTypeDescription.Visitor.ForSignatureVisitor(signatureWriter.visitExceptionType()));
+                        generic = generic || !exceptionType.getSort().isNonGeneric();
+                    }
                 }
                 return generic
                         ? signatureWriter.toString()

diff --git a/.../src/test/java/net/bytebuddy/description/type/generic/GenericSignatureResolutionTest.java b/.../src/test/java/net/bytebuddy/description/type/generic/GenericSignatureResolutionTest.java
@@ -19,7 +19,7 @@
 
 public class GenericSignatureResolutionTest {
 
-    private static final String FOO = "foo";
+    private static final String FOO = "foo", BAR = "bar";
 
     @Test
     public void testGenericType() throws Exception {
@@ -49,7 +49,7 @@ public void testGenericField() throws Exception {
     public void testGenericMethod() throws Exception {
         DynamicType.Unloaded<?> unloaded = new ByteBuddy()
                 .redefine(GenericMethod.class)
-                .method(named("foo"))
+                .method(named(FOO))
                 .intercept(FixedValue.nullValue())
                 .make();
         Class<?> type = unloaded.load(null, ClassLoadingStrategy.Default.WRAPPER).getLoaded();
@@ -61,6 +61,22 @@ public void testGenericMethod() throws Exception {
         assertThat(createdMethod.getExceptionTypes().getOnly(), is(originalMethod.getExceptionTypes().getOnly()));
     }
 
+    @Test
+    public void testGenericMethodWithoutGenericExceptionTypes() throws Exception {
+        DynamicType.Unloaded<?> unloaded = new ByteBuddy()
+                .redefine(GenericMethod.class)
+                .method(named(BAR))
+                .intercept(FixedValue.nullValue())
+                .make();
+        Class<?> type = unloaded.load(null, ClassLoadingStrategy.Default.WRAPPER).getLoaded();
+        MethodDescription createdMethod = new MethodDescription.ForLoadedMethod(type.getDeclaredMethod(BAR, Object.class));
+        MethodDescription originalMethod = new MethodDescription.ForLoadedMethod(GenericMethod.class.getDeclaredMethod(BAR, Object.class));
+        assertThat(createdMethod.getTypeVariables(), is(originalMethod.getTypeVariables()));
+        assertThat(createdMethod.getReturnType(), is(originalMethod.getReturnType()));
+        assertThat(createdMethod.getParameters().getOnly().getType(), is(originalMethod.getParameters().getOnly().getType()));
+        assertThat(createdMethod.getExceptionTypes().getOnly(), is(originalMethod.getExceptionTypes().getOnly()));
+    }
+
     @Test
     public void testNoSuperType() throws Exception {
         assertThat(new ByteBuddy().redefine(Object.class).make(), notNullValue(DynamicType.class));
@@ -178,11 +194,16 @@ public static abstract class GenericType<T extends ArrayList<T> & Callable<T>,
 
     }
 
+    @SuppressWarnings("unused")
     public static class GenericMethod {
 
         <T extends Exception & Callable<T>> T foo(T arg) throws T {
             return null;
         }
+
+        <T> T bar(T arg) throws Exception {
+            return null;
+        }
     }
 
     public static class GenericField<T> {