Attachment #191377 for bug #339891

View | Details | Raw Unified | Return to bug 339891
Collapse All | Expand All




	return this.pattern.fineGrain;
}

private MethodBinding getMethodBinding(ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes) {
	MethodBinding[] methods = type.getMethods(methodName);
	MethodBinding method = null;
	methodsLoop: for (int i=0, length=methods.length; i<length; i++) {
		method = methods[i];

		subType = CharOperation.compareWith(this.pattern.declaringQualification, method.declaringClass.fPackage.shortReadableName()) == 0;
	}
	int declaringLevel = subType
		? resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass, method.selector, null)
		: resolveLevelForType(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass);
	return (methodLevel & MATCH_LEVEL_MASK) > (declaringLevel & MATCH_LEVEL_MASK) ? declaringLevel : methodLevel; // return the weaker match
}

	int declaringLevel;
	if (isVirtualInvoke(method, messageSend) && (messageSend.actualReceiverType instanceof ReferenceBinding)) {
		ReferenceBinding methodReceiverType = (ReferenceBinding) messageSend.actualReceiverType;
		declaringLevel = resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, methodReceiverType, method.selector, method.parameters);
		if (declaringLevel == IMPOSSIBLE_MATCH) {
			if (method.declaringClass == null || this.allSuperDeclaringTypeNames == null) {
				declaringLevel = INACCURATE_MATCH;

 * Returns INACCURATE_MATCH if resolve fails
 * Returns IMPOSSIBLE_MATCH if it doesn't.
 */
protected int resolveLevelAsSubtype(char[] simplePattern, char[] qualifiedPattern, ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes) {
	if (type == null) return INACCURATE_MATCH;

	int level = resolveLevelForType(simplePattern, qualifiedPattern, type);
	if (level != IMPOSSIBLE_MATCH) {
		MethodBinding method = argumentTypes == null ? null : getMethodBinding(type, methodName, argumentTypes);
		if (((method != null && !method.isAbstract()) || !type.isAbstract()) && !type.isInterface()) { // if concrete, then method is overridden
			level |= OVERRIDDEN_METHOD_FLAVOR;
		}


	// matches superclass
	if (!type.isInterface() && !CharOperation.equals(type.compoundName, TypeConstants.JAVA_LANG_OBJECT)) {
		level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, type.superclass(), methodName, argumentTypes);
		if (level != IMPOSSIBLE_MATCH) {
			if (argumentTypes != null) {
				// need to verify if method may be overridden
				MethodBinding method = getMethodBinding(type, methodName, argumentTypes);
				if (method != null) { // one method match in hierarchy
					if ((level & OVERRIDDEN_METHOD_FLAVOR) != 0) {
						// this method is already overridden on a super class, current match is impossible

	ReferenceBinding[] interfaces = type.superInterfaces();
	if (interfaces == null) return INACCURATE_MATCH;
	for (int i = 0; i < interfaces.length; i++) {
		level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, interfaces[i], methodName, null);
		if (level != IMPOSSIBLE_MATCH) {
			if (!type.isAbstract() && !type.isInterface()) { // if concrete class, then method is overridden
				level |= OVERRIDDEN_METHOD_FLAVOR;




	suite.addTest(new JavaSearchBugsTests("testBug324189c"));
	suite.addTest(new JavaSearchBugsTests("testBug324189d"));
	suite.addTest(new JavaSearchBugsTests("testBug324189e"));
	suite.addTest(new JavaSearchBugsTests("testBug339891"));
	return suite;
}
class TestCollector extends JavaSearchResultCollector {

	search("A.run()", METHOD, DECLARATIONS);
	assertSearchResults("src/b324189/A.java void b324189.A.run() [run] EXACT_MATCH");
}
/**
 * @bug 339891: NPE when searching for method (with '*' wildcard character)
 * @test Search for Worker.run() should not return results like TestWorker
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=339891"
 */
public void testBug339891() throws CoreException {
	try {
		IJavaProject project = createJavaProject("P");
		createFile("/P/Ref.java",
			"public class Ref{\n"+
			" public void foo() {}\n"+
			"}\n"+
			"}\n");
		createFile("/P/Test.java",
			"public class Test{\n"+
				" public void foo(Ref ref) {" +
				"   ref.foo();\n"+
				"}\n" +
				"}\n");
		waitUntilIndexesReady();
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[]{project}, IJavaSearchScope.SOURCES);
		search("Ref.*", METHOD, REFERENCES, EXACT_RULE, scope, this.resultCollector);
		assertSearchResults("Test.java void Test.foo(Ref) [foo()] EXACT_MATCH");
	} finally {
		deleteProject("P");
	}
}

}

Return to bug 339891

Lines 699-704 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (+29 lines)
699	suite.addTest(new JavaSearchBugsTests("testBug324189c"));	699	suite.addTest(new JavaSearchBugsTests("testBug324189c"));
700	suite.addTest(new JavaSearchBugsTests("testBug324189d"));	700	suite.addTest(new JavaSearchBugsTests("testBug324189d"));
701	suite.addTest(new JavaSearchBugsTests("testBug324189e"));	701	suite.addTest(new JavaSearchBugsTests("testBug324189e"));
		702	suite.addTest(new JavaSearchBugsTests("testBug339891"));
702	return suite;	703	return suite;
703	}	704	}
704	class TestCollector extends JavaSearchResultCollector {	705	class TestCollector extends JavaSearchResultCollector {
Lines 13452-13455 Link Here
13452	search("A.run()", METHOD, DECLARATIONS);	13453	search("A.run()", METHOD, DECLARATIONS);
13453	assertSearchResults("src/b324189/A.java void b324189.A.run() [run] EXACT_MATCH");	13454	assertSearchResults("src/b324189/A.java void b324189.A.run() [run] EXACT_MATCH");
13454	}	13455	}
		13456	/**
		13457	* @bug 339891: NPE when searching for method (with '*' wildcard character)
		13458	* @test Search for Worker.run() should not return results like TestWorker
		13459	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=339891"
		13460	*/
		13461	public void testBug339891() throws CoreException {
		13462	try {
		13463	IJavaProject project = createJavaProject("P");
		13464	createFile("/P/Ref.java",
		13465	"public class Ref{\n"+
		13466	" public void foo() {}\n"+
		13467	"}\n"+
		13468	"}\n");
		13469	createFile("/P/Test.java",
		13470	"public class Test{\n"+
		13471	" public void foo(Ref ref) {" +
		13472	" ref.foo();\n"+
		13473	"}\n" +
		13474	"}\n");
		13475	waitUntilIndexesReady();
		13476	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[]{project}, IJavaSearchScope.SOURCES);
		13477	search("Ref.*", METHOD, REFERENCES, EXACT_RULE, scope, this.resultCollector);
		13478	assertSearchResults("Test.java void Test.foo(Ref) [foo()] EXACT_MATCH");
		13479	} finally {
		13480	deleteProject("P");
		13481	}
		13482	}
		13483
13455	}	13484	}

Lines 50-57 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodLocator.java (-9 / +9 lines)
50	return this.pattern.fineGrain;	50	return this.pattern.fineGrain;
51	}	51	}
52		52
53	private MethodBinding getMethodBinding(ReferenceBinding type, TypeBinding[] argumentTypes) {	53	private MethodBinding getMethodBinding(ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes) {
54	MethodBinding[] methods = type.getMethods(this.pattern.selector);	54	MethodBinding[] methods = type.getMethods(methodName);
55	MethodBinding method = null;	55	MethodBinding method = null;
56	methodsLoop: for (int i=0, length=methods.length; i<length; i++) {	56	methodsLoop: for (int i=0, length=methods.length; i<length; i++) {
57	method = methods[i];	57	method = methods[i];
Lines 613-619 Link Here
613	subType = CharOperation.compareWith(this.pattern.declaringQualification, method.declaringClass.fPackage.shortReadableName()) == 0;	613	subType = CharOperation.compareWith(this.pattern.declaringQualification, method.declaringClass.fPackage.shortReadableName()) == 0;
614	}	614	}
615	int declaringLevel = subType	615	int declaringLevel = subType
616	? resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass, null)	616	? resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass, method.selector, null)
617	: resolveLevelForType(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass);	617	: resolveLevelForType(this.pattern.declaringSimpleName, this.pattern.declaringQualification, method.declaringClass);
618	return (methodLevel & MATCH_LEVEL_MASK) > (declaringLevel & MATCH_LEVEL_MASK) ? declaringLevel : methodLevel; // return the weaker match	618	return (methodLevel & MATCH_LEVEL_MASK) > (declaringLevel & MATCH_LEVEL_MASK) ? declaringLevel : methodLevel; // return the weaker match
619	}	619	}
Lines 646-652 Link Here
646	int declaringLevel;	646	int declaringLevel;
647	if (isVirtualInvoke(method, messageSend) && (messageSend.actualReceiverType instanceof ReferenceBinding)) {	647	if (isVirtualInvoke(method, messageSend) && (messageSend.actualReceiverType instanceof ReferenceBinding)) {
648	ReferenceBinding methodReceiverType = (ReferenceBinding) messageSend.actualReceiverType;	648	ReferenceBinding methodReceiverType = (ReferenceBinding) messageSend.actualReceiverType;
649	declaringLevel = resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, methodReceiverType, method.parameters);	649	declaringLevel = resolveLevelAsSubtype(this.pattern.declaringSimpleName, this.pattern.declaringQualification, methodReceiverType, method.selector, method.parameters);
650	if (declaringLevel == IMPOSSIBLE_MATCH) {	650	if (declaringLevel == IMPOSSIBLE_MATCH) {
651	if (method.declaringClass == null \|\| this.allSuperDeclaringTypeNames == null) {	651	if (method.declaringClass == null \|\| this.allSuperDeclaringTypeNames == null) {
652	declaringLevel = INACCURATE_MATCH;	652	declaringLevel = INACCURATE_MATCH;
Lines 674-685 Link Here
674	* Returns INACCURATE_MATCH if resolve fails	674	* Returns INACCURATE_MATCH if resolve fails
675	* Returns IMPOSSIBLE_MATCH if it doesn't.	675	* Returns IMPOSSIBLE_MATCH if it doesn't.
676	*/	676	*/
677	protected int resolveLevelAsSubtype(char[] simplePattern, char[] qualifiedPattern, ReferenceBinding type, TypeBinding[] argumentTypes) {	677	protected int resolveLevelAsSubtype(char[] simplePattern, char[] qualifiedPattern, ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes) {
678	if (type == null) return INACCURATE_MATCH;	678	if (type == null) return INACCURATE_MATCH;
679		679
680	int level = resolveLevelForType(simplePattern, qualifiedPattern, type);	680	int level = resolveLevelForType(simplePattern, qualifiedPattern, type);
681	if (level != IMPOSSIBLE_MATCH) {	681	if (level != IMPOSSIBLE_MATCH) {
682	MethodBinding method = argumentTypes == null ? null : getMethodBinding(type, argumentTypes);	682	MethodBinding method = argumentTypes == null ? null : getMethodBinding(type, methodName, argumentTypes);
683	if (((method != null && !method.isAbstract()) \|\| !type.isAbstract()) && !type.isInterface()) { // if concrete, then method is overridden	683	if (((method != null && !method.isAbstract()) \|\| !type.isAbstract()) && !type.isInterface()) { // if concrete, then method is overridden
684	level \|= OVERRIDDEN_METHOD_FLAVOR;	684	level \|= OVERRIDDEN_METHOD_FLAVOR;
685	}	685	}
Lines 688-698 Link Here
688		688
689	// matches superclass	689	// matches superclass
690	if (!type.isInterface() && !CharOperation.equals(type.compoundName, TypeConstants.JAVA_LANG_OBJECT)) {	690	if (!type.isInterface() && !CharOperation.equals(type.compoundName, TypeConstants.JAVA_LANG_OBJECT)) {
691	level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, type.superclass(), argumentTypes);	691	level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, type.superclass(), methodName, argumentTypes);
692	if (level != IMPOSSIBLE_MATCH) {	692	if (level != IMPOSSIBLE_MATCH) {
693	if (argumentTypes != null) {	693	if (argumentTypes != null) {
694	// need to verify if method may be overridden	694	// need to verify if method may be overridden
695	MethodBinding method = getMethodBinding(type, argumentTypes);	695	MethodBinding method = getMethodBinding(type, methodName, argumentTypes);
696	if (method != null) { // one method match in hierarchy	696	if (method != null) { // one method match in hierarchy
697	if ((level & OVERRIDDEN_METHOD_FLAVOR) != 0) {	697	if ((level & OVERRIDDEN_METHOD_FLAVOR) != 0) {
698	// this method is already overridden on a super class, current match is impossible	698	// this method is already overridden on a super class, current match is impossible
Lines 712-718 Link Here
712	ReferenceBinding[] interfaces = type.superInterfaces();	712	ReferenceBinding[] interfaces = type.superInterfaces();
713	if (interfaces == null) return INACCURATE_MATCH;	713	if (interfaces == null) return INACCURATE_MATCH;
714	for (int i = 0; i < interfaces.length; i++) {	714	for (int i = 0; i < interfaces.length; i++) {
715	level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, interfaces[i], null);	715	level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, interfaces[i], methodName, null);
716	if (level != IMPOSSIBLE_MATCH) {	716	if (level != IMPOSSIBLE_MATCH) {
717	if (!type.isAbstract() && !type.isInterface()) { // if concrete class, then method is overridden	717	if (!type.isAbstract() && !type.isInterface()) { // if concrete class, then method is overridden
718	level \|= OVERRIDDEN_METHOD_FLAVOR;	718	level \|= OVERRIDDEN_METHOD_FLAVOR;