Hi Andy,
I think I understand where the TypeKind SIMPLE shows up. In the following code:
} else if (aType instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) aType;
ResolvedType baseType = fromType(pt.getRawType());
pt is correctly a ParameterizedTypeImpl whose .toString() shows the correct type package.Type<ParameterType> . The pt.getRawType() returns a Class whose .toString() yields the simple package.Type. This gets fed to:
if (aType instanceof Class) {
Class clazz = (Class) aType;
String name = clazz.getName();
/**
* getName() can return:
*
* 1. If this class object represents a reference type that is not an array type then the binary name of the class is
* returned 2. If this class object represents a primitive type or void, then the name returned is a String equal to the
* Java language keyword corresponding to the primitive type or void. 3. If this class object represents a class of
* arrays, then the internal form of the name consists of the name of the element type preceded by one or more '['
* characters representing the depth of the array nesting.
*/
if (clazz.isArray()) {
UnresolvedType ut = UnresolvedType.forSignature(name.replace('.', '/'));
return getWorld().resolve(ut);
} else {
return getWorld().resolve(name);
}
This is where things start to get interesting, resolve(<String>) is implemented as: