Java's compiler not retaining generic method annotations?

Question

I am currently encountering an issue with Java's generic type erasure and runtime annotations and I am not sure whether I am doing something wrong or it is a bug in the Java compiler. Consider the following minimal working example:

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface MyAnnotation {
}

public interface MyGenericInterface<T> {
    void hello(T there);
}

public class MyObject {
}

public class MyClass implements MyGenericInterface<MyObject> {
    @Override
    @MyAnnotation
    public void hello(final MyObject there) {
    }
}

Now when I query information about MyClass.hello with reflection I would expect that the hello method still has the annotation, however it does not:

public class MyTest {

    @Test
    public void testName() throws Exception {
        Method[] declaredMethods = MyClass.class.getDeclaredMethods();
        for (Method method : declaredMethods) {
            Assert.assertNotNull(String.format("Method '%s' is not annotated.", method), method
                    .getAnnotation(MyAnnotation.class));
        }
    }

}

The (unexpected) error message reads as follows:

java.lang.AssertionError: Method 'public void test.MyClass.hello(java.lang.Object)' is not annotated.

Tested with Java 1.7.60.

Answer 1

As has been pointed out by others, compilation generates two methods with the same name, a hello(Object) and a hello(MyObject).

The reason for this is type erasure:

MyGenericInterface mgi = new MyClass();
c.hello( "hahaha" );

The above should compile because the erasure of void hello(T) is void hello(Object). Of course it should also fail at runtime because there is no implementation that would accept an arbitrary Object.

From the above we can conclude that void hello(MyObject) is not in fact a valid override for that method. But generics would be really useless if you couldn't "override" a method with a type parameter.

The way the compiler gets around it is to generate a synthetic method with the signature void hello(Object), which checks the input parameter type at runtime and delegates to void hello(MyObject), if the check is successful. As you can see in the byte code in John Farrelly's answer.

So your class really looks something like this (observe how your annotation stays on the original method):

public class MyClass implements MyGenericInterface<MyObject> {
     @MyAnnotation
     public void hello(final MyObject there) {
     }

     @Override
     public void hello(Object ob) {
         hello((MyObject)ob);
     }
}

Luckily, because it's a synthetic method, you can filter out void hello(Object) by checking the value of method.isSynthetic(), if it's true you should just ignore it for the purposes of annotation processing.

@Test
public void testName() throws Exception {
    Method[] declaredMethods = MyClass.class.getDeclaredMethods();
    for (Method method : declaredMethods) {
        if (!method.isSynthetic()) {
             Assert.assertNotNull(String.format("Method '%s' is not annotated.", method), method
                .getAnnotation(MyAnnotation.class));
        }
    }
}

This should work fine.

Update: According to this RFE, annotations should now be copied across to bridge methods as well.

Answer 2

It seems that internally, javac has created 2 methods:

$ javap -c MyClass.class 
Compiled from "MyTest.java"
class MyClass implements MyGenericInterface<MyObject> {
  MyClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."    <init>":()V
       4: return

  public void hello(MyObject);
    Code:
       0: return

  public void hello(java.lang.Object);
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #2                  // class MyObject
       5: invokevirtual #3                  // Method hello:(LMyObject;)V
       8: return
}

The hello(java.lang.Object) method checks the type of the object, and then invokes the MyObject method, which has the annotation on it.

---

Update

I see that these additional "bridge methods" are specifically called out as part of type erasure and generics:

https://docs.oracle.com/javase/tutorial/java/generics/bridgeMethods.html

Also, the annotations missing on these bridged methods is a bug which is fixed in Java 8 u94

Answer 3

The method appears twice. One is annotated and the other one not. I guess that is your case too but the assertion error happens on the bad one and you can't get to see the good.

Method[] declaredMethods = MyClass.class.getDeclaredMethods();
for (Method method : declaredMethods) {
    System.out.println(String.format("Method: %s", method));
    for (Annotation a: method.getAnnotations()) {
        System.out.println(String.format("  Annotation: %s  of class %s", a, a.annotationType()));
    }
    for (Annotation a: method.getDeclaredAnnotations()) {
        System.out.println(String.format("  DeclaredAnnotation: %s  of class %s", a, a.annotationType()));
    }
    if (method.getDeclaredAnnotation(MyAnnotation.class) == null) {
        System.out.println(String.format(
                "  Method '%s' is not annotated.", method));
    }
}

Output is:

Method: public void MyClass.hello(MyObject)
  Annotation: @MyAnnotation()  of class interface MyAnnotation
  DeclaredAnnotation: @MyAnnotation()  of class interface MyAnnotation
Method: public void MyClass.hello(java.lang.Object)
  Method 'public void MyClass.hello(java.lang.Object)' is not annotated.

EDIT: As I supossed and others confirmed, he method gets duplicated by the compiler. It is needed by java. I got to decompile it the right way:

//# java -jar ........\cfr_0_101.jar MyClass --hidebridgemethods false
/*
 * Decompiled with CFR 0_101.
 */
import MyAnnotation;
import MyGenericInterface;
import MyObject;

public class MyClass
implements MyGenericInterface<MyObject> {
    @MyAnnotation
    @Override
    public void hello(MyObject there) {
    }

    @Override
    public /* bridge */ /* synthetic */ void hello(Object object) {
        MyClass myClass;
        myClass.hello((MyObject)object);
    }
}

It is related to this question: Passing Derived Class to a method which needs to override expecting a base class

I think this is related too. The field is duplicated because the method is: Duplicated field in generated XML using JAXB