Attachment #178046 for bug #322979




		return nodeSet.addMatch(node, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);

	char[] typeRefSimpleName = null;
	removeTypeArgumentsMatches(node, nodeSet);
	if (node instanceof SingleTypeReference) {
		typeRefSimpleName = ((SingleTypeReference) node).token;
	} else { // QualifiedTypeReference

protected int referenceType() {
	return IJavaElement.TYPE;
}
/*
 * When the type reference is a type argument it cannot be a super type
 * reference as well. Hence, this method seek through type arguments of
 * the given type reference if any to remove any corresponding matches already
 * stored in the node set...
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=322979"
 */
private void removeTypeArgumentsMatches(TypeReference typeReference, MatchingNodeSet nodeSet) {
	if (typeReference instanceof ParameterizedSingleTypeReference) {
		ParameterizedSingleTypeReference parameterizedTypeReference = (ParameterizedSingleTypeReference) typeReference;
		if (parameterizedTypeReference.typeArguments != null) {
			removeTypeArgumentsMatches(parameterizedTypeReference.typeArguments, nodeSet);
		}
	}
	if (typeReference instanceof ParameterizedQualifiedTypeReference) {
		ParameterizedQualifiedTypeReference parameterizedTypeReference = (ParameterizedQualifiedTypeReference) typeReference;
		if (parameterizedTypeReference.typeArguments != null) {
			TypeReference[][] typesArguments = parameterizedTypeReference.typeArguments;
			int length = typesArguments.length;
			for (int i=0; i<length; i++) {
				removeTypeArgumentsMatches(typesArguments[i], nodeSet);
			}
		}
	}
}
/*
 * Remove any of the given type arguments from the possible or accurate
 * matches as they cannot be super type references...
 */
private void removeTypeArgumentsMatches(TypeReference[] typeArguments, MatchingNodeSet nodeSet) {
	int l = typeArguments == null ? 0 : typeArguments.length;
	for (int a=0; a<l; a++) {
		TypeReference typeArgument = typeArguments[a];
		if (nodeSet.removePossibleMatch(typeArgument) == null) {
			nodeSet.removeTrustedMatch(typeArgument);
		}
	}
}
public int resolveLevel(ASTNode node) {
	if (!(node instanceof TypeReference)) return IMPOSSIBLE_MATCH;


Lines 42-51 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (-4 / +4 lines)
42	public static List JAVA_SEARCH_SUITES = null;	42	public static List JAVA_SEARCH_SUITES = null;
43	protected static IJavaProject JAVA_PROJECT;	43	protected static IJavaProject JAVA_PROJECT;
44	protected static boolean COPY_DIRS = true;	44	protected static boolean COPY_DIRS = true;
45	protected static int EXACT_RULE = SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE;	45	protected final static int EXACT_RULE = SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE;
46	protected static int EQUIVALENT_RULE = EXACT_RULE \| SearchPattern.R_EQUIVALENT_MATCH;	46	protected final static int EQUIVALENT_RULE = EXACT_RULE \| SearchPattern.R_EQUIVALENT_MATCH;
47	protected static int ERASURE_RULE = EXACT_RULE \| SearchPattern.R_ERASURE_MATCH;	47	protected final static int ERASURE_RULE = EXACT_RULE \| SearchPattern.R_ERASURE_MATCH;
48	protected static int RAW_RULE = EXACT_RULE \| SearchPattern.R_ERASURE_MATCH \| SearchPattern.R_EQUIVALENT_MATCH;	48	protected final static int RAW_RULE = EXACT_RULE \| SearchPattern.R_ERASURE_MATCH \| SearchPattern.R_EQUIVALENT_MATCH;
49		49
50	// ICompilationUnit[] workingCopies;	50	// ICompilationUnit[] workingCopies;
51	// boolean discard;	51	// boolean discard;




	}
}

static { TESTS_PREFIX = "testBug322979"; }
public void testBug322979a() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements Comparable<Object>{\n"+
		    "public int compareTo(Object o) {\n"+
		        "return 0;\n"+
		    "}\n"+
			"}\n");
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showAccuracy(true);
		this.resultCollector.showSelection();
		search("Object", TYPE, IMPLEMENTORS, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements Comparable<Object>{] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979b() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends java.lang.Object implements Comparable<Object>{\n"+
		    "public int compareTo(Object o) {\n"+
		        "return 0;\n"+
		    "}\n"+
			"}\n");
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		IType type = getClassFile("P", getExternalJCLPathString("1.5"), "java.lang", "Object.class").getType();
		this.resultCollector.showAccuracy(true);
		this.resultCollector.showSelection();
		search(type, IMPLEMENTORS, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|java.lang.Object|! implements Comparable<Object>{] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979c() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements I01a<Object>, I01b<String>, I01c<Object> {\n" + 
			"}\n" + 
			"interface I01a<T> {}\n" + 
			"interface I01b<T> {}\n" + 
			"interface I01c<T> {}\n"
		);
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showSelection();
		search("java.lang.Object", TYPE, IMPLEMENTORS, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements I01a<Object>, I01b<String>, I01c<Object> {] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979d() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements I01<\n" + 
			"	I02<\n" + 
			"		I03<Object,\n" + 
			"			I02<Object, I01<Object>>,\n" + 
			"			I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" + 
			"			>,\n" + 
			"		I01<Object>>> {\n" + 
			"}\n" + 
			"interface I01<T> {}\n" + 
			"interface I02<T, U> {}\n" + 
			"interface I03<T, U, V> {}\n"
		);
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showSelection();
		search("Object", TYPE, IMPLEMENTORS, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements I01<] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979e() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements I01<\n" + 
			"	I02<\n" + 
			"		I03<Object,\n" + 
			"			I02<Object, I01<Object>>,\n" + 
			"			I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" + 
			"			>,\n" + 
			"		I01<Object>>> {\n" + 
			"}\n" + 
			"interface I01<T> {}\n" + 
			"interface I02<T, U> {}\n" + 
			"interface I03<T, U, V> {}\n"
		);
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showSelection();
		search("Object", TYPE, REFERENCES, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements I01<] EXACT_MATCH\n" + 
			"Test.java Test [		I03<!|Object|!,] EXACT_MATCH\n" + 
			"Test.java Test [			I02<!|Object|!, I01<Object>>,] EXACT_MATCH\n" + 
			"Test.java Test [			I02<Object, I01<!|Object|!>>,] EXACT_MATCH\n" + 
			"Test.java Test [			I03<!|Object|!, I01<Object>, I02<Object, I01<Object>>>] EXACT_MATCH\n" + 
			"Test.java Test [			I03<Object, I01<!|Object|!>, I02<Object, I01<Object>>>] EXACT_MATCH\n" + 
			"Test.java Test [			I03<Object, I01<Object>, I02<!|Object|!, I01<Object>>>] EXACT_MATCH\n" + 
			"Test.java Test [			I03<Object, I01<Object>, I02<Object, I01<!|Object|!>>>] EXACT_MATCH\n" + 
			"Test.java Test [		I01<!|Object|!>>> {] EXACT_MATCH\n" + 
			""+ getExternalJCLPathString("1.5") + " java.lang.Object java.lang.Object.clone() EXACT_MATCH\n" + 
			""+ getExternalJCLPathString("1.5") + " boolean java.lang.Object.equals(java.lang.Object) EXACT_MATCH\n" + 
			""+ getExternalJCLPathString("1.5") + " java.lang.Class<? extends java.lang.Object> java.lang.Object.getClass() EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979f() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements I01<\n" + 
			"	I02<\n" + 
			"		I03<Object,\n" + 
			"			I02<Object, I01<Object>>,\n" + 
			"			I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" + 
			"			>,\n" + 
			"		I01<Object>>> {\n" + 
			"}\n" + 
			"interface I01<T> {}\n" + 
			"interface I02<T, U> {}\n" + 
			"interface I03<T, U, V> {}\n"
		);
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showSelection();
		search("Object", TYPE, REFERENCES | SUPERTYPE_TYPE_REFERENCE, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements I01<] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug322979g() throws CoreException {
	try
	{
		IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		createFile("/P/Test.java", 
			"public class Test extends Object implements I<A<Object>.B<I<Object>>.C<I<A<Object>.B<Object>.C<Object>>>> {\n" + 
			"}\n" + 
			"interface I<T> {\n" + 
			"}\n" + 
			"class A<T> {\n" + 
			"	class B<U> {\n" + 
			"		class C<V> {}\n" + 
			"	}\n" + 
			"}\n"
		);
		waitUntilIndexesReady();
		int mask = IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SOURCES ;
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		this.resultCollector.showSelection();
		search("Object", TYPE, IMPLEMENTORS, scope);
		assertSearchResults(
			"Test.java Test [public class Test extends !|Object|! implements I<A<Object>.B<I<Object>>.C<I<A<Object>.B<Object>.C<Object>>>> {] EXACT_MATCH"
		);
	} finally {
		deleteProject("P");
	}
}

/**
 * @bug 324109: [search] Java search shows incorrect results as accurate matches
 * @test search of method declaration off missing types should report potential matches and not accurate.

Return to bug 322979

Lines 38-43 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/SuperTypeReferenceLocator.java (+40 lines)
38	return nodeSet.addMatch(node, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);	38	return nodeSet.addMatch(node, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
39		39
40	char[] typeRefSimpleName = null;	40	char[] typeRefSimpleName = null;
		41	removeTypeArgumentsMatches(node, nodeSet);
41	if (node instanceof SingleTypeReference) {	42	if (node instanceof SingleTypeReference) {
42	typeRefSimpleName = ((SingleTypeReference) node).token;	43	typeRefSimpleName = ((SingleTypeReference) node).token;
43	} else { // QualifiedTypeReference	44	} else { // QualifiedTypeReference
Lines 73-78 Link Here
73	protected int referenceType() {	74	protected int referenceType() {
74	return IJavaElement.TYPE;	75	return IJavaElement.TYPE;
75	}	76	}
		77	/*
		78	* When the type reference is a type argument it cannot be a super type
		79	* reference as well. Hence, this method seek through type arguments of
		80	* the given type reference if any to remove any corresponding matches already
		81	* stored in the node set...
		82	*
		83	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=322979"
		84	*/
		85	private void removeTypeArgumentsMatches(TypeReference typeReference, MatchingNodeSet nodeSet) {
		86	if (typeReference instanceof ParameterizedSingleTypeReference) {
		87	ParameterizedSingleTypeReference parameterizedTypeReference = (ParameterizedSingleTypeReference) typeReference;
		88	if (parameterizedTypeReference.typeArguments != null) {
		89	removeTypeArgumentsMatches(parameterizedTypeReference.typeArguments, nodeSet);
		90	}
		91	}
		92	if (typeReference instanceof ParameterizedQualifiedTypeReference) {
		93	ParameterizedQualifiedTypeReference parameterizedTypeReference = (ParameterizedQualifiedTypeReference) typeReference;
		94	if (parameterizedTypeReference.typeArguments != null) {
		95	TypeReference[][] typesArguments = parameterizedTypeReference.typeArguments;
		96	int length = typesArguments.length;
		97	for (int i=0; i<length; i++) {
		98	removeTypeArgumentsMatches(typesArguments[i], nodeSet);
		99	}
		100	}
		101	}
		102	}
		103	/*
		104	* Remove any of the given type arguments from the possible or accurate
		105	* matches as they cannot be super type references...
		106	*/
		107	private void removeTypeArgumentsMatches(TypeReference[] typeArguments, MatchingNodeSet nodeSet) {
		108	int l = typeArguments == null ? 0 : typeArguments.length;
		109	for (int a=0; a<l; a++) {
		110	TypeReference typeArgument = typeArguments[a];
		111	if (nodeSet.removePossibleMatch(typeArgument) == null) {
		112	nodeSet.removeTrustedMatch(typeArgument);
		113	}
		114	}
		115	}
76	public int resolveLevel(ASTNode node) {	116	public int resolveLevel(ASTNode node) {
77	if (!(node instanceof TypeReference)) return IMPOSSIBLE_MATCH;	117	if (!(node instanceof TypeReference)) return IMPOSSIBLE_MATCH;
78		118

Lines 12072-12077 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (+203 lines)
12072	}	12072	}
12073	}	12073	}
12074		12074
		12075	static { TESTS_PREFIX = "testBug322979"; }
		12076	public void testBug322979a() throws CoreException {
		12077	try
		12078	{
		12079	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		12080	createFile("/P/Test.java",
		12081	"public class Test extends Object implements Comparable<Object>{\n"+
		12082	"public int compareTo(Object o) {\n"+
		12083	"return 0;\n"+
		12084	"}\n"+
		12085	"}\n");
		12086	waitUntilIndexesReady();
		12087	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
		12088	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		12089	this.resultCollector.showAccuracy(true);
		12090	this.resultCollector.showSelection();
		12091	search("Object", TYPE, IMPLEMENTORS, scope);
		12092	assertSearchResults(
		12093	"Test.java Test [public class Test extends !\|Object\|! implements Comparable<Object>{] EXACT_MATCH"
		12094	);
		12095	} finally {
		12096	deleteProject("P");
		12097	}
		12098	}
		12099
		12100	public void testBug322979b() throws CoreException {
		12101	try
		12102	{
		12103	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		12104	createFile("/P/Test.java",
		12105	"public class Test extends java.lang.Object implements Comparable<Object>{\n"+
		12106	"public int compareTo(Object o) {\n"+
		12107	"return 0;\n"+
		12108	"}\n"+
		12109	"}\n");
		12110	waitUntilIndexesReady();
		12111	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
		12112	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
		12113	IType type = getClassFile("P", getExternalJCLPathString("1.5"), "java.lang", "Object.class").getType();
		12114	this.resultCollector.showAccuracy(true);
		12115	this.resultCollector.showSelection();
		12116	search(type, IMPLEMENTORS, scope);
		12117	assertSearchResults(
		12118	"Test.java Test [public class Test extends !\|java.lang.Object\|! implements Comparable<Object>{] EXACT_MATCH"
		12119	);
		12120	} finally {
		12121	deleteProject("P");
		12122	}
		12123	}
		12124
		12125	public void testBug322979c() throws CoreException {
		12126	try
		12127	{
		12128	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
		12129	createFile("/P/Test.java",
		12130	"public class Test extends Object implements I01a<Object>, I01b<String>, I01c<Object> {\n" +
		12131	"}\n" +
		12132	"interface I01a<T> {}\n" +
		12133	"interface I01b<T> {}\n" +
		12134	"interface I01c<T> {}\n"
		12135	);
		12136	waitUntilIndexesReady();
		12137	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
		12138	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
12139	this.resultCollector.showSelection();
12140	search("java.lang.Object", TYPE, IMPLEMENTORS, scope);
12141	assertSearchResults(
12142	"Test.java Test [public class Test extends !\|Object\|! implements I01a<Object>, I01b<String>, I01c<Object> {] EXACT_MATCH"
12143	);
12144	} finally {
12145	deleteProject("P");
12146	}
12147	}
12148
12149	public void testBug322979d() throws CoreException {
12150	try
12151	{
12152	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
12153	createFile("/P/Test.java",
12154	"public class Test extends Object implements I01<\n" +
12155	" I02<\n" +
12156	" I03<Object,\n" +
12157	" I02<Object, I01<Object>>,\n" +
12158	" I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" +
12159	" >,\n" +
12160	" I01<Object>>> {\n" +
12161	"}\n" +
12162	"interface I01<T> {}\n" +
12163	"interface I02<T, U> {}\n" +
12164	"interface I03<T, U, V> {}\n"
12165	);
12166	waitUntilIndexesReady();
12167	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
12168	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
12169	this.resultCollector.showSelection();
12170	search("Object", TYPE, IMPLEMENTORS, scope);
12171	assertSearchResults(
12172	"Test.java Test [public class Test extends !\|Object\|! implements I01<] EXACT_MATCH"
12173	);
12174	} finally {
12175	deleteProject("P");
12176	}
12177	}
12178
12179	public void testBug322979e() throws CoreException {
12180	try
12181	{
12182	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
12183	createFile("/P/Test.java",
12184	"public class Test extends Object implements I01<\n" +
12185	" I02<\n" +
12186	" I03<Object,\n" +
12187	" I02<Object, I01<Object>>,\n" +
12188	" I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" +
12189	" >,\n" +
12190	" I01<Object>>> {\n" +
12191	"}\n" +
12192	"interface I01<T> {}\n" +
12193	"interface I02<T, U> {}\n" +
12194	"interface I03<T, U, V> {}\n"
12195	);
12196	waitUntilIndexesReady();
12197	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
12198	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
12199	this.resultCollector.showSelection();
12200	search("Object", TYPE, REFERENCES, scope);
12201	assertSearchResults(
12202	"Test.java Test [public class Test extends !\|Object\|! implements I01<] EXACT_MATCH\n" +
12203	"Test.java Test [ I03<!\|Object\|!,] EXACT_MATCH\n" +
12204	"Test.java Test [ I02<!\|Object\|!, I01<Object>>,] EXACT_MATCH\n" +
12205	"Test.java Test [ I02<Object, I01<!\|Object\|!>>,] EXACT_MATCH\n" +
12206	"Test.java Test [ I03<!\|Object\|!, I01<Object>, I02<Object, I01<Object>>>] EXACT_MATCH\n" +
12207	"Test.java Test [ I03<Object, I01<!\|Object\|!>, I02<Object, I01<Object>>>] EXACT_MATCH\n" +
12208	"Test.java Test [ I03<Object, I01<Object>, I02<!\|Object\|!, I01<Object>>>] EXACT_MATCH\n" +
12209	"Test.java Test [ I03<Object, I01<Object>, I02<Object, I01<!\|Object\|!>>>] EXACT_MATCH\n" +
12210	"Test.java Test [ I01<!\|Object\|!>>> {] EXACT_MATCH\n" +
12211	""+ getExternalJCLPathString("1.5") + " java.lang.Object java.lang.Object.clone() EXACT_MATCH\n" +
12212	""+ getExternalJCLPathString("1.5") + " boolean java.lang.Object.equals(java.lang.Object) EXACT_MATCH\n" +
12213	""+ getExternalJCLPathString("1.5") + " java.lang.Class<? extends java.lang.Object> java.lang.Object.getClass() EXACT_MATCH"
12214	);
12215	} finally {
12216	deleteProject("P");
12217	}
12218	}
12219
12220	public void testBug322979f() throws CoreException {
12221	try
12222	{
12223	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
12224	createFile("/P/Test.java",
12225	"public class Test extends Object implements I01<\n" +
12226	" I02<\n" +
12227	" I03<Object,\n" +
12228	" I02<Object, I01<Object>>,\n" +
12229	" I03<Object, I01<Object>, I02<Object, I01<Object>>>\n" +
12230	" >,\n" +
12231	" I01<Object>>> {\n" +
12232	"}\n" +
12233	"interface I01<T> {}\n" +
12234	"interface I02<T, U> {}\n" +
12235	"interface I03<T, U, V> {}\n"
12236	);
12237	waitUntilIndexesReady();
12238	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
12239	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
12240	this.resultCollector.showSelection();
12241	search("Object", TYPE, REFERENCES \| SUPERTYPE_TYPE_REFERENCE, scope);
12242	assertSearchResults(
12243	"Test.java Test [public class Test extends !\|Object\|! implements I01<] EXACT_MATCH"
12244	);
12245	} finally {
12246	deleteProject("P");
12247	}
12248	}
12249
12250	public void testBug322979g() throws CoreException {
12251	try
12252	{
12253	IJavaProject project = createJavaProject("P", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5");
12254	createFile("/P/Test.java",
12255	"public class Test extends Object implements I<A<Object>.B<I<Object>>.C<I<A<Object>.B<Object>.C<Object>>>> {\n" +
12256	"}\n" +
12257	"interface I<T> {\n" +
12258	"}\n" +
12259	"class A<T> {\n" +
12260	" class B<U> {\n" +
12261	" class C<V> {}\n" +
12262	" }\n" +
12263	"}\n"
12264	);
12265	waitUntilIndexesReady();
12266	int mask = IJavaSearchScope.APPLICATION_LIBRARIES \| IJavaSearchScope.SOURCES ;
12267	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project }, mask);
12268	this.resultCollector.showSelection();
12269	search("Object", TYPE, IMPLEMENTORS, scope);
12270	assertSearchResults(
12271	"Test.java Test [public class Test extends !\|Object\|! implements I<A<Object>.B<I<Object>>.C<I<A<Object>.B<Object>.C<Object>>>> {] EXACT_MATCH"
12272	);
12273	} finally {
12274	deleteProject("P");
12275	}
12276	}
12277
12075	/**	12278	/**
12076	* @bug 324109: [search] Java search shows incorrect results as accurate matches	12279	* @bug 324109: [search] Java search shows incorrect results as accurate matches
12077	* @test search of method declaration off missing types should report potential matches and not accurate.	12280	* @test search of method declaration off missing types should report potential matches and not accurate.