/**
* Returns the qualified signature corresponding to <code>signature</code>.
*
* @param signature the signature to qualify
* @param context the type inside which an unqualified type will be resolved to find the
* qualifier, or <code>null</code> if no context is available
* @return the qualified signature
*/
public static String qualifySignature(final String signature, final IType context) {
if (context == null) return signature;
String qualifier = Signature.getSignatureQualifier(signature);
if (qualifier.length() > 0) return signature;
String elementType = Signature.getElementType(signature);
String erasure = Signature.getTypeErasure(elementType);
String simpleName = Signature.getSignatureSimpleName(erasure);
String genericSimpleName = Signature.getSignatureSimpleName(elementType);
int dim = Signature.getArrayCount(signature);
try {
String[][] strings = context.resolveType(simpleName);
if (strings != null && strings.length > 0) qualifier = strings[0][0];
} catch (JavaModelException e) {
// ignore - not found
}
if (qualifier.length() == 0) return signature;
String qualifiedType = Signature.toQualifiedName(new String[] {qualifier, genericSimpleName});
String qualifiedSignature = Signature.createTypeSignature(qualifiedType, true);
String newSignature = Signature.createArraySignature(qualifiedSignature, dim);
return newSignature;
}
public ITypeModel getBodyType() {
IMethod iMethod = (IMethod) tm;
try {
String[] parameterTypes = iMethod.getParameterTypes();
for (String s : parameterTypes) {
if (s.contains("java")) // $NON-NLS-1$
{
continue;
}
String returnType = s;
if (returnType.startsWith("Q") && returnType.endsWith(";")) { // $NON-NLS-1$ //$NON-NLS-2$
IType ownerType = (IType) iMethod.getAncestor(IJavaElement.TYPE);
String[][] resolveType =
ownerType.resolveType(returnType.substring(1, returnType.length() - 1));
if (resolveType.length == 1) {
IType findType =
ownerType.getJavaProject().findType(resolveType[0][0] + '.' + resolveType[0][1]);
if (findType != null && findType instanceof SourceType) {
return new JDTType(findType);
}
}
}
}
} catch (Exception e) {
throw new IllegalStateException(e);
}
return null;
}
public IMethod findMethod(IType type, String name) throws JavaModelException {
for (IMethod m : type.getMethods()) if (m.getElementName().equals(name)) return m;
String superType = type.getSuperclassName();
if (superType != null)
for (String[] resolved : type.resolveType(superType)) {
IType type2 = TypeUtil.findType(type.getJavaProject(), resolved[0] + "." + resolved[1]);
if (type2 != null) return findMethod(type2, name);
}
return null;
}
public static String resolveClassName(String className, IType type) {
if (className == null || type == null) {
return className;
}
// replace binary $ inner class name syntax with . for source level
className = className.replace('$', '.');
String dotClassName = new StringBuilder().append('.').append(className).toString();
IProject project = type.getJavaProject().getProject();
try {
// Special handling for some well-know classes
if (className.startsWith("java.lang") && getJavaType(project, className) != null) {
return className;
}
// Check if the class is imported
if (!type.isBinary()) {
// Strip className to first segment to support ReflectionUtils.MethodCallback
int ix = className.lastIndexOf('.');
String firstClassNameSegment = className;
if (ix > 0) {
firstClassNameSegment = className.substring(0, ix);
}
// Iterate the imports
for (IImportDeclaration importDeclaration : type.getCompilationUnit().getImports()) {
String importName = importDeclaration.getElementName();
// Wildcard imports -> check if the package + className is a valid type
if (importDeclaration.isOnDemand()) {
String newClassName =
new StringBuilder(importName.substring(0, importName.length() - 1))
.append(className)
.toString();
if (getJavaType(project, newClassName) != null) {
return newClassName;
}
}
// Concrete import matching .className at the end -> check if type exists
else if (importName.endsWith(dotClassName) && getJavaType(project, importName) != null) {
return importName;
}
// Check if className is multi segmented (ReflectionUtils.MethodCallback)
// -> check if the first segment
else if (!className.equals(firstClassNameSegment)) {
if (importName.endsWith(firstClassNameSegment)) {
String newClassName =
new StringBuilder(importName.substring(0, importName.lastIndexOf('.') + 1))
.append(className)
.toString();
if (getJavaType(project, newClassName) != null) {
return newClassName;
}
}
}
}
}
// Check if the class is in the same package as the type
String packageName = type.getPackageFragment().getElementName();
String newClassName = new StringBuilder(packageName).append(dotClassName).toString();
if (getJavaType(project, newClassName) != null) {
return newClassName;
}
// Check if the className is sufficient (already fully-qualified)
if (getJavaType(project, className) != null) {
return className;
}
// Check if the class is coming from the java.lang
newClassName = new StringBuilder("java.lang").append(dotClassName).toString();
if (getJavaType(project, newClassName) != null) {
return newClassName;
}
// Fall back to full blown resolution
String[][] fullInter = type.resolveType(className);
if (fullInter != null && fullInter.length > 0) {
return fullInter[0][0] + "." + fullInter[0][1];
}
} catch (JavaModelException e) {
SpringCore.log(e);
}
return className;
}
