1. we have an annotation defined in a JCP API that looks like:

  @interface javax.foo.Bar {
     Class value();
  }

2. a developer writes a source file that uses this annotation

  @javax.foo.Bar(AnotherUserClass.class)
  class AUserClass { ... }

3. our annotation processor wants to access this Bar annotation by using the getAnnotation method (which will return an instance of Bar.)

[The developer should be able to access the annotation value
 by stmt javax.foo.Bar tmpValue = b.value();
 but this method causes an com.sun.mirror.type.MirroredTypeException
 to be thrown.]

-- code analysis from Kohsuke Kawaguchi --
From what I can tell by looking at the source code of APT (which could be bit old), the getAnnotation method is really designed to work with this correctly --- see AnnotationProxyMaker.getAllReflectedValues, which calls generateValue, which in turn uses ValueVisitor, which handles the possibility of an annotation member of the Class type.

I think it would be great if Rebecca can trace through the APT source code from the invocation of the getAnnotation() to see why the code, which seems to be written correctly, isn't working.

AHHHHHHHHHHHHH!


I see what's going on here! APT creates MirroredTypeException eagerly, before the getAnnotation method returns (which is correct.) When an exception is created, JRE fills in the stack trace, which includes the getAnnotation method.

Eventually, our code accesses javax.foo.Bar.value(), where the exception is actually thrown. BUT! Since this exception is created earlier, its stack trace doesn't have this invocation in it; instead, if you just look at the stack trace, it looks as if the exception is thrown from the point where it's constructed.

So I believe the fix is in AnnotationInvocationHandler line 56, change this to:

  if (result instanceof ExceptionProxy)
    throw ((ExceptionProxy) result).generateException();

that:

  if (result instanceof ExceptionProxy)
    throw ((ExceptionProxy) result).generateException().fillInStackTrace();

(Or do it in MirroredTypeExceptionProxy.generateException)

Also, I see that you are throwing the same instance of MirroredTypeException over and over, but is this safe? wouldn't it be safer if you create a new exception instance every time?