I'm writing a tool that uses the annotation processor to generate source code depending on the return type of methods of an annotated class. The return type is always some subtype (interface or class) of an interface `A` that defines a type variable `T`.

```java
interface A<T>{T m();};

```

I would like to find the type parameter for the method `m()` return value type variable `T`.

The return type is represented by the annotation processor as a `javax.lang.model.type.TypeMirror` instance. The simplest case is to return `A<T>` directly. 

```java
@SomeAnnotation
class SomeClass{
    A<T> x();
}

```

The processor code to find out `T` is quite simple. (I'll cast instead of using the visitor API here to keep the code simple.) 

```java
DeclaredType type = (DeclaredType) typeMirror;
TypeMirror t = type.getTypeArguments().get(0);

```

The `TypeMirror` of the return type is a `javax.lang.model.type.DeclaredType` and `T` is the first type argument. The result `t` is a `javax.lang.model.type.TypeVariable` for `T`. The same works for a concrete return type `A<B>` (`B` is some type: `interface B{}`). The result for `t` is a `DeclaredType` representing `B`. 

Things start to get complicated with other result types:

```java
interface Subtype<T> extends A<T>{}
interface Concrete extends A<B>{};
interface Multiple<B,T> extends A<T>{}
interface Bounds<T extends B> extends A<T>{}
interface Hierarchy extends Concrete{}

```

```none
Subtype<B>          -> DeclaredType B
Subtype<T>          -> TypeVariable T
Concrete            -> DeclaredType B
Multiple<B,T>       -> TypeVariable T or DeclaredType B depeding on Multiple
Multiple<B,B>       -> TypeVariable B
<T extends B> A<T>  -> TypeVariable T with super class bound B
Bound<B>            -> DeclaredType B
Bound<C>            -> DeclaredType C (subtype of B)
Hierarchy           -> TypeVariable T

```

Is there a way to find the correct type parameter for `T` without mirroring the whole java type system?