boolean matchMethod(MethodPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) {
if (!pattern.findDeclarations) return false; // only relevant when finding declarations
if (!(binaryInfo instanceof IBinaryMethod)) return false;
IBinaryMethod method = (IBinaryMethod) binaryInfo;
if (!pattern.matchesName(pattern.selector, method.getSelector())) return false;
if (!checkDeclaringType(
enclosingBinaryType,
pattern.declaringSimpleName,
pattern.declaringQualification,
pattern.isCaseSensitive(),
pattern.isCamelCase())) return false;
// look at return type only if declaring type is not specified
boolean checkReturnType =
pattern.declaringSimpleName == null
&& (pattern.returnSimpleName != null || pattern.returnQualification != null);
boolean checkParameters = pattern.parameterSimpleNames != null;
if (checkReturnType || checkParameters) {
char[] methodDescriptor = convertClassFileFormat(method.getMethodDescriptor());
if (checkReturnType) {
char[] returnTypeSignature =
Signature.toCharArray(Signature.getReturnType(methodDescriptor));
if (!checkTypeName(
pattern.returnSimpleName,
pattern.returnQualification,
returnTypeSignature,
pattern.isCaseSensitive(),
pattern.isCamelCase())) return false;
}
if (checkParameters
&& !checkParameters(
methodDescriptor,
pattern.parameterSimpleNames,
pattern.parameterQualifications,
pattern.isCaseSensitive(),
pattern.isCamelCase())) return false;
}
return true;
}
boolean matchConstructor(
ConstructorPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) {
if (!pattern.findDeclarations) return false; // only relevant when finding declarations
if (!(binaryInfo instanceof IBinaryMethod)) return false;
IBinaryMethod method = (IBinaryMethod) binaryInfo;
if (!method.isConstructor()) return false;
if (!checkDeclaringType(
enclosingBinaryType,
pattern.declaringSimpleName,
pattern.declaringQualification,
pattern.isCaseSensitive(),
pattern.isCamelCase())) return false;
if (pattern.parameterSimpleNames != null) {
char[] methodDescriptor = convertClassFileFormat(method.getMethodDescriptor());
if (!checkParameters(
methodDescriptor,
pattern.parameterSimpleNames,
pattern.parameterQualifications,
pattern.isCaseSensitive(),
pattern.isCamelCase())) return false;
}
return true;
}
/** Locate declaration in the current class file. This class file is always in a jar. */
public void locateMatches(MatchLocator locator, ClassFile classFile, IBinaryType info)
throws CoreException {
SearchPattern pattern = locator.pattern;
// check annotations references
matchAnnotations(pattern, locator, classFile, info);
// check class definition
BinaryType binaryType = (BinaryType) classFile.getType();
if (matchBinary(pattern, info, null)) {
binaryType =
new ResolvedBinaryType(
(JavaElement) binaryType.getParent(),
binaryType.getElementName(),
binaryType.getKey());
locator.reportBinaryMemberDeclaration(null, binaryType, null, info, SearchMatch.A_ACCURATE);
return;
}
// Define arrays to store methods/fields from binary type if necessary
IBinaryMethod[] binaryMethods = info.getMethods();
int bMethodsLength = binaryMethods == null ? 0 : binaryMethods.length;
IBinaryMethod[] unresolvedMethods = null;
char[][] binaryMethodSignatures = null;
boolean hasUnresolvedMethods = false;
// Get fields from binary type info
IBinaryField[] binaryFields = info.getFields();
int bFieldsLength = binaryFields == null ? 0 : binaryFields.length;
IBinaryField[] unresolvedFields = null;
boolean hasUnresolvedFields = false;
// Report as many accurate matches as possible
int accuracy = SearchMatch.A_ACCURATE;
boolean mustResolve = pattern.mustResolve;
if (mustResolve) {
BinaryTypeBinding binding = locator.cacheBinaryType(binaryType, info);
if (binding != null) {
// filter out element not in hierarchy scope
if (!locator.typeInHierarchy(binding)) return;
// Search matches on resolved methods
MethodBinding[] availableMethods = binding.availableMethods();
int aMethodsLength = availableMethods == null ? 0 : availableMethods.length;
hasUnresolvedMethods = bMethodsLength != aMethodsLength;
for (int i = 0; i < aMethodsLength; i++) {
MethodBinding method = availableMethods[i];
char[] methodSignature = method.genericSignature();
if (methodSignature == null) methodSignature = method.signature();
// Report the match if possible
int level = locator.patternLocator.resolveLevel(method);
if (level != PatternLocator.IMPOSSIBLE_MATCH) {
IMethod methodHandle =
binaryType.getMethod(
new String(
method.isConstructor()
? binding.compoundName[binding.compoundName.length - 1]
: method.selector),
CharOperation.toStrings(
Signature.getParameterTypes(convertClassFileFormat(methodSignature))));
accuracy =
level == PatternLocator.ACCURATE_MATCH
? SearchMatch.A_ACCURATE
: SearchMatch.A_INACCURATE;
locator.reportBinaryMemberDeclaration(null, methodHandle, method, info, accuracy);
}
// Remove method from unresolved list
if (hasUnresolvedMethods) {
if (binaryMethodSignatures
== null) { // Store binary method signatures to avoid multiple computation
binaryMethodSignatures = new char[bMethodsLength][];
for (int j = 0; j < bMethodsLength; j++) {
IBinaryMethod binaryMethod = binaryMethods[j];
char[] signature = binaryMethod.getGenericSignature();
if (signature == null) signature = binaryMethod.getMethodDescriptor();
binaryMethodSignatures[j] = signature;
}
}
for (int j = 0; j < bMethodsLength; j++) {
if (CharOperation.equals(binaryMethods[j].getSelector(), method.selector)
&& CharOperation.equals(binaryMethodSignatures[j], methodSignature)) {
if (unresolvedMethods == null) {
System.arraycopy(
binaryMethods,
0,
unresolvedMethods = new IBinaryMethod[bMethodsLength],
0,
bMethodsLength);
}
unresolvedMethods[j] = null;
break;
}
}
}
}
// Search matches on resolved fields
FieldBinding[] availableFields = binding.availableFields();
int aFieldsLength = availableFields == null ? 0 : availableFields.length;
hasUnresolvedFields = bFieldsLength != aFieldsLength;
for (int i = 0; i < aFieldsLength; i++) {
FieldBinding field = availableFields[i];
// Report the match if possible
int level = locator.patternLocator.resolveLevel(field);
if (level != PatternLocator.IMPOSSIBLE_MATCH) {
IField fieldHandle = binaryType.getField(new String(field.name));
accuracy =
level == PatternLocator.ACCURATE_MATCH
? SearchMatch.A_ACCURATE
: SearchMatch.A_INACCURATE;
locator.reportBinaryMemberDeclaration(null, fieldHandle, field, info, accuracy);
}
// Remove the field from unresolved list
if (hasUnresolvedFields) {
for (int j = 0; j < bFieldsLength; j++) {
if (CharOperation.equals(binaryFields[j].getName(), field.name)) {
if (unresolvedFields == null) {
System.arraycopy(
binaryFields,
0,
unresolvedFields = new IBinaryField[bFieldsLength],
0,
bFieldsLength);
}
unresolvedFields[j] = null;
break;
}
}
}
}
// If all methods/fields were accurate then returns now
if (!hasUnresolvedMethods && !hasUnresolvedFields) {
return;
}
}
accuracy = SearchMatch.A_INACCURATE;
}
// Report inaccurate methods
if (mustResolve) binaryMethods = unresolvedMethods;
bMethodsLength = binaryMethods == null ? 0 : binaryMethods.length;
for (int i = 0; i < bMethodsLength; i++) {
IBinaryMethod method = binaryMethods[i];
if (method == null) continue; // impossible match or already reported as accurate
if (matchBinary(pattern, method, info)) {
char[] name;
if (method.isConstructor()) {
name = info.getName();
int lastSlash = CharOperation.lastIndexOf('/', name);
if (lastSlash != -1) {
name = CharOperation.subarray(name, lastSlash + 1, name.length);
}
} else {
name = method.getSelector();
}
String selector = new String(name);
char[] methodSignature = binaryMethodSignatures == null ? null : binaryMethodSignatures[i];
if (methodSignature == null) {
methodSignature = method.getGenericSignature();
if (methodSignature == null) methodSignature = method.getMethodDescriptor();
}
String[] parameterTypes =
CharOperation.toStrings(
Signature.getParameterTypes(convertClassFileFormat(methodSignature)));
IMethod methodHandle = binaryType.getMethod(selector, parameterTypes);
methodHandle =
new ResolvedBinaryMethod(binaryType, selector, parameterTypes, methodHandle.getKey());
locator.reportBinaryMemberDeclaration(null, methodHandle, null, info, accuracy);
}
}
// Report inaccurate fields
if (mustResolve) binaryFields = unresolvedFields;
bFieldsLength = binaryFields == null ? 0 : binaryFields.length;
for (int i = 0; i < bFieldsLength; i++) {
IBinaryField field = binaryFields[i];
if (field == null) continue; // impossible match or already reported as accurate
if (matchBinary(pattern, field, info)) {
String fieldName = new String(field.getName());
IField fieldHandle = binaryType.getField(fieldName);
fieldHandle = new ResolvedBinaryField(binaryType, fieldName, fieldHandle.getKey());
locator.reportBinaryMemberDeclaration(null, fieldHandle, null, info, accuracy);
}
}
}