Attachment #115133 for bug #12044




 * (regression test for bug 23112 search: need a way to search for references to the implicit non-arg constructor)
 */
public void testConstructorReference10() throws CoreException { // was testConstructorReferenceImplicitConstructorCall2
	this.resultCollector.showSynthetic();
	search(
		"c11.A()",
		CONSTRUCTOR,

public void testFieldReference03() throws CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q8", "EclipseTest.java").getType("EclipseTest");
	IField field = type.getField("test");
	this.resultCollector.showPotential(false);
	search(field, REFERENCES, getJavaSearchScope());
	assertSearchResults(
		"src/q8/EclipseTest.java void q8.EclipseTest.main(String[]) [test]"

public void testFieldReference20() throws CoreException { // was testFieldReferenceInOutDocComment
	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
	IField field = type.getField("x");
	this.resultCollector.showInsideDoc();
	search(field, REFERENCES, getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/s4/X.java int s4.X.foo() [x] OUTSIDE_JAVADOC\n" +

public void testMethodReference15() throws CoreException { // was testMethodReferenceInOutDocComment
	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
	IMethod method = type.getMethod("foo", new String[] {});
	this.resultCollector.showInsideDoc();
	search(method, REFERENCES, getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/s4/X.java void s4.X.bar() [foo()] INSIDE_JAVADOC\n" +

public void testMethodReference17() throws CoreException {
	IType type = getCompilationUnit("JavaSearch/src/b111416/X.java").getType("X");
	IMethod method = type.getMethod("open", new String[] {"QString;"});
	this.resultCollector.showAccuracy(true);
	search(method, REFERENCES, ERASURE_RULE, getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/b111416/X.java void b111416.X.foo() [open(\"\")] EXACT_MATCH",

		.getType("A1").getMethod("m", new String[] {});
	SearchPattern rightPattern = createPattern(rightMethod, ALL_OCCURRENCES);
	SearchPattern orPattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
	this.resultCollector.showAccuracy(true);
	search(
		orPattern,
		getJavaSearchScope(),

 */
public void testPackageDeclarationBug73551() throws CoreException {
	JavaSearchResultCollector result = new JavaSearchResultCollector();
	result.showAccuracy(true);
	IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "p71267", "Test.java").getPackageDeclaration("p71267");
	search(packDecl, DECLARATIONS, getJavaSearchScope(),  result);
	assertSearchResults(

	try {
		test = srcRoot.createPackageFragment("b117020", true, null);
		JavaSearchResultCollector result = new JavaSearchResultCollector();
		result.showAccuracy(true);
		search(test, DECLARATIONS, getJavaSearchScope(),  result);
		assertSearchResults(
			"src/b117020 b117020 EXACT_MATCH",

		JAVA_PROJECT.setRawClasspath(newClasspath, null);

		// potential match for a field declaration
		this.resultCollector.showAccuracy(true);
		search("MissingFieldType.*", FIELD, DECLARATIONS,  getJavaSearchScope());
		assertSearchResults(
			"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +

	            }
            }
		};
		collector.showAccuracy(true);
		search("*", FIELD, DECLARATIONS,  getJavaSearchScope(), collector);
		assertSearchResults(
			"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +

		JAVA_PROJECT.setRawClasspath(newClasspath, null);

		// potential match for a method declaration
		this.resultCollector.showAccuracy(true);
		search("MissingArgumentType.foo*", METHOD, DECLARATIONS, getJavaSearchScope());
		assertSearchResults(
			"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +

	            }
            }
		};
		collector.showAccuracy(true);
		search("*", METHOD, DECLARATIONS,  getJavaSearchScope(), collector);
		assertSearchResults(
			"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +

		JAVA_PROJECT.setRawClasspath(newClasspath, null);

		// exact match for a type declaration
		this.resultCollector.showAccuracy(true);
		search("AbortCompilation.*Missing*", TYPE, DECLARATIONS,  getJavaSearchScope());
		assertSearchResults(
			"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +

		JAVA_PROJECT.setRawClasspath(newClasspath, null);

		// exact match for a type declaration
		this.resultCollector.showAccuracy(true);
		search("Missing*", TYPE, DECLARATIONS,  getJavaSearchScope());
		assertSearchResults(
			"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +

	IPackageFragmentRoot root = getPackageFragmentRoot("JavaSearch", "test20631.jar");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});

	this.resultCollector.showJarFile();
	search("Y", TYPE, DECLARATIONS, scope);
		TYPE,
		DECLARATIONS,
		scope,
		this.resultCollector);
	assertSearchResults(
		"test20631.jar|X$Y.class X$Y"
	);
}
/**
 * Type declaration using a package scope test.

public void testTypeReference03() throws CoreException {
	SearchPattern pattern = createPattern("x31985", TYPE, REFERENCES, false);

	this.resultCollector.showAccuracy(true);
	search(
		pattern,
		getJavaSearchScope(),

public void testTypeReference10() throws CoreException { // was testMemberTypeReference
	// references to second level member type

	this.resultCollector.showAccuracy(true);
	search(
		"BMember",
		TYPE,


	// references to first level member type
	this.resultCollector = new JavaSearchResultCollector();
	this.resultCollector.showAccuracy(true);
	search(
		"AzzMember",
		TYPE,


	// no reference to a field with same name as member type
	this.resultCollector = new JavaSearchResultCollector();
	this.resultCollector.showAccuracy(true);
	search(
		"BMember",
		FIELD,

		.getType("A")
		.getType("Object");

	this.resultCollector.showAccuracy(true);
	search(
		type,
		REFERENCES,

public void testTypeReference24() throws CoreException { // was testTypeReferenceInThrows
	IType type = getCompilationUnit("JavaSearch", "src", "a7", "X.java").getType("MyException");

	this.resultCollector.showAccuracy(true);
	search(
		type,
		REFERENCES,

 */
public void testTypeReference26() throws CoreException { // was testInnacurateTypeReference2

	this.resultCollector.showAccuracy(true);
	this.resultCollector.showSelection();
	search(
		"p.Zork",
		TYPE,

public void testTypeReference27() throws CoreException { // was testInnacurateTypeReference3
	IType type = getCompilationUnit("JavaSearch", "src", "r3", "A21485.java").getType("A21485");

	this.resultCollector.showAccuracy(true);
	search(
		type,
		REFERENCES,

public void testTypeReference33() throws CoreException { // was testTypeReferenceWithRecovery
	IType type = getCompilationUnit("JavaSearch", "src", "e1", "A29366.java").getType("A29366");

	this.resultCollector.showAccuracy(true);
	search(
		type,
		REFERENCES,

public void testTypeReference34() throws CoreException { // was testTypeReferenceWithProblem
	IType type = getCompilationUnit("JavaSearch", "src", "e6", "A.java").getType("A");

	this.resultCollector.showAccuracy(true);
	search(
		"B36479",
		TYPE,


		IType type = getCompilationUnit("JavaSearch", "src", "e7", "A.java").getType("A");

		this.resultCollector.showAccuracy(true);
		search(
			type,
			REFERENCES,

	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "f2");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});

	this.resultCollector.showSelection();
	search(
		"Y",
		TYPE,


	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();

	this.resultCollector.showSelection();
	search(
		localType,
		REFERENCES,

 */
public void testTypeReference38() throws CoreException { // was testTypeReferenceInOutDocComment
	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
	this.resultCollector.showInsideDoc();
	search(type, REFERENCES, getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/s4/X.java void s4.X.bar() [X] INSIDE_JAVADOC\n" +

Lines 433-440 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (-1 / +4 lines)
433	protected void addLibraryEntry(String path, boolean exported) throws JavaModelException {	433	protected void addLibraryEntry(String path, boolean exported) throws JavaModelException {
434	addLibraryEntry(this.currentProject, new Path(path), null, null, null, null, exported);	434	addLibraryEntry(this.currentProject, new Path(path), null, null, null, null, exported);
435	}	435	}
		436	protected void addLibraryEntry(IJavaProject project, String path) throws JavaModelException {
		437	addLibraryEntry(project, new Path(path), null, null, null, null, false);
		438	}
436	protected void addLibraryEntry(IJavaProject project, String path, boolean exported) throws JavaModelException {	439	protected void addLibraryEntry(IJavaProject project, String path, boolean exported) throws JavaModelException {
437	addLibraryEntry(project, new Path(path), exported);	440	addLibraryEntry(project, new Path(path), null, null, null, null, exported);
438	}	441	}
439	protected void addLibraryEntry(IJavaProject project, IPath path, boolean exported) throws JavaModelException {	442	protected void addLibraryEntry(IJavaProject project, IPath path, boolean exported) throws JavaModelException {
440	addLibraryEntry(project, path, null, null, null, null, exported);	443	addLibraryEntry(project, path, null, null, null, null, exported);

Lines 32-39 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchGenericTests.java (-2 / +2 lines)
32		32
33	protected void setUp () throws Exception {	33	protected void setUp () throws Exception {
34	super.setUp();	34	super.setUp();
35	this.resultCollector.showAccuracy = true;	35	this.resultCollector.showAccuracy(true);
36	this.resultCollector.showRule = true;	36	this.resultCollector.showRule();
37	}	37	}
38		38
39	/*	39	/*

Lines 81-87 Link Here

(-)src/org/eclipse/jdt/core/tests/model/SearchTests.java (-1 / +2 lines)
81	CharOperation.concatWith(enclosingTypeNames, '$'),	81	CharOperation.concatWith(enclosingTypeNames, '$'),
82	simpleTypeName,	82	simpleTypeName,
83	'$');	83	'$');
84	this.results.addElement(new String(CharOperation.concat(packageName, typeName, '.')));	84	String qualifiedName = new String(CharOperation.concat(packageName, typeName, '.'));
		85	this.results.addElement(qualifiedName);
85	}	86	}
86	public String toString(){	87	public String toString(){
87	int length = this.results.size();	88	int length = this.results.size();




import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.search.AbstractSearchScope;
import org.eclipse.jdt.internal.core.search.indexing.IIndexConstants;
import org.eclipse.jdt.internal.core.search.matching.AndPattern;
import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.search.matching.AndPattern;
import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
import org.eclipse.jdt.internal.core.search.matching.PatternLocator;
import org.eclipse.jdt.internal.core.search.matching.TypeDeclarationPattern;

	return buildModelTestSuite(JavaSearchBugsTests.class);
}
static {
//	org.eclipse.jdt.internal.core.search.processing.JobManager.VERBOSE = true;
//	org.eclipse.jdt.internal.core.search.BasicSearchEngine.VERBOSE = true;
//	org.eclipse.jdt.internal.codeassist.SelectionEngine.DEBUG = true;
}

protected void setUp () throws Exception {
	super.setUp();
	this.resultCollector = new TestCollector();
	this.resultCollector.showAccuracy(true);
}

/**
 * @bug 12044: [search] Reference to package is not found in qualified annotation
 * @test Ensure that references to package are also found in qualified annotation
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=12044"
 */
private String[] sourcesBug12044() throws CoreException {
	return new String[] {
		"Def.java",
	    "public class Def {\n" + 
	    "	public static final int ONE = 1;\n" + 
	    "	public static final int TWO = 2;\n" + 
	    "	public static final int THREE = 3;\n" + 
	    "}\n",
		"Ref.java",
	    "public class Ref {\n" +
	    "	class Sub {\n" + 
	    "		int x = Def.ONE;\n" + 
	    "		int getX() {\n" + 
	    "			return x;\n" + 
	    "		}\n" + 
	    "	}\n" + 
	    "	void foo(Sub sub) {\n" + 
	    "		switch (sub.getX()) {\n" + 
	    "			case Def.ONE:\n" + 
	    "				break;\n" + 
	    "			case Def.TWO:\n" + 
	    "				break;\n" + 
	    "			case Def.THREE:\n" + 
	    "				break;\n" + 
	    "		}\n" + 
	    "	}\n" + 
	    "}\n"
	};
}
static { TESTS_PREFIX = "testBug12044"; }
public void testBug12044_no_src() throws CoreException, IOException {
	IJavaProject javaProject = null;
	try {
		javaProject = createJavaProject("b012044", new String[] { "src" }, new String[] {"JCL_LIB" }, "bin");
		waitUntilIndexesReady();
		String jarPath = getWorkspacePath()+"b012044"+File.separator+"b012044.jar";
		createJar(sourcesBug12044(), jarPath);
		refresh(javaProject);
		String resourcePath = "/b012044/b012044.jar";
		addLibraryEntry(javaProject, resourcePath);
		waitUntilIndexesReady();
		IClassFile classFile = getClassFile("b012044", resourcePath, "", "Def.class");
		IField field = classFile.getType().getField("ONE");
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { javaProject } );
		this.resultCollector.showJarFile();
		search(field, ALL_OCCURRENCES, scope);
		assertSearchResults(
		"b012044.jar|Def.class Def.ONE [No source] EXACT_MATCH"
		);
	}
	finally {
		if (javaProject != null) {
			deleteProject(javaProject);
		}
	}
}
public void testBug12044_src_in_zip() throws CoreException, IOException {
	IJavaProject javaProject = null;
	try {
		javaProject = createJavaProject("b012044", new String[] { "src" }, new String[] {"JCL_LIB" }, "bin");
		waitUntilIndexesReady();
		String path = getWorkspacePath()+"b012044"+File.separator+"b012044";
		String jarPath = path+".jar";
		createJar(sourcesBug12044(), jarPath);
		String zipPath = path+".zip";
		Util.createSourceZip(sourcesBug12044(), zipPath);
		refresh(javaProject);
		String resourcePath = "/b012044/b012044.jar";
		String resourceZipPath = "/b012044/b012044.zip";
		addLibraryEntry(javaProject, resourcePath, resourceZipPath);
		waitUntilIndexesReady();
		IClassFile classFile = getClassFile("b012044", resourcePath, "", "Def.class");
		IField field = classFile.getType().getField("ONE");
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { javaProject } );
		this.resultCollector.showJarFile();
		search(field, ALL_OCCURRENCES, scope);
		assertSearchResults(
			"b012044.jar|Def.class Def.ONE EXACT_MATCH\n" + 
			"b012044.jar|Ref.class void Ref.foo(Ref.Sub) EXACT_MATCH\n" + 
			"b012044.jar|Ref$Sub.class Ref$Sub.x EXACT_MATCH"
		);
	}
	finally {
		if (javaProject != null) {
			deleteProject(javaProject);
		}
	}
}

/**

	);
}
public void testBug79378b() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b79378/A.java",
		"package b79378;\n" +

	);
}
public void testBug82208_TYPE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", TYPE, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_CLASS() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", CLASS, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_INTERFACE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", INTERFACE, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_ENUM() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", ENUM, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_ANNOTATION_TYPE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", ANNOTATION_TYPE, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_CLASS_AND_INTERFACE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", CLASS_AND_INTERFACE, ALL_OCCURRENCES);
	assertSearchResults(

	);
}
public void testBug82208_CLASS_AND_ENUMERATION() throws CoreException {
	this.resultCollector.showRule();
	setUpBug82208();
	search("B82208*", CLASS_AND_ENUM, ALL_OCCURRENCES);
	assertSearchResults(

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83012"
 */
public void testBug82673() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b82673/Test.java",
		"package b82673;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83012"
 */
public void testBug83012() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83012/Test.java",
		"package b83012;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83230"
 */
private void setUpBug83230_Explicit() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83230/Test.java",
		"package b83230;\n" +

	);
}
public void testBug83230_Explicit() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IMethod method = selectMethod(this.workingCopies[0], "authorName");
	search(method, REFERENCES);

	);
}
public void testBug83230_Explicit01() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IMethod method = selectMethod(this.workingCopies[0], "authorName");
	search(method, DECLARATIONS);

	);
}
public void testBug83230_Explicit02() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IType type = selectType(this.workingCopies[0], "Address");
	search(type, REFERENCES);

	);
}
public void testBug83230_Explicit03() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IMethod method = selectMethod(this.workingCopies[0], "foo");
	search(method, REFERENCES);

	);
}
public void testBug83230_Explicit04() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IField field = selectField(this.workingCopies[0], "city");
	search(field, REFERENCES);

	);
}
public void testBug83230_Explicit05() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83230_Explicit();
	IField field = selectField(this.workingCopies[0], "ageMin");
	search(field, REFERENCES);

	);
}
public void testBug83230_Implicit01() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83230/Test.java",
		"package b83230;\n" +

	);
}
public void testBug83230_Implicit02() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83230/Test.java",
		"package b83230;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83304"
 */
public void testBug83304() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83304/Test.java",
		"package b83304;\n" +

	);
}
private void setUpBug83304_TypeParameterizedElementPattern() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83304/Types.java",
		"package b83304;\n" +

	);
}
public void testBug83304_TypeParameterizedElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_TypeParameterizedElementPattern();
	IType type = selectType(this.workingCopies[0], "Generic", 4);
	search(type, REFERENCES, ERASURE_RULE);

	);
}
public void testBug83304_TypeGenericElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_TypeParameterizedElementPattern();
	IType type = getClassFile("JavaSearchBugs", "lib/JavaSearch15.jar", "g1.t.s.def", "Generic.class").getType();
	search(type, REFERENCES, ERASURE_RULE);

	);
}
public void testBug83304_TypeStringPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_TypeParameterizedElementPattern();
	search("Generic<? super Exception>", TYPE, REFERENCES, ERASURE_RULE);
	assertSearchResults(

	);
}
private void setUpBug83304_MethodParameterizedElementPattern() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83304/Methods.java",
		"package b83304;\n" +

	);
}
public void testBug83304_MethodParameterizedElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_MethodParameterizedElementPattern();
	IMethod method = selectMethod(this.workingCopies[0], "generic", 2);
	search(method, REFERENCES, ERASURE_RULE);

	);
}
public void testBug83304_MethodGenericElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_MethodParameterizedElementPattern();
	IType type = getClassFile("JavaSearchBugs", "lib/JavaSearch15.jar", "g5.m.def", "Single.class").getType();
	IMethod method = type.getMethod("generic", new String[] { "TU;" });

	);
}
public void testBug83304_MethodStringPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_MethodParameterizedElementPattern();
	search("<Exception>generic", METHOD, REFERENCES, ERASURE_RULE);
	assertSearchResults(

	);
}
private void setUpBug83304_ConstructorGenericElementPattern() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83304/Constructors.java",
		"package b83304;\n" +

	);
}
public void testBug83304_ConstructorGenericElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_ConstructorGenericElementPattern();
	IMethod method = selectMethod(this.workingCopies[0], "Single", 3);
	search(method, REFERENCES, ERASURE_RULE);

	);
}
public void testBug83304_ConstructorParameterizedElementPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_ConstructorGenericElementPattern();
	IType type = getClassFile("JavaSearchBugs", "lib/JavaSearch15.jar", "g5.c.def", "Single.class").getType();
	IMethod method = type.getMethod("Single", new String[] { "TT;", "TU;" });

	);
}
public void testBug83304_ConstructorStringPattern() throws CoreException {
	this.resultCollector.showRule();
	setUpBug83304_ConstructorGenericElementPattern();
	search("<Exception>Single", CONSTRUCTOR, REFERENCES, ERASURE_RULE);
	assertSearchResults(

	);
}
public void testBug83804_Type() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug83804_Type();
	IType type = this.workingCopies[1].getType("Test");
	search(type, REFERENCES);

	);
}
public void testBug83804_Method() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug83804_Type();
	IMethod[] methods = this.workingCopies[1].getType("Test").getMethods();
	assertEquals("Invalid number of methods", 1, methods.length);

	);
}
public void testBug83804_Field() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug83804_Type();
	IField[] fields = this.workingCopies[1].getType("Test").getFields();
	assertEquals("Invalid number of fields", 1, fields.length);

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83388"
 */
public void testBug83388() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83388/R.java",
		"package b83388;\n" +

	);
}
public void testBug83388b() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83388/R.java",
		"package b83388;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83693"
 */
public void testBug83693() throws CoreException {
	this.resultCollector.showRule();
	this.resultCollector.showInsideDoc();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b83693/A.java",
		"package b83693;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=84100"
 */
private void setUpBug84100() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b84100/X.java",
		"package b84100;\n" +

	);
}
public void testBug84100() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84100();
	IMethod method = selectMethod(this.workingCopies[0], "foo", 1);
	search(method, REFERENCES);

	);
}
public void testBug84100b() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84100();
	IMethod method = selectMethod(this.workingCopies[0], "foo", 2);
	search(method, REFERENCES);

	);
}
public void testBug84100c() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84100();
	IMethod method = selectMethod(this.workingCopies[0], "foo", 3);
	search(method, REFERENCES);

	);
}
public void testBug84100d() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84100();
	IMethod method = selectMethod(this.workingCopies[0], "foo", 4);
	search(method, REFERENCES);

	);
}
public void testBug84100e() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84100();
	IMethod method = selectMethod(this.workingCopies[0], "foo", 5);
	search(method, REFERENCES);

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=84121"
 */
public void testBug84121() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b84121/Test.java",
		"package b84121;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=84724"
 */
private void setUpBug84724() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b84724/X.java",
		"package b84724;\n" +

	);
}
public void testBug84724() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84724();
	IMethod method = selectMethod(this.workingCopies[0], "X", 2);
	search(method, REFERENCES);

	);
}
public void testBug84724b() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84724();
	IMethod method = selectMethod(this.workingCopies[0], "X", 3);
	search(method, REFERENCES);

	);
}
public void testBug84724c() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84724();
	IMethod method = selectMethod(this.workingCopies[0], "X", 4);
	search(method, REFERENCES);

	);
}
public void testBug84724d() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84724();
	IMethod method = selectMethod(this.workingCopies[0], "X", 5);
	search(method, REFERENCES);

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=84727"
 */
private void setUpBug84727() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[3];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b84727/A.java",
		"package b84727;\n" +

	);
}
public void testBug84727() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84727();
	IMethod[] methods = this.workingCopies[0].getType("A").getMethods();
	assertEquals("Invalid number of methods", 2, methods.length);

	);
}
public void testBug84727b() throws CoreException {
	this.resultCollector.showRule();
	setUpBug84727();
	IMethod[] methods = this.workingCopies[0].getType("A").getMethods();
	assertEquals("Invalid number of methods", 2, methods.length);

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=85810"
 */
public void testBug85810() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b85810/Test.java",
		"package b85810;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=86596"
 */
public void testBug86596() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[3];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b86596/aa/link/A.java",
		"package b86596.aa.link;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=86642"
 */
public void testBug86642() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b86642/A.java",
		"package b86642;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=86380"
 */
private void setUpBug86380() throws CoreException {
	this.resultCollector.showInsideDoc();
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b86380/package-info.java",
		"/**\n" +

	);
}
public void testBug86380_Type() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug86380();
	ICompilationUnit unit = getCompilationUnit("JavaSearchBugs", "src", "b86380", "Annot.java");
	IType type = unit.getType("Annot");

	);
}
public void testBug86380_Method() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug86380();
	ICompilationUnit unit = getCompilationUnit("JavaSearchBugs", "src", "b86380", "Annot.java");
	IMethod[] methods = unit.getType("Annot").getMethods();

	);
}
public void testBug86380_Field() throws CoreException {
	this.resultCollector.showInsideDoc();
	setUpBug86380();
	ICompilationUnit unit = getCompilationUnit("JavaSearchBugs", "src", "b86380", "Annot.java");
	IField[] fields = unit.getType("Annot").getFields();

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=88174"
 */
public void testBug88174() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b88174/Test.java",
		"package b88174;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=92944"
 */
private void setUpBug92944() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b92944/Test.java",
		"package b92944;\n" +

	);
}
public void testBug92944_TYPE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_CLASS() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_CLASS_AND_INTERFACE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_CLASS_AND_ENUM() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_INTERFACE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_ENUM() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

		requestor);
}
public void testBug92944_ANNOTATION_TYPE() throws CoreException {
	this.resultCollector.showRule();
	setUpBug92944();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine(this.workingCopies).searchAllTypeNames(

 */
public void testBug93392() throws CoreException {
	TestCollector collector = new TestCollector();
	collector.showAccuracy(true);
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b93392/Test.java",
		"package b93392;\n" +


	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy(true);
	search(type, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [b95794.Test] EXACT_MATCH\n" +

	assertEquals("Problem with occurences or references number of matches: ", occurencesCollector.matches.size()-1, referencesCollector.matches.size());
}
public void testBug95794b() throws CoreException {
	this.resultCollector.showRule();
	ICompilationUnit unit = getCompilationUnit("JavaSearchBugs", "src", "b95794", "Test.java");
	IType type = unit.getType("Test").getType("Color");

	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy(true);
	search(type, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [b95794.Test.Color] EXACT_MATCH\n" +

	assertEquals("Problem with occurences or references number of matches: ", occurencesCollector.matches.size()-1, referencesCollector.matches.size());
}
public void testBug95794c() throws CoreException {
	this.resultCollector.showRule();
	ICompilationUnit unit = getCompilationUnit("JavaSearchBugs", "src", "b95794", "Test.java");
	IField field = unit.getType("Test").getType("Color").getField("WHITE");

	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy(true);
	search(field, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [WHITE] EXACT_MATCH\n" +

 */
public void testBug97087() throws CoreException {
	this.workingCopies = new ICompilationUnit[1];
	this.resultCollector.showRule();
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b97087/Bug.java",
		"package b97087;\n" +
		"public class Bug<Type> {\n" +

		this.workingCopies[1].commitWorkingCopy(true, null);
		this.workingCopies[2].commitWorkingCopy(true, null);
		this.workingCopies[3].commitWorkingCopy(true, null);
		this.resultCollector.showRule();
		IType type = this.workingCopies[0].getType("L");
		search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH);
		assertSearchResults(

		this.workingCopies[1].commitWorkingCopy(true, null);
		this.workingCopies[2].commitWorkingCopy(true, null);
		this.workingCopies[3].commitWorkingCopy(true, null);
		this.resultCollector.showRule();
		IType type = this.workingCopies[0].getType("L");
		search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH);
		assertSearchResults(

		"public @interface Annot {\n" +
		"}\n"
	);
	this.resultCollector.showInsideDoc();
	IType type = this.workingCopies[1].getType("Test");
	search(type, REFERENCES);
	assertSearchResults(

		"}"
	);
	IType type = this.workingCopies[0].getType("X");
	this.resultCollector.showRule();
	search(type, REFERENCES, ERASURE_RULE);
	assertSearchResults(
		"src/p1/X.java p1.X.gen [X] EXACT_MATCH\n" +

		"}"
	);
	IType type = this.workingCopies[0].getType("Foo");
	this.resultCollector.showRule();
	new SearchEngine(this.workingCopies).search(
		SearchPattern.createPattern(type, REFERENCES),
		new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=148380"
 */
public void testBug148380_SearchAllTypes_wc() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[4];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b148380/I.java",
		"package b148380;\n" +

		);
		waitUntilIndexesReady();
		IPackageFragment packageFragment = getPackage("/JavaSearchBugs/src/b153765");
		this.resultCollector.showSelection();
		search(packageFragment, REFERENCES);
		assertSearchResults(
			"src/b153765/test/SomeClass.java void b153765.test.SomeClass.foo() [        @§|b153765|§.Unimportant public void foo() {}] EXACT_MATCH"

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=156177"
 */
public void testBug156177() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b156177/Test.java",
		"package b156177;\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=156491"
 */
public void testBug156491() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/pack/Test.java",
		"package pack;\n" +

	);
}
public void testBug156491a() throws CoreException {
	this.resultCollector.showRule();
	setUpBug156491();
	IMethod method = this.workingCopies[0].getType("L2").getMethod("test", new String[0]);
	this.resultCollector.showFlavors = PatternLocator.SUPER_INVOCATION_FLAVOR;

	);
}
public void testBug156491b() throws CoreException {
	this.resultCollector.showRule();
	setUpBug156491();
	IMethod method = this.workingCopies[0].getType("L1").getMethod("test", new String[0]);
	this.resultCollector.showFlavors = PatternLocator.SUPER_INVOCATION_FLAVOR;

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=160301"
 */
public void testBug160301() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" +

	);
}
public void testBug160301b() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/test/Test.java",
		"package test;\n" +

	);
}
public void testBug160301_Interface() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" +

	);
}
public void testBug160301_Abstract() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" +

	);
}
public void testBug160301_Abstract2() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" +

	);
}
public void testBug160301_Abstract3() throws CoreException {
	this.resultCollector.showRule();
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" +

	);
}
public void testBug164121a() throws CoreException {
	this.resultCollector.showRule();
	setUpBug164121();
	ILocalVariable param = getLocalVariable(this.workingCopies[0], "param", "param");
	search(param, DECLARATIONS);

	);
}
public void testBug164121b() throws CoreException {
	this.resultCollector.showRule();
	setUpBug164121();
	ILocalVariable param = getLocalVariable(this.workingCopies[0], "param", "param");
	search(param, ALL_OCCURRENCES);

			assertTrue("Search match element "+element.getElementName()+" should exist!!!", element.exists());
		}
	};
	collector.showAccuracy(true);
	search(type, REFERENCES, getJavaSearchScope(), collector);
	assertSearchResults(
		"lib/b164791.jar test.<anonymous> EXACT_MATCH\n" +

        }

	};
	testCollector.showAccuracy(true);
	IMethod method = this.workingCopies[0].getType("ClassA").getMethod("setValue", new String[] { "I" });
	search(method, REFERENCES, getJavaSearchScope(), testCollector);
	assertSearchResults(

		"}\n" +
		"class Ref {}"
	);
	this.resultCollector.showInsideDoc();
	new SearchEngine(this.workingCopies).searchDeclarationsOfReferencedTypes(this.workingCopies[0], this.resultCollector, null);
	assertSearchResults(
		"src/b195489/Test.java b195489.Ref [Ref] EXACT_MATCH OUTSIDE_JAVADOC"

		"}\n" +
		"class Ref {}"
	);
	this.resultCollector.showInsideDoc();
	new SearchEngine(this.workingCopies).searchDeclarationsOfReferencedTypes(this.workingCopies[0], this.resultCollector, null);
	assertSearchResults(
		"src/b195489/Test.java b195489.Ref [Ref] EXACT_MATCH OUTSIDE_JAVADOC"

		"}\n" +
		"class Ref {}"
	);
	this.resultCollector.showInsideDoc();
	new SearchEngine(this.workingCopies).searchDeclarationsOfReferencedTypes(this.workingCopies[0], this.resultCollector, null);
	assertSearchResults(
		"src/b195489/Test.java b195489.Ref [Ref] EXACT_MATCH OUTSIDE_JAVADOC"

		"}\n" +
		"class Ref {}"
	);
	this.resultCollector.showInsideDoc();
	String docCommentSupport = JAVA_PROJECT.getOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, true);
	JAVA_PROJECT.setOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.DISABLED);
	try {

	);
	IType type = this.workingCopies[0].getType("Test");
	ReferenceCollector collector = new ReferenceCollector();
	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java @Annot(clazz=Test.class) [        @Annot(clazz=§|Test|§.class) int x;]",

		"}\n"
	);
	ReferenceCollector collector = new ReferenceCollector();
	collector.showSelection();
	search("Deprecated", TYPE, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java @Deprecated() [        @§|Deprecated|§ foo() {}]",

	);
	IType type = this.workingCopies[0].getType("Ref");
	ReferenceCollector collector = new ReferenceCollector();
	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment5/Ref.java void comment5.Ref.doA(Ref).ref [    void doA(§|Ref|§ ref) {}]\n" +

	);
	IField field = this.workingCopies[0].getType("Num").getField("CONST");
	ReferenceCollector collector = new ReferenceCollector();
	collector.showSelection();
	search(field, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment10/Ref.java @Num(number=Num.CONST) [@Num(number= Num.§|CONST|§)]",

	);
	IType type = this.workingCopies[0].getType("Tag");
	TypeReferenceCollector collector = new TypeReferenceCollector();
	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment22/Test.java @Tag() [    @§|Tag|§ Test test1, test2, test3;]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferenceCollector collector = new TypeReferenceCollector();
	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java @Annot(clazz=test.Test.class) [    @Annot(clazz = §|test.Test|§.class) int x, y;]",

		"public class Types {\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	search("*", TYPE, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/generics/Generic.java [import §|java.io.Serializable|§;] EXACT_MATCH\n" +

		"	Test test;\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	search("*", TYPE, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/Ref.java [import §|pack.Test|§;] EXACT_MATCH\n" +

	addLibraryEntry(JAVA_PROJECT, "/JavaSearchBugs/lib/b211366.jar", false);
	try {
		IType type = getClassFile("JavaSearchBugs", "lib/b211366.jar", "test", "Bug.class").getType();
		this.resultCollector.showMatchKind();
		search(type, REFERENCES);
		assertSearchResults(
			"TypeReferenceMatch: lib/b211366.jar pack.Test [No source] EXACT_MATCH\n" +

		SearchPattern rightPattern = SearchPattern.createPattern(type, REFERENCES);
		SearchPattern leftPattern = SearchPattern.createPattern(type, DECLARATIONS);
		SearchPattern pattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
		this.resultCollector.showMatchKind();
		new SearchEngine(this.workingCopies).search(
			pattern,
			new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

				SearchPattern.createPattern("Bug", TYPE, REFERENCES, SearchPattern.R_EXACT_MATCH)));
		IPackageFragmentRoot root = JAVA_PROJECT.getPackageFragmentRoot("/JavaSearchBugs/lib/b211366.jar");
		this.resultCollector.sorted = true;
		this.resultCollector.showMatchKind();
		new SearchEngine(this.workingCopies).search(
			SearchPattern.createOrPattern(leftPattern, rightPattern),
			new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

		"\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	ILocalVariable variable = selectLocalVariable(this.workingCopies[0], "test");
	search(variable, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	int fField;" +
		"}"
	);
	this.resultCollector.showSelection();
	IField field = this.workingCopies[0].getType("Test").getField("fWrapped");
	search(field, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, WRITE_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, WRITE_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	this.resultCollector.showAccess();
	this.resultCollector.showAccuracy(false);
	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	this.resultCollector.showAccess();
	this.resultCollector.showAccuracy(false);
	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}"
	);
	this.resultCollector.showSelection();
	IType type = selectType(this.workingCopies[0], "Row");
	search(type, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"	}\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	this.resultCollector.showRule();
	SearchPattern typePattern = SearchPattern.createPattern("test", TYPE, ALL_OCCURRENCES, SearchPattern.R_EXACT_MATCH);
	SearchPattern methPattern = SearchPattern.createPattern("test", METHOD, ALL_OCCURRENCES, SearchPattern.R_EXACT_MATCH);
	SearchPattern fieldPattern = SearchPattern.createPattern("test", FIELD, ALL_OCCURRENCES, SearchPattern.R_EXACT_MATCH);

		"public class Y<T extends X<?>> {\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	this.resultCollector.showRule();
	IType type = this.workingCopies[0].getType("X");
	search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"public class Z<T extends X<?> & I<?>> {\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	this.resultCollector.showRule();
	IType type = this.workingCopies[0].getType("I");
	search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(

		"\n" +
		"}\n"
	);
	this.resultCollector.showSelection();
	IType type = this.workingCopies[0].getType("Test");
	search(type, REFERENCES, getJavaSearchWorkingCopiesScope());


Lines 30-36 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchGenericFieldTests.java (-1 / +1 lines)
30		30
31	protected void setUp () throws Exception {	31	protected void setUp () throws Exception {
32	super.setUp();	32	super.setUp();
33	this.resultCollector.showAccuracy = true;	33	this.resultCollector.showAccuracy(true);
34	}	34	}
35		35
36	/**	36	/**





import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.core.tests.model.AbstractJavaSearchTests.JavaSearchResultCollector;

		IPackageFragmentRoot root = project.getPackageFragmentRoot(getFolder("/P1/test"));
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search("foo", METHOD, DECLARATIONS, scope, resultCollector);
		assertSearchResults(
			"test/Test.java [in P1] void Test.foo() [foo]",

		);
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search("ITest", TYPE, REFERENCES, scope, resultCollector);
		assertSearchResults(
			"test/Test.java [in P1] Test.test [ITest]\n" +

		assertNotNull("We should have a default fragment for project P1!", defaultFragment);
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {defaultFragment});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search("main(String[]) void", METHOD, DECLARATIONS, scope, resultCollector);
		assertSearchResults(
			"Test.java [in P1] void Test.main(String[]) [main]",

		);
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search("Test", TYPE, REFERENCES, scope, resultCollector);
		assertSearchResults(
			"src/X.java [in P1] X.test [Test]",


		// Index the output location as it is a library for the project
		IndexManager indexManager = JavaModelManager.getIndexManager();
		IPackageFragmentRoot root = project.getPackageFragmentRoot(getWorkspaceRoot().findMember("/P1/bin"));
		indexManager.indexPackageFragmentRoot(root);
		waitUntilIndexesReady();

		// Search for all types




protected void setUp () throws Exception {
	super.setUp();
	this.resultCollector = new JavaSearchResultCollector();
//	this.resultCollector.showInsideDoc = false;
	this.resultCollector.showAccuracy(true);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
}

static {

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
	return this.workingCopies[0].getType("Fields").getField("field");
}
public void testFieldRef() throws CoreException {

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
	return this.workingCopies[0].getType("Methods").getMethod("method", new String[0]);
}
public void testMethodRef() throws CoreException {

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
}
public void testTypeRefAll_Allocation() throws CoreException {
	setUpTypeRefAll();

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
	return this.workingCopies[0].getType("Types");
}
public void testTypeRefGeneric01() throws CoreException {

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
	return this.workingCopies[0].getType("Types");
}
public void testTypeRefGenericAll02() throws CoreException {

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
}
public void testTypeRefGenericMethod_AllGenericFlags() throws CoreException {
	setUpTypeRefGenericMethod();

		"----------\n",
		problemRequestor.problems.toString()
	);
	this.resultCollector.showSelection();
	this.resultCollector.showOffset();
}
public void testTypeRefQualifiedAll_Allocation() throws CoreException {
	setUpTypeRefQualifiedAll();





		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p1, p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		IField field = wc1.getType("X").getField("BAR");
		SearchPattern pattern = SearchPattern.createPattern(field, ALL_OCCURRENCES);
		new SearchEngine(new ICompilationUnit[] {wc1, wc2}).search(

		IMethod method = type.getMethod("foo", new String[] {});
		IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			REFERENCES,

		IMethod method = type.getMethod("foo", new String[] {});
		IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			REFERENCES,

		IMethod method = type.getMethod("foo", new String[] {});
		IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			REFERENCES,

		IMethod method = type.getMethod("foo", new String[] {});
		IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showAccuracy(true);
		resultCollector.showProject();
		search(
			method,
			REFERENCES,


		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p1, p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		IMethod method = getCompilationUnit("/P1/p/I.java").getType("I").getMethod("method", new String[] {"QObject;"});
		search(
			method,


		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p1, p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		IPackageFragment pkg = getPackage("/P1/p");
		search(
			pkg,


		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p1});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			"Object",
			TYPE,


		scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p2});
		resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			"Object",
			TYPE,

		// search method declaration in workspace scope
		IJavaSearchScope scope = SearchEngine.createWorkspaceScope(); //JavaSearchScope(new IJavaElement[] {p1, p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			DECLARATIONS,


		// search method declaration in workspace scope with JDT-UI flags
		resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			UI_DECLARATIONS,

		// search method declaration in project scope
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		search(
			method,
			UI_DECLARATIONS,

		// search method declaration in workspace scope
		IJavaSearchScope scope = SearchEngine.createWorkspaceScope(); //JavaSearchScope(new IJavaElement[] {p1, p2});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		resultCollector.showAccuracy(true);
		search(method, REFERENCES, scope, resultCollector);
		assertSearchResults(
			"Unexpected references of method Test.getType()",

		// Create scope and search
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { p1, p2 }, IJavaSearchScope.SOURCES | IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.REFERENCED_PROJECTS);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		resultCollector.showAccuracy(true);
		new SearchEngine().search(
			SearchPattern.createPattern("toString", IJavaSearchConstants.METHOD, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH),
			new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

		// Create scope and search
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { p1, p2, p3 }, IJavaSearchScope.SOURCES | IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.REFERENCED_PROJECTS);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		resultCollector.showAccuracy(true);
		new SearchEngine().search(
			SearchPattern.createPattern("toString", IJavaSearchConstants.METHOD, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH),
			new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

		SearchPattern leftPattern = SearchPattern.createPattern(typeA1, REFERENCES);
		SearchPattern pattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		resultCollector.showAccuracy(true);
		new SearchEngine().search(
			pattern,
			new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},

		// search annotation type reference in P2 scope
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {p2}, false/*don't include referenced projects*/);
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showProject();
		resultCollector.showAccuracy(true);
		search(type, ANNOTATION_TYPE_REFERENCE, scope, resultCollector);
		assertSearchResults(
			"Unexpected references of annotation type MyAnnot",




import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;
import org.eclipse.jdt.internal.core.Member;
import org.eclipse.jdt.internal.core.PackageFragment;
//import org.eclipse.jdt.internal.core.ResolvedSourceMethod;
//import org.eclipse.jdt.internal.core.ResolvedSourceType;

//	boolean discard;

	/**
	 * Flags for the default search result collector
	 */
	static protected final int SHOW_ACCURACY		= 0x0001;
	static protected final int SHOW_SELECTION		= 0x0002;
	static protected final int SHOW_RULE					= 0x0004;
	static protected final int SHOW_INSIDE_DOC		= 0x0008;
	static protected final int SHOW_POTENTIAL		= 0x0010;
	static protected final int SHOW_PROJECT			= 0x0020;
	static protected final int SHOW_SYNTHETIC		= 0x0040;
	static protected final int SHOW_OFFSET				= 0x0080;
	static protected final int SHOW_ACCESS				= 0x0100;
	static protected final int SHOW_MATCH_KIND	= 0x0200;
	static protected final int SHOW_JAR_FILE			= 0x0400;

	/**
	 * Collects results as a string.
	 */
	public static class JavaSearchResultCollector extends SearchRequestor {
		int flags = SHOW_POTENTIAL; // default
		protected SearchMatch match;
		public StringBuffer results = new StringBuffer(), line;
		public boolean showAccuracy;
		public boolean showSelection;
		public boolean showRule;
		public boolean showInsideDoc;
		public boolean showPotential = true;
		public boolean showProject;
		public boolean showSynthetic;
		public boolean showOffset = false;
		public boolean showAccess = false;
		public int showFlavors = 0;
		public boolean showMatchKind = false;
		public int count = 0;
		List lines = new ArrayList();
		boolean sorted;

			this.count++;
			this.match = searchMatch;
			writeLine();
			if (this.line != null && (this.match.getAccuracy() == SearchMatch.A_ACCURATE || (this.flags & SHOW_POTENTIAL) != 0)) {
				this.lines.add(this.line);
			}
		}

				IResource resource = this.match.getResource();
				IJavaElement element = getElement(this.match);
				this.line = new StringBuffer();
				if ((this.flags & SHOW_MATCH_KIND) != 0) {
					String matchClassName = this.match.getClass().getName();
					this.line.append(matchClassName.substring(matchClassName.lastIndexOf('.')+1));
					this.line.append(": ");
				}
				this.line.append(getPathString(resource, element));
				if ((this.flags & SHOW_PROJECT) != 0) {
					IProject project = element.getJavaProject().getProject();
					this.line.append(" [in ");
					this.line.append(project.getName());

					if (start == -1 || (contents != null && contents.length > 0)) { // retrieving attached source not implemented here
						this.line.append(" [");
						if (start > -1) {
							if ((this.flags & SHOW_SELECTION) != 0) {
								int lineStart1 = CharOperation.lastIndexOf('\n', contents, 0, start);
								int lineStart2 = CharOperation.lastIndexOf('\r', contents, 0, start);
								int lineStart = Math.max(lineStart1, lineStart2) + 1;

								this.line.append("§|");
							}
							this.line.append(CharOperation.subarray(contents, start, end));
							if ((this.flags & SHOW_SELECTION) != 0) {
								this.line.append("|§");
								int lineEnd1 = CharOperation.indexOf('\n', contents, end);
								int lineEnd2 = CharOperation.indexOf('\r', contents, end);

								if (lineEnd == -1) lineEnd = contents.length;
								this.line.append(CharOperation.subarray(contents, end, lineEnd));
							}
							if ((this.flags & SHOW_OFFSET) != 0) {
								this.line.append('@');
								this.line.append(start);
							}

						this.line.append("]");
					}
				}
				if ((this.flags & SHOW_ACCURACY) != 0) {
					this.line.append(" ");
					if (this.match.getAccuracy() == SearchMatch.A_ACCURATE) {
						if ((this.flags & SHOW_RULE) != 0) {
							if (this.match.isExact()) {
								this.line.append("EXACT_");
							} else if (this.match.isEquivalent()) {

						this.line.append("POTENTIAL_MATCH");
					}
				}
				if ((this.flags & SHOW_INSIDE_DOC) != 0) {
					this.line.append(" ");
					if (this.match.isInsideDocComment()) {
						this.line.append("INSIDE_JAVADOC");

						this.line.append("OUTSIDE_JAVADOC");
					}
				}
				if ((this.flags & SHOW_SYNTHETIC) != 0) {
					if (this.match instanceof MethodReferenceMatch) {
						MethodReferenceMatch methRef = (MethodReferenceMatch) this.match;
						if (methRef.isSynthetic()) {

						}
					}
				}
				if ((this.flags & SHOW_ACCESS) != 0) {
					if (this.match instanceof FieldReferenceMatch) {
						FieldReferenceMatch fieldRef = (FieldReferenceMatch) this.match;
						if (fieldRef.isReadAccess()) {

		private boolean showSuperInvocation() {
			return (this.showFlavors & PatternLocator.SUPER_INVOCATION_FLAVOR) != 0;
		}
		public void showAccess() {
			this.flags |= SHOW_ACCESS;
		}
		public void showAccuracy(boolean on) {
			if (on) {
				this.flags |= SHOW_ACCURACY;
			} else {
				this.flags &= ~SHOW_ACCURACY;
			}
		}
		public void showInsideDoc() {
			this.flags |= SHOW_INSIDE_DOC;
		}
		public void showJarFile() {
			this.flags |= SHOW_JAR_FILE;
		}
		public void showMatchKind() {
			this.flags |= SHOW_MATCH_KIND;
		}
		public void showOffset() {
			this.flags |= SHOW_OFFSET;
		}
		public void showPotential(boolean on) {
			if (on) {
				this.flags |= SHOW_POTENTIAL;
			} else {
				this.flags &= ~SHOW_POTENTIAL;
			}
		}
		public void showProject() {
			this.flags |= SHOW_PROJECT;
		}
		public void showRule() {
			this.flags |= SHOW_RULE;
		}
		public void showSelection() {
			this.flags |= SHOW_SELECTION;
		}
		public void showSynthetic() {
			this.flags |= SHOW_SYNTHETIC;
		}
		protected void append(IAnnotation annotation) throws JavaModelException {
			this.line.append("@");
			this.line.append(annotation.getElementName());

			String pathString;
			if (resource != null) {
				IPath path = resource.getProjectRelativePath();
				if ((this.flags & SHOW_JAR_FILE) != 0 && element instanceof Member) {
					IPackageFragmentRoot pkgFragmentRoot = null;
					try {
		                pkgFragmentRoot = element.getJavaProject().findPackageFragmentRoot(resource.getFullPath());
	                } catch (JavaModelException e) {
		                // ignore
	                }
					if (pkgFragmentRoot != null && pkgFragmentRoot.isArchive()) {
						if (pkgFragmentRoot.isExternal()) {
							pathString = pkgFragmentRoot.getPath().toOSString();
						} else {
							pathString = path.toString();
						}
						return pathString + "|" + ((Member)element).getTypeRoot().getElementName();
					}
				}
				if (path.segmentCount() == 0) {
					IJavaElement root = element;
					while (root != null && !(root instanceof IPackageFragmentRoot)) {

Lines 47-54 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchGenericTypeTests.java (-2 / +2 lines)
47		47
48	protected void setUp () throws Exception {	48	protected void setUp () throws Exception {
49	super.setUp();	49	super.setUp();
50	this.resultCollector.showAccuracy = true;	50	this.resultCollector.showAccuracy(true);
51	this.resultCollector.showRule = true;	51	this.resultCollector.showRule();
52	}	52	}
53		53
54	/*	54	/*




		super.setUp();
		this.originalOptions = JAVA_PROJECT.getOptions(true);
		JAVA_PROJECT.setOption(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED);
		this.resultCollector.showAccuracy(true);
		this.resultCollector.showInsideDoc();
	}
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.tests.model.SuiteOfTestCases#tearDownSuite()

	 */
	public void testBug54962() throws CoreException {
		setJavadocOptions();
		this.resultCollector.showInsideDoc();
		this.resultCollector.showSelection();
		IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "j6", "Bug54962.java").getPackageDeclaration("j6");
		search(packDecl, REFERENCES, getJavaSearchScope());
		assertSearchResults(

	//	TODO (frederic) should no longer get POTENTIAL after 196200 got fixed
	public void testBug54962qualified() throws CoreException {
		setJavadocOptions();
		this.resultCollector.showInsideDoc();
		this.resultCollector.showSelection();
		IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "j7.qua.li.fied", "Bug54962a.java").getPackageDeclaration("j7.qua.li.fied");
		search(packDecl, REFERENCES, getJavaSearchScope());
		assertSearchResults(

	 */
	public void testBug71267() throws CoreException {
		setJavadocOptions();
		this.resultCollector.showInsideDoc();
		IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "p71267", "Test.java").getPackageDeclaration("p71267");
		search(packDecl, REFERENCES, getJavaSearchScope());
		assertSearchResults(

	}
	public void testBug71267qualified() throws CoreException {
		setJavadocOptions();
		this.resultCollector.showInsideDoc();
		IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "p71267.q71267", "Test.java").getPackageDeclaration("p71267.q71267");
		search(packDecl, REFERENCES, getJavaSearchScope());
		assertSearchResults(

	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=83285"
	 */
	public void testBug83285() throws CoreException {
		this.resultCollector.showRule();
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/JavaSearch/src/b83285/A.java",
			"package b83285;\n" +

		);
	}
	public void testBug83285a() throws CoreException {
		this.resultCollector.showRule();
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/JavaSearch/src/b83285/A.java",
			"package b83285;\n" +

		);
	}
	public void testBug83285b() throws CoreException {
		this.resultCollector.showRule();
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/JavaSearch/src/b83285/A.java",
			"package b83285;\n" +




	}



	/**
	 * Returns the SourceRange for the name of the given element, or
	 * {-1, -1} if no source range is known for the name of the element.

		return false;
	}

	//***************************************************************

	/**
	 * Locates and returns source code for the given (binary) type, in this
	 * SourceMapper's ZIP file, or returns <code>null</code> if source
	 * code cannot be found.
	 */
	public Object findSourceFile(IType type, IBinaryType info) {
		if (!type.isBinary()) {
			return null;
		}
		String simpleSourceFileName = ((BinaryType) type).getSourceFileName(info);
		if (simpleSourceFileName == null) {
			return null;
		}
		return findSourceFile(type, simpleSourceFileName);
	}

	/**
	 * Locates and returns source code for the given (binary) type, in this
	 * SourceMapper's ZIP file, or returns <code>null</code> if source
	 * code cannot be found.
	 * The given simpleSourceFileName is the .java file name (without the enclosing
	 * folder) used to create the given type (e.g. "A.java" for x/y/A$Inner.class)
	 */
	public Object findSourceFile(IType type, String simpleSourceFileName) {
		long time = 0;
		if (VERBOSE) {
			time = System.currentTimeMillis();
		}
		PackageFragment pkgFrag = (PackageFragment) type.getPackageFragment();
		String name = org.eclipse.jdt.internal.core.util.Util.concatWith(pkgFrag.names, simpleSourceFileName, '/');

		Object sourceFile = null;

		if (this.rootPath != null) {
			sourceFile = getSourceFileForRootPath(this.rootPath, name);
		}

		if (sourceFile == null) {
			computeAllRootPaths(type);
			if (this.rootPaths != null) {
				loop: for (Iterator iterator = this.rootPaths.iterator(); iterator.hasNext(); ) {
					String currentRootPath = (String) iterator.next();
					if (!currentRootPath.equals(this.rootPath)) {
						sourceFile = getSourceFileForRootPath(currentRootPath, name);
						if (sourceFile != null) {
							// remember right root path
							this.rootPath = currentRootPath;
							break loop;
						}
					}
				}
			}
		}
		if (VERBOSE) {
			System.out.println("spent " + (System.currentTimeMillis() - time) + "ms for " + type.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return sourceFile;
	}

	private Object getSourceFileForRootPath(String currentRootPath, String name) {
		String newFullName;
		if (!currentRootPath.equals(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH)) {
			if (currentRootPath.endsWith("/")) { //$NON-NLS-1$
				newFullName = currentRootPath + name;
			} else {
				newFullName = currentRootPath + '/' + name;
			}
		} else {
			newFullName = name;
		}
		return getSourceFile(newFullName);
	}

	private Object getSourceFile(String fullName) {
		Object target = JavaModel.getTarget(this.sourcePath, true);
		if (target instanceof IContainer) {
			IResource res = ((IContainer)target).findMember(fullName);
			if (res instanceof IFile) {
				return res;
			}
		} else {
			// try to get the entry
			ZipEntry entry = null;
			ZipFile zip = null;
			JavaModelManager manager = JavaModelManager.getJavaModelManager();
			try {
				zip = manager.getZipFile(this.sourcePath);
				entry = zip.getEntry(fullName);
				if (entry != null) {
					return entry;
				}
			} catch (CoreException e) {
				return null;
			} finally {
				manager.closeZipFile(zip); // handle null case
			}
		}
		return null;
	}
	
	public ZipFile getSourceZipFile() {
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		try {
			return manager.getZipFile(this.sourcePath);
		} catch (CoreException e) {
			// ignore
		}
		return null;		
	}
	
}





		int newLength = newResolvedClasspath.length;
		int oldLength = this.oldResolvedClasspath.length;
		
		// First, look at removed classpath entries
		for (int i = 0; i < oldLength; i++) {
			int index = classpathContains(newResolvedClasspath, this.oldResolvedClasspath[i]);
			if (index == -1) {

			}
		}

		// Then, look at created or changed classpath entries
		for (int i = 0; i < newLength; i++) {
			IClasspathEntry entry = newResolvedClasspath[i];
			int index = classpathContains(this.oldResolvedClasspath, entry);
			if (index == -1) {
				// remote projects are not indexed in this project
				if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT){
					continue;
				}

				// Request indexing for the removed classpath entry
				int entryKind = entry.getEntryKind();
				switch (entryKind) {
					case IClasspathEntry.CPE_LIBRARY:
						boolean pathHasChanged = true;
						IPath newPath = entry.getPath();
						for (int j = 0; j < oldLength; j++) {
							IClasspathEntry oldEntry = this.oldResolvedClasspath[j];
							if (oldEntry.getPath().equals(newPath)) {

							}
						}
						if (pathHasChanged) {
							indexManager.indexLibrary(entry, this.project);
						}
						break;
					case IClasspathEntry.CPE_SOURCE:
						IClasspathEntry entry = newResolvedClasspath[i];
						IPath path = entry.getPath();
						char[][] inclusionPatterns = ((ClasspathEntry)entry).fullInclusionPatternChars();
						char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();

						break;
				}
			}
			// since bug 12044, source attached are indexed instead of class files
			// hence needs to verify whether the source attachment has changed
			else if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
				IPath srcPath = entry.getSourceAttachmentPath();
				IPath oldSrcPath = this.oldResolvedClasspath[index].getSourceAttachmentPath();
				if (srcPath == null && oldSrcPath != null) {
					indexManager.removeIndex(entry.getPath());
				} else if (srcPath != null && !srcPath.equals(oldSrcPath)) {
					indexManager.indexLibrary(entry, this.project);
				}
			}
		}
	}


Lines 573-579 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRoot.java (+18 lines)
573	*/	573	*/
574	public IPath getSourceAttachmentPath() throws JavaModelException {	574	public IPath getSourceAttachmentPath() throws JavaModelException {
575	if (getKind() != K_BINARY) return null;	575	if (getKind() != K_BINARY) return null;
		576	return sourceAttachmentPath();
		577	}
576		578
		579	/**
		580	* @see IPackageFragmentRoot#getSourceAttachmentRootPath()
		581	* Returns the same result but without opening the package fragment root.
		582	* However, no verification is done on the package fragment root kind, hence
		583	* provides an unpredictable result if it is not a {@link IPackageFragmentRoot#K_BINARY}.
		584	*/
		585	public IPath sourceAttachmentPath() throws JavaModelException {
577	// 1) look source attachment property (set iff attachSource(...) was called	586	// 1) look source attachment property (set iff attachSource(...) was called
578	IPath path = getPath();	587	IPath path = getPath();
579	String serverPathString= Util.getSourceAttachmentProperty(path);	588	String serverPathString= Util.getSourceAttachmentProperty(path);
Lines 618-624 Link Here
618	*/	627	*/
619	public IPath getSourceAttachmentRootPath() throws JavaModelException {	628	public IPath getSourceAttachmentRootPath() throws JavaModelException {
620	if (getKind() != K_BINARY) return null;	629	if (getKind() != K_BINARY) return null;
		630	return sourceAttachmentRootPath();
		631	}
621		632
		633	/**
		634	* @see IPackageFragmentRoot#getSourceAttachmentRootPath()
		635	* Returns the same result but without opening the package fragment root.
		636	* However, no verification is done on the package fragment root kind, hence
		637	* provides an unpredictable result if it is not a {@link IPackageFragmentRoot#K_BINARY}.
		638	*/
		639	public IPath sourceAttachmentRootPath() throws JavaModelException {
622	// 1) look source attachment property (set iff attachSource(...) was called	640	// 1) look source attachment property (set iff attachSource(...) was called
623	IPath path = getPath();	641	IPath path = getPath();
624	String serverPathString= Util.getSourceAttachmentProperty(path);	642	String serverPathString= Util.getSourceAttachmentProperty(path);




				continue;
			}
			for (int j = 0; j < entries.length; j++){
				IClasspathEntry entry = entries[j];
				if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
					IPath entryPath = entry.getPath();

					if (!archivePathsToRefresh.contains(entryPath)) continue; // not supposed to be refreshed


									// first remove the index so that it is forced to be re-indexed
									this.manager.indexManager.removeIndex(entryPath);
									// then index the jar
									this.manager.indexManager.indexLibrary(entry, javaProject);
								} else {
									externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
								}

									externalArchivesStatus.put(entryPath, EXTERNAL_JAR_ADDED);
									this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));
									// index the new jar
									this.manager.indexManager.indexLibrary(entry, javaProject);
								}
							}
						} else { // internal JAR

					switch (delta.getKind()) {
						case IResourceDelta.ADDED:
							// index the new jar
							indexManager.indexPackageFragmentRoot(root);
							break;
						case IResourceDelta.CHANGED:
							// first remove the index so that it is forced to be re-indexed
							indexManager.removeIndex(jarPath);
							// then index the jar
							indexManager.indexPackageFragmentRoot(root);
							break;
						case IResourceDelta.REMOVED:
							// the jar was physically removed: remove the index

Lines 77-83 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/IndexAllProject.java (-1 / +1 lines)
77	if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && entry.getPath().equals(projectPath)) {	77	if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && entry.getPath().equals(projectPath)) {
78	// the project is also a library folder (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89815)	78	// the project is also a library folder (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89815)
79	// ensure a job exists to index it as a binary folder	79	// ensure a job exists to index it as a binary folder
80	this.manager.indexLibrary(projectPath, this.project);	80	this.manager.indexLibrary(entry, javaProject);
81	return true;	81	return true;
82	}	82	}
83	}	83	}




 *******************************************************************************/
package org.eclipse.jdt.internal.core.search.indexing;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Enumeration;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;


import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchParticipant;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.BinaryType;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.PackageFragmentRoot;
import org.eclipse.jdt.internal.core.SourceMapper;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.search.JavaSearchDocument;
import org.eclipse.jdt.internal.core.search.processing.JobManager;
import org.eclipse.jdt.internal.core.util.HashtableOfArrayToObject;

class AddJarFileToIndex extends IndexRequest {

	private static final char JAR_SEPARATOR = IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR.charAt(0);
	IFile resource;
	SourceMapper sourceMapper;
	IPath sourcePath;
	IJavaProject javaProject;
	IPackageFragmentRoot packageFragmentRoot;
	private HashtableOfArrayToObject packageHandles = new HashtableOfArrayToObject();

public AddJarFileToIndex(IFile resource, IndexManager manager) {
	super(resource.getFullPath(), manager);
	this.resource = resource;
}
public AddJarFileToIndex(IPath jarPath, IndexManager manager) {
	// external JAR scenario - no resource
	super(jarPath, manager);
}

private IType createTypeFromJar(String classFilePath) throws JavaModelException {
	String[] simpleNames = new Path(classFilePath).segments();
	String[] pkgName;
	int length = simpleNames.length-1;
	if (length > 0) {
		pkgName = new String[length];
		System.arraycopy(simpleNames, 0, pkgName, 0, length);
	} else {
		pkgName = CharOperation.NO_STRINGS;
	}
	IPackageFragment pkgFragment= (IPackageFragment) this.packageHandles.get(pkgName);
	if (pkgFragment == null) {
		pkgFragment= ((PackageFragmentRoot)this.packageFragmentRoot).getPackageFragment(pkgName);
		this.packageHandles.put(pkgName, pkgFragment);
	}
	return pkgFragment.getClassFile(simpleNames[length]).getType();
}

void setJavaProject(IJavaProject javaProject) {
	this.javaProject = javaProject;
}

void setSourceMapper(IClasspathEntry classpathEntry) {
	this.sourcePath = classpathEntry.getSourceAttachmentPath();
	IPath rootPath = classpathEntry.getSourceAttachmentRootPath();
	if (this.sourcePath != null) {
		Map options = this.javaProject == null
			? JavaCore.getOptions()
			: this.javaProject.getOptions(true);
		this.sourceMapper = new SourceMapper(
			this.sourcePath ,
			rootPath == null ? null : rootPath.toOSString(),
			options);
	}
	if (this.javaProject != null) {
		IPackageFragmentRoot[] roots = this.javaProject.findPackageFragmentRoots(classpathEntry);
		if (roots != null && roots.length == 1) {
			this.packageFragmentRoot = roots[0];
		}
		return false;
	}
}

void setSourceMapper(IPackageFragmentRoot fragmentRoot) {
	this.packageFragmentRoot = fragmentRoot;
	if (this.javaProject == null) {
		this.javaProject = fragmentRoot.getJavaProject();
	}
	try {
		this.sourcePath = ((PackageFragmentRoot)fragmentRoot).sourceAttachmentPath();
		if (this.sourcePath == null) {
			this.sourcePath = fragmentRoot.getPath();
		}
		IPath rootPath = ((PackageFragmentRoot)fragmentRoot).sourceAttachmentRootPath();
		this.sourceMapper = new SourceMapper(
			this.sourcePath,
			rootPath == null ? null : rootPath.toOSString(),
			this.javaProject.getOptions(true));
	} catch (JavaModelException e) {
		// skip
	}
}

public boolean equals(Object o) {
	if (o instanceof AddJarFileToIndex) {
		if (this.resource != null)
			return this.resource.equals(((AddJarFileToIndex) o).resource);
		if (this.containerPath != null)
			return this.containerPath.equals(((AddJarFileToIndex) o).containerPath);
		return -1;
	}
	return false;
}
public int hashCode() {
	if (this.resource != null)
		return this.resource.hashCode();
	if (this.containerPath != null)
		return this.containerPath.hashCode();
	return -1;
}
public boolean execute(IProgressMonitor progressMonitor) {

	if (this.isCancelled || progressMonitor != null && progressMonitor.isCanceled()) return true;

	try {
		// if index is already cached, then do not perform any check
		// MUST reset the IndexManager if a jar file is changed
		Index index = this.manager.getIndexForUpdate(this.containerPath, false, /*do not reuse index file*/ false /*do not create if none*/);
		if (index != null) {
			if (JobManager.VERBOSE)
				org.eclipse.jdt.internal.core.util.Util.verbose("-> no indexing required (index already exists) for " + this.containerPath); //$NON-NLS-1$
			return true;
		}

		index = this.manager.getIndexForUpdate(this.containerPath, true, /*reuse index file*/ true /*create if none*/);
		if (index == null) {
			if (JobManager.VERBOSE)
				org.eclipse.jdt.internal.core.util.Util.verbose("-> index could not be created for " + this.containerPath); //$NON-NLS-1$
			return true;
		}
		ReadWriteMonitor monitor = index.monitor;
		if (monitor == null) {
			if (JobManager.VERBOSE)
				org.eclipse.jdt.internal.core.util.Util.verbose("-> index for " + this.containerPath + " just got deleted"); //$NON-NLS-1$//$NON-NLS-2$
			return true; // index got deleted since acquired
		}
		index.separator = JAR_SEPARATOR;
		ZipFile zip = null;
		ZipFile sourceZip = null;
		JavaModelManager modelManager = JavaModelManager.getJavaModelManager();
		modelManager.cacheZipFiles();
		try {
			// this path will be a relative path to the workspace in case the zipfile in the workspace otherwise it will be a path in the
			// local file system
			Path zipFilePath = null;

			monitor.enterWrite(); // ask permission to write
			if (this.resource != null) {
				IPath resourcePath = this.resource.getFullPath();
				if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Creating ZipFile on " + resourcePath); //$NON-NLS-1$	//$NON-NLS-2$
				}
				try {
					zip = modelManager.getZipFile(resourcePath);
				} catch (CoreException ce) {
					if (JobManager.VERBOSE) {
						org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + resourcePath + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$
						ce.printStackTrace();
					}
					return false;
				}
				zipFilePath = (Path) resourcePath.makeRelative();
				// absolute path relative to the workspace

				// Get package fragment root if not already stored
				if (this.packageFragmentRoot == null) {
					IJavaElement javaElement = JavaCore.create(this.resource, this.javaProject);
					if (javaElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
						this.packageFragmentRoot = (IPackageFragmentRoot) javaElement;
					}
				}
			} else {
				if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Creating ZipFile on " + this.containerPath); //$NON-NLS-1$	//$NON-NLS-2$
				}
				try {
					zip = modelManager.getZipFile(this.containerPath);
				} catch (CoreException ce) {
					if (JobManager.VERBOSE) {
						org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + this.containerPath + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$
						ce.printStackTrace();
					}
					return false;
				}
				zipFilePath = (Path) this.containerPath;
				// path is already canonical since coming from a library classpath entry
			}

			if (this.isCancelled) {
				if (JobManager.VERBOSE)
					org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing of " + zip.getName() + " has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$
				return false;
			}

			if (JobManager.VERBOSE)
				org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing " + zip.getName()); //$NON-NLS-1$
			long initialTime = System.currentTimeMillis();

			String[] paths = index.queryDocumentNames(""); // all file names //$NON-NLS-1$
			if (paths != null) {
				int max = paths.length;
				/* check integrity of the existing index file
				 * if the length is equal to 0, we want to index the whole jar again
				 * If not, then we want to check that there is no missing entry, if
				 * one entry is missing then we recreate the index
				 */
				String EXISTS = "OK"; //$NON-NLS-1$
				String DELETED = "DELETED"; //$NON-NLS-1$
				SimpleLookupTable indexedFileNames = new SimpleLookupTable(max == 0 ? 33 : max + 11);
				for (int i = 0; i < max; i++)
					indexedFileNames.put(paths[i], DELETED);
				for (Enumeration e = zip.entries(); e.hasMoreElements();) {
					// iterate each entry to index it
					ZipEntry ze = (ZipEntry) e.nextElement();
					String zipEntryName = ze.getName();
					if (Util.isClassFileName(zipEntryName))
						indexedFileNames.put(zipEntryName, EXISTS);
				}
				boolean needToReindex = indexedFileNames.elementSize != max; // a new file was added
				if (!needToReindex) {
					Object[] valueTable = indexedFileNames.valueTable;
					for (int i = 0, l = valueTable.length; i < l; i++) {
						if (valueTable[i] == DELETED) {
							needToReindex = true; // a file was deleted so re-index
							break;
						}
					}
					if (!needToReindex) {
						if (JobManager.VERBOSE)
							org.eclipse.jdt.internal.core.util.Util.verbose("-> no indexing required (index is consistent with library) for " //$NON-NLS-1$
							+ zip.getName() + " (" //$NON-NLS-1$
							+ (System.currentTimeMillis() - initialTime) + "ms)"); //$NON-NLS-1$
						this.manager.saveIndex(index); // to ensure its placed into the saved state
						return true;
					}
					zip = new ZipFile(file);
					zipFilePath = (Path) this.resource.getFullPath().makeRelative();
					// absolute path relative to the workspace
				} else {
					if (JavaModelManager.ZIP_ACCESS_VERBOSE)
						System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Creating ZipFile on " + this.containerPath); //$NON-NLS-1$	//$NON-NLS-2$
					// external file -> it is ok to use toFile()
					zip = new ZipFile(this.containerPath.toFile());
					zipFilePath = (Path) this.containerPath;
					// path is already canonical since coming from a library classpath entry
				}

				if (this.isCancelled) {
					if (JobManager.VERBOSE)
						org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing of " + zip.getName() + " has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$
					return false;
				}
			}

			// Index the jar for the first time or reindex the jar in case the previous index file has been corrupted
			// index already existed: recreate it so that we forget about previous entries
			SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
			index = this.manager.recreateIndex(this.containerPath);
			if (index == null) {
				// failed to recreate index, see 73330
				this.manager.removeIndex(this.containerPath);
				return false;
			}
			index.separator = JAR_SEPARATOR;

			if (this.sourcePath != null) {
				index.sourcePath = this.sourcePath.toString();
				try {
					sourceZip = modelManager.getZipFile(this.sourcePath);	
				} catch (CoreException ce) {
					// ignore
				}
			}
			// Need a special way to get sources when they are in the jar itself
			if (zip != null && zip == sourceZip) {
				ZipEntry[] zipEntries = new ZipEntry[10];
				int stackPtr = -1;
				String previousFileName = null;
				for (Enumeration e = zip.entries(); e.hasMoreElements();) {
					if (this.isCancelled) {
						if (JobManager.VERBOSE)
							org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing of " + zip.getName() + " has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$
						return false;
							indexedFileNames.put(zipEntryName, EXISTS);
					}

					// iterate each entry to index it
					ZipEntry ze = (ZipEntry) e.nextElement();
					String zeName = ze.getName();
					if (Util.isClassFileName(zeName)) {
						String fileName = zeName.substring(0, zeName.length()-SuffixConstants.SUFFIX_CLASS.length);
						if (previousFileName != null && !(previousFileName.startsWith(fileName) && previousFileName.charAt(fileName.length()) == '$')) {
							// no source was found for previous class file name => index it now and all member classes as well
							while (stackPtr >= 0) {
								ZipEntry previousEntry = zipEntries[stackPtr--];
								String previousEntryName = previousEntry.getName();
								if (!previousEntryName.startsWith(previousFileName) && previousEntryName.charAt(fileName.length()) != '$') break;
								final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(previousEntry, zip);
								JavaSearchDocument searchDocument = new JavaSearchDocument(previousEntry, zipFilePath, classFileBytes, participant);
								this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
							}
						}
						previousFileName = fileName;

						int length = zipEntries.length;
						if (++stackPtr == length) {
							// resize (should seldom occur as happen only when local class depth is over 10!
							System.arraycopy(zipEntries, 0, zipEntries = new ZipEntry[length + (length>>1)], 0, length);
							return true;
						}
						zipEntries[stackPtr] = ze;
					}
					else if (Util.isJavaFileName(zeName) && zeName.startsWith(previousFileName) && zeName.length() == (previousFileName.length()+SuffixConstants.SUFFIX_java.length)) {
						// this is the source file of previous class files => index it
						JavaSearchDocument searchDocument = new JavaSearchDocument(zipEntries[stackPtr], zipFilePath, ze, sourceZip, this.sourcePath, participant);
						this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
						stackPtr = -1; // flush entries stack
						previousFileName = null;
					}
				}

				// index remaining class files if any
				while (stackPtr >= 0) {
					ZipEntry previousEntry = zipEntries[stackPtr--];
					final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(previousEntry, zip);
					JavaSearchDocument searchDocument = new JavaSearchDocument(previousEntry, zipFilePath, classFileBytes, participant);
					this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
					this.manager.removeIndex(this.containerPath);
					return false;
				}
			} else {
				IFile previousSourceFile = null;
				ZipEntry previousZipEntry = null;
				ZipEntry previousSourceZipEntry = null;
				for (Enumeration e = zip.entries(); e.hasMoreElements();) {
					if (this.isCancelled) {
						if (JobManager.VERBOSE)


					// iterate each entry to index it
					ZipEntry ze = (ZipEntry) e.nextElement();
					String zeName = ze.getName();
					if (Util.isClassFileName(zeName)) {
						IFile sourceFile = null;
						ZipEntry sourceZipEntry = null;

						if (this.sourcePath != null) {
							IType type = null;
							try {
								if (this.packageFragmentRoot != null) {
									type = createTypeFromJar(zeName);
								}
							} catch (JavaModelException jme) {
								// ignore
							}
							if (type != null) {
								String sourceName = ((BinaryType) type).getSourceFileName(null);
								Object mappedSource = this.sourceMapper.findSourceFile(type, sourceName);
								if (mappedSource != null) {
									if (mappedSource instanceof IFile) {
										sourceFile = (IFile)mappedSource;
									} else {
										sourceZipEntry = (ZipEntry) mappedSource;
									}
								}
							}
						}
						if (sourceFile != null) {
							if (previousSourceFile != null && !sourceFile.equals(previousSourceFile)) {
								JavaSearchDocument searchDocument = new JavaSearchDocument(ze, zipFilePath, previousSourceFile, this.sourcePath, participant);
								this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
							}
							previousSourceFile = sourceFile;
						} else if (sourceZipEntry != null) {
							if (previousSourceZipEntry != null && !sourceZipEntry.getName().equals(previousSourceZipEntry.getName())) {
								JavaSearchDocument searchDocument = new JavaSearchDocument(previousZipEntry, zipFilePath, previousSourceZipEntry, sourceZip, this.sourcePath, participant);
								this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
							}
							previousSourceZipEntry = sourceZipEntry;
						} else {
							final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
							JavaSearchDocument searchDocument = new JavaSearchDocument(ze, zipFilePath, classFileBytes, participant);
							this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
						}
						previousZipEntry = ze;
					}
				}

				// index the remaining source file/zip entry if any
				if (previousZipEntry != null && (previousSourceFile != null || previousSourceZipEntry != null)) {
					JavaSearchDocument searchDocument = previousSourceFile != null
						? new JavaSearchDocument(previousZipEntry, zipFilePath, previousSourceFile, this.sourcePath, participant)
						: new JavaSearchDocument(previousZipEntry, zipFilePath, previousSourceZipEntry, sourceZip, this.sourcePath, participant);
					this.manager.indexDocument(searchDocument, participant, index, this.containerPath);
				}
						System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Closing ZipFile " + zip); //$NON-NLS-1$	//$NON-NLS-2$
					zip.close();
				}
				monitor.exitWrite(); // free write lock
			}
		} catch (IOException e) {
			if (JobManager.VERBOSE) {
				org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + this.containerPath + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$
				e.printStackTrace();
			}
			this.manager.saveIndex(index);
			if (JobManager.VERBOSE)
				org.eclipse.jdt.internal.core.util.Util.verbose("-> done indexing of " //$NON-NLS-1$
					+ zip.getName() + " (" //$NON-NLS-1$
					+ (System.currentTimeMillis() - initialTime) + "ms)"); //$NON-NLS-1$
		} finally {
			modelManager.flushZipFiles();
//			if (zip != null) {
//				if (JavaModelManager.ZIP_ACCESS_VERBOSE)
//					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Closing ZipFile " + zip); //$NON-NLS-1$	//$NON-NLS-2$
//				zip.close();
//			}
			monitor.exitWrite(); // free write lock
		}
	} catch (IOException e) {
		if (JobManager.VERBOSE) {
			org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + this.containerPath + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$
			e.printStackTrace();
		}
		this.manager.removeIndex(this.containerPath);
		return false;
	protected Integer updatedIndexState() {
		return IndexManager.REBUILDING_STATE;
	}
	public String toString() {
		return "indexing " + this.containerPath.toString(); //$NON-NLS-1$
	}
	return true;
}
public String getJobFamily() {
	if (this.resource != null)
		return super.getJobFamily();
	return this.containerPath.toOSString(); // external jar
}
protected Integer updatedIndexState() {
	return IndexManager.REBUILDING_STATE;
}
public String toString() {
	return "indexing " + this.containerPath.toString(); //$NON-NLS-1$
}
}




import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.search.JavaSearchDocument;
import org.eclipse.jdt.internal.core.util.Util;

public class BinaryIndexer extends AbstractIndexer implements SuffixConstants {

			final byte[] contents = this.document.getByteContents();
			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=107124
			// contents can potentially be null if a IOException occurs while retrieving the contents
			if (contents == null) {
				// See if there's some source attached
				if (this.document instanceof JavaSearchDocument) {
					JavaSearchDocument javaSearchDocument = (JavaSearchDocument) this.document;
					if (javaSearchDocument.sourcePath != null) {
						char[] source = javaSearchDocument.getCharContents();
						if (source.length != 0) {
							// the source exists, then prefer to index it instead of the class file
							SourceIndexer sourceIndexer = new SourceIndexer(this.document);
							sourceIndexer.indexDocument();
						}
					}
				}
				return;
			}
			final String path = this.document.getPath();
			ClassFileReader reader = new ClassFileReader(contents, path == null ? null : path.toCharArray());





		for (int i = 0; i < entries.length; i++) {
			IClasspathEntry entry= entries[i];
			if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
				indexLibrary(entry, javaProject);
		}
	} catch(JavaModelException e){ // cannot retrieve classpath info
	}

 * Trigger addition of a library to an index
 * Note: the actual operation is performed in background
 */
public void indexLibrary(IClasspathEntry classpathEntry, IJavaProject requestingProject) {

	// Otherwise index it as a jar file
	IPath path = classpathEntry.getPath();
	IndexRequest request = indexLibraryRequest(path);
	if (request == null) 	return;
	if (request instanceof AddJarFileToIndex) {
		AddJarFileToIndex jarFileRequest = (AddJarFileToIndex) request;
		jarFileRequest.setJavaProject(requestingProject);
		jarFileRequest.setSourceMapper(classpathEntry);
	}
	if (!isJobWaiting(request)) {
		request(request);
	}
}
public void indexPackageFragmentRoot(IPackageFragmentRoot fragmentRoot) {
	IPath path = fragmentRoot.getPath();
	IndexRequest request = indexLibraryRequest(path);
	if (request == null) 	return;
	if (request instanceof AddJarFileToIndex) {
		AddJarFileToIndex jarFileRequest = (AddJarFileToIndex) request;
		jarFileRequest.setSourceMapper(fragmentRoot);
	}
	if (!isJobWaiting(request)) {
		request(request);
	}
}
private IndexRequest indexLibraryRequest(IPath path) {
	// requestingProject is no longer used to cancel jobs but leave it here just in case
	if (JavaCore.getPlugin() == null) return null;

	Object target = JavaModel.getTarget(path, true);
	IndexRequest request = null;
	if (target instanceof IFile) {
		request = new AddJarFileToIndex((IFile) target, this);
	} else if (target instanceof File) {
		request = new AddJarFileToIndex(path, this);
	} else if (target instanceof IContainer) {
		request = new IndexBinaryFolder((IContainer) target, this);
	}
	return request;
}
/**
 * Trigger addition of a library to an index
 * Note: the actual operation is performed in background
 */
public void indexLibrary(IPath path, IProject requestingProject) {
	// requestingProject is no longer used to cancel jobs but leave it here just in case
	if (JavaCore.getPlugin() == null) return;




			int separatorIndex= path.indexOf(IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR);
			type = separatorIndex == -1
				? createTypeFromPath(path, new String(simpleTypeName), enclosingTypeNames)
				: createTypeFromJar(path, separatorIndex, new String(simpleTypeName), enclosingTypeNames); // need to provide simpleTypeName and enclosing type names when the type has been found in attached source!
		}
		if (type != null) {
			this.requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, modifiers));

		// skip
	}
}
private IType createTypeFromJar(String resourcePath, int separatorIndex, String simpleTypeName, char[][] enclosingTypeNames) throws JavaModelException {
	// path to a class file inside a jar
	// Optimization: cache package fragment root handle and package handles
	if (this.lastPkgFragmentRootPath == null

		pkgFragment= ((PackageFragmentRoot) this.lastPkgFragmentRoot).getPackageFragment(pkgName);
		this.packageHandles.put(pkgName, pkgFragment);
	}
	String simpleName= simpleNames[length];
	IClassFile classFile= pkgFragment.getClassFile(simpleName);
	IType type = classFile.getType();
	int etnLength = enclosingTypeNames == null ? 0 : enclosingTypeNames.length;
	if (etnLength > 0) {
		if (etnLength > 0) {
			for (int i=1; i<etnLength; i++) {
				type = type.getType(new String(enclosingTypeNames[i]));
			}
			type = type.getType(simpleTypeName);
		}
	}
	return type;
//	return pkgFragment.getClassFile(simpleNames[length]).getType();
}
private IType createTypeFromPath(String resourcePath, String simpleTypeName, char[][] enclosingTypeNames) throws JavaModelException {
	// path to a file in a directory

Lines 10-15 Link Here

(-)search/org/eclipse/jdt/internal/core/search/JavaSearchDocument.java (-8 / +59 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core.search;	11	package org.eclipse.jdt.internal.core.search;
12		12
		13	import java.io.IOException;
		14	import java.util.zip.ZipEntry;
		15	import java.util.zip.ZipFile;
		16
13	import org.eclipse.core.resources.IFile;	17	import org.eclipse.core.resources.IFile;
14	import org.eclipse.core.resources.ResourcesPlugin;	18	import org.eclipse.core.resources.ResourcesPlugin;
15	import org.eclipse.core.runtime.CoreException;	19	import org.eclipse.core.runtime.CoreException;
Lines 26-32 Link Here
26		30
27	private IFile file;	31	private IFile file;
28	protected byte[] byteContents;	32	protected byte[] byteContents;
29	protected char[] charContents;	33	public char[] charContents;
		34	public ZipFile sourceZip;
		35	public ZipEntry sourceEntry;
		36	public IPath sourcePath;
30		37
31	public JavaSearchDocument(String documentPath, SearchParticipant participant) {	38	public JavaSearchDocument(String documentPath, SearchParticipant participant) {
32	super(documentPath, participant);	39	super(documentPath, participant);
Lines 35-43 Link Here
35	super(zipFilePath + IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR + zipEntry.getName(), participant);	42	super(zipFilePath + IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR + zipEntry.getName(), participant);
36	this.byteContents = contents;	43	this.byteContents = contents;
37	}	44	}
		45	public JavaSearchDocument(ZipEntry ze, Path zipFilePath, IFile file, IPath srcPath, SearchParticipant participant) {
		46	this(ze, zipFilePath, (byte[]) null, participant);
		47	this.file = file;
		48	this.sourcePath = srcPath;
		49	}
		50	public JavaSearchDocument(ZipEntry ze, Path zipFilePath, ZipEntry se, ZipFile zip, IPath srcPath, SearchParticipant participant) {
		51	this(ze, zipFilePath, (byte[]) null, participant);
		52	this.sourceEntry = se;
		53	this.sourceZip = zip;
		54	this.sourcePath = srcPath;
		55	}
38		56
39	public byte[] getByteContents() {	57	public byte[] getByteContents() {
40	if (this.byteContents != null) return this.byteContents;	58	if (this.byteContents != null) return this.byteContents;
		59	if (this.sourcePath != null) {
		60	// try to initialize source contents instead
		61	if (getCharContents() != null) return null;
		62	}
41	try {	63	try {
42	return Util.getResourceContentsAsByteArray(getFile());	64	return Util.getResourceContentsAsByteArray(getFile());
43	} catch (JavaModelException e) {	65	} catch (JavaModelException e) {
Lines 48-62 Link Here
48	}	70	}
49	}	71	}
50	public char[] getCharContents() {	72	public char[] getCharContents() {
51	if (this.charContents != null) return this.charContents;	73	if (this.charContents == null) {
52	try {	74	// The source may be found through an attachment
53	return Util.getResourceContentsAsCharArray(getFile());	75	if (this.sourcePath != null) {
54	} catch (JavaModelException e) {	76	// a zip entry in an attached source zip
55	if (BasicSearchEngine.VERBOSE \|\| JobManager.VERBOSE) { // used during search and during indexing	77	if (this.sourceEntry != null) {
56	e.printStackTrace();	78	try {
		79	byte[] bytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(this.sourceEntry, this.sourceZip);
		80	if (bytes != null) {
		81	return this.charContents = org.eclipse.jdt.internal.compiler.util.Util.bytesToChar(bytes, null);
		82	}
		83	} catch (IOException e) {
		84	// ignore
		85	}
		86	this.sourceEntry = null; // avoid to read it again
		87	return null;
		88	}
		89	if (this.file != null) {
		90	try {
		91	return this.charContents = Util.getResourceContentsAsCharArray(this.file);
		92	} catch (JavaModelException e) {
		93	if (BasicSearchEngine.VERBOSE \|\| JobManager.VERBOSE) { // used during search and during indexing
		94	e.printStackTrace();
		95	}
		96	}
		97	this.file = null; // avoid to read it again
		98	return null;
		99	}
		100	} else {
		101	try {
		102	return Util.getResourceContentsAsCharArray(getFile());
		103	} catch (JavaModelException e) {
		104	if (BasicSearchEngine.VERBOSE \|\| JobManager.VERBOSE) { // used during search and during indexing
		105	e.printStackTrace();
		106	}
		107	}
57	}	108	}
58	return null;
59	}	109	}
		110	return this.charContents;
60	}	111	}
61	public String getEncoding() {	112	public String getEncoding() {
62	// Return the encoding of the associated file	113	// Return the encoding of the associated file

Lines 2470-2476 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java (-1 / +6 lines)
2470	} else if (enclosingElement instanceof IMember) {	2470	} else if (enclosingElement instanceof IMember) {
2471	IMember member = (IMember) parent;	2471	IMember member = (IMember) parent;
2472	if (member.isBinary()) {	2472	if (member.isBinary()) {
2473	enclosingElement = ((IClassFile)this.currentPossibleMatch.openable).getType();	2473	IType topLevelType = ((IClassFile)this.currentPossibleMatch.openable).getType();
		2474	if (type.name.equals(topLevelType.getElementName())) {
		2475	enclosingElement = topLevelType;
		2476	} else {
		2477	enclosingElement = topLevelType.getType(new String(type.name));
		2478	}
2474	} else {	2479	} else {
2475	enclosingElement = member.getType(new String(type.name), occurrenceCount);	2480	enclosingElement = member.getType(new String(type.name), occurrenceCount);
2476	}	2481	}

Lines 29-34 Link Here

(-)search/org/eclipse/jdt/internal/core/index/Index.java (+4 lines)
29	public class Index {	29	public class Index {
30		30
31	public String containerPath;	31	public String containerPath;
		32	public String sourcePath;
32	public ReadWriteMonitor monitor;	33	public ReadWriteMonitor monitor;
33		34
34	// Separator to use after the container path	35	// Separator to use after the container path
Lines 102-107 Link Here
102	public String containerRelativePath(String documentPath) {	103	public String containerRelativePath(String documentPath) {
103	int index = documentPath.indexOf(IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR);	104	int index = documentPath.indexOf(IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR);
104	if (index == -1) {	105	if (index == -1) {
		106	if (this.sourcePath != null) {
		107	return documentPath;
		108	}
105	index = this.containerPath.length();	109	index = this.containerPath.length();
106	if (documentPath.length() <= index)	110	if (documentPath.length() <= index)
107	throw new IllegalArgumentException("Document path " + documentPath + " must be relative to " + this.containerPath); //$NON-NLS-1$ //$NON-NLS-2$	111	throw new IllegalArgumentException("Document path " + documentPath + " must be relative to " + this.containerPath); //$NON-NLS-1$ //$NON-NLS-2$

Lines 655-660 Link Here

(-)src/org/eclipse/jdt/core/tests/performance/FullSourceWorkspaceTests.java (+1 lines)
655	if (jdkLib == null) {	655	if (jdkLib == null) {
656	throw new RuntimeException("Cannot set JRE_LIB classpath variable as the rt.jar lib was not found!!!");	656	throw new RuntimeException("Cannot set JRE_LIB classpath variable as the rt.jar lib was not found!!!");
657	}	657	}
		658	JavaCore.setClasspathVariable("JRE_LIB", new Path(jdkLib), null);
658		659
659	// Set classpaths (workaround bug 73253 Project references not set on project open)	660	// Set classpaths (workaround bug 73253 Project references not set on project open)
660	System.out.print("Set projects classpaths...");	661	System.out.print("Set projects classpaths...");

Lines 245-251 Link Here

(-)src/org/eclipse/jdt/core/tests/performance/FullSourceWorkspaceSearchTests.java (-1 / +1 lines)
245	/**	245	/**
246	* Performance tests for search: Indexing one project (JDT/Core).	246	* Performance tests for search: Indexing one project (JDT/Core).
247	*/	247	*/
248	public void testIndexingOneProject() throws CoreException {	248	public void testONLY_IndexingOneProject() throws CoreException {
249	tagAsSummary("Indexing JDT/Core project", true); // put in fingerprint	249	tagAsSummary("Indexing JDT/Core project", true); // put in fingerprint
250		250
251	// Warm-up	251	// Warm-up

Return to bug 12044

Lines 934-940 Link Here

(-)model/org/eclipse/jdt/internal/core/SourceMapper.java (-1 / +112 lines)
934	}	934	}
935		935
936		936
937
938	/**	937	/**
939	* Returns the SourceRange for the name of the given element, or	938	* Returns the SourceRange for the name of the given element, or
940	* {-1, -1} if no source range is known for the name of the element.	939	* {-1, -1} if no source range is known for the name of the element.
Lines 1327-1330 Link Here
1327	return false;	1326	return false;
1328	}	1327	}
1329		1328
		1329	//***************************************************************
		1330
		1331	/**
		1332	* Locates and returns source code for the given (binary) type, in this
		1333	* SourceMapper's ZIP file, or returns <code>null</code> if source
		1334	* code cannot be found.
		1335	*/
		1336	public Object findSourceFile(IType type, IBinaryType info) {
		1337	if (!type.isBinary()) {
		1338	return null;
		1339	}
		1340	String simpleSourceFileName = ((BinaryType) type).getSourceFileName(info);
		1341	if (simpleSourceFileName == null) {
		1342	return null;
		1343	}
		1344	return findSourceFile(type, simpleSourceFileName);
		1345	}
		1346
		1347	/**
		1348	* Locates and returns source code for the given (binary) type, in this
		1349	* SourceMapper's ZIP file, or returns <code>null</code> if source
		1350	* code cannot be found.
		1351	* The given simpleSourceFileName is the .java file name (without the enclosing
		1352	* folder) used to create the given type (e.g. "A.java" for x/y/A$Inner.class)
		1353	*/
		1354	public Object findSourceFile(IType type, String simpleSourceFileName) {
		1355	long time = 0;
		1356	if (VERBOSE) {
		1357	time = System.currentTimeMillis();
		1358	}
		1359	PackageFragment pkgFrag = (PackageFragment) type.getPackageFragment();
		1360	String name = org.eclipse.jdt.internal.core.util.Util.concatWith(pkgFrag.names, simpleSourceFileName, '/');
		1361
		1362	Object sourceFile = null;
		1363
		1364	if (this.rootPath != null) {
		1365	sourceFile = getSourceFileForRootPath(this.rootPath, name);
		1366	}
		1367
		1368	if (sourceFile == null) {
		1369	computeAllRootPaths(type);
		1370	if (this.rootPaths != null) {
		1371	loop: for (Iterator iterator = this.rootPaths.iterator(); iterator.hasNext(); ) {
		1372	String currentRootPath = (String) iterator.next();
		1373	if (!currentRootPath.equals(this.rootPath)) {
		1374	sourceFile = getSourceFileForRootPath(currentRootPath, name);
		1375	if (sourceFile != null) {
		1376	// remember right root path
		1377	this.rootPath = currentRootPath;
		1378	break loop;
		1379	}
		1380	}
		1381	}
		1382	}
		1383	}
		1384	if (VERBOSE) {
		1385	System.out.println("spent " + (System.currentTimeMillis() - time) + "ms for " + type.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$
		1386	}
		1387	return sourceFile;
		1388	}
		1389
		1390	private Object getSourceFileForRootPath(String currentRootPath, String name) {
		1391	String newFullName;
		1392	if (!currentRootPath.equals(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH)) {
1393	if (currentRootPath.endsWith("/")) { //$NON-NLS-1$
1394	newFullName = currentRootPath + name;
1395	} else {
1396	newFullName = currentRootPath + '/' + name;
1397	}
1398	} else {
1399	newFullName = name;
1400	}
1401	return getSourceFile(newFullName);
1402	}
1403
1404	private Object getSourceFile(String fullName) {
1405	Object target = JavaModel.getTarget(this.sourcePath, true);
1406	if (target instanceof IContainer) {
1407	IResource res = ((IContainer)target).findMember(fullName);
1408	if (res instanceof IFile) {
1409	return res;
1410	}
1411	} else {
1412	// try to get the entry
1413	ZipEntry entry = null;
1414	ZipFile zip = null;
1415	JavaModelManager manager = JavaModelManager.getJavaModelManager();
1416	try {
1417	zip = manager.getZipFile(this.sourcePath);
1418	entry = zip.getEntry(fullName);
1419	if (entry != null) {
1420	return entry;
1421	}
1422	} catch (CoreException e) {
1423	return null;
1424	} finally {
1425	manager.closeZipFile(zip); // handle null case
1426	}
1427	}
1428	return null;
1429	}
1430
1431	public ZipFile getSourceZipFile() {
1432	JavaModelManager manager = JavaModelManager.getJavaModelManager();
1433	try {
1434	return manager.getZipFile(this.sourcePath);
1435	} catch (CoreException e) {
1436	// ignore
1437	}
1438	return null;
1439	}
1440
1330	}	1441	}

Lines 457-462 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathChange.java (-7 / +21 lines)
457		457
458	int newLength = newResolvedClasspath.length;	458	int newLength = newResolvedClasspath.length;
459	int oldLength = this.oldResolvedClasspath.length;	459	int oldLength = this.oldResolvedClasspath.length;
		460
		461	// First, look at removed classpath entries
460	for (int i = 0; i < oldLength; i++) {	462	for (int i = 0; i < oldLength; i++) {
461	int index = classpathContains(newResolvedClasspath, this.oldResolvedClasspath[i]);	463	int index = classpathContains(newResolvedClasspath, this.oldResolvedClasspath[i]);
462	if (index == -1) {	464	if (index == -1) {
Lines 487-506 Link Here
487	}	489	}
488	}	490	}
489		491
		492	// Then, look at created or changed classpath entries
490	for (int i = 0; i < newLength; i++) {	493	for (int i = 0; i < newLength; i++) {
491	int index = classpathContains(this.oldResolvedClasspath, newResolvedClasspath[i]);	494	IClasspathEntry entry = newResolvedClasspath[i];
		495	int index = classpathContains(this.oldResolvedClasspath, entry);
492	if (index == -1) {	496	if (index == -1) {
493	// remote projects are not indexed in this project	497	// remote projects are not indexed in this project
494	if (newResolvedClasspath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){	498	if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT){
495	continue;	499	continue;
496	}	500	}
497		501
498	// Request indexing	502	// Request indexing for the removed classpath entry
499	int entryKind = newResolvedClasspath[i].getEntryKind();	503	int entryKind = entry.getEntryKind();
500	switch (entryKind) {	504	switch (entryKind) {
501	case IClasspathEntry.CPE_LIBRARY:	505	case IClasspathEntry.CPE_LIBRARY:
502	boolean pathHasChanged = true;	506	boolean pathHasChanged = true;
503	IPath newPath = newResolvedClasspath[i].getPath();	507	IPath newPath = entry.getPath();
504	for (int j = 0; j < oldLength; j++) {	508	for (int j = 0; j < oldLength; j++) {
505	IClasspathEntry oldEntry = this.oldResolvedClasspath[j];	509	IClasspathEntry oldEntry = this.oldResolvedClasspath[j];
506	if (oldEntry.getPath().equals(newPath)) {	510	if (oldEntry.getPath().equals(newPath)) {
Lines 509-519 Link Here
509	}	513	}
510	}	514	}
511	if (pathHasChanged) {	515	if (pathHasChanged) {
512	indexManager.indexLibrary(newPath, this.project.getProject());	516	indexManager.indexLibrary(entry, this.project);
513	}	517	}
514	break;	518	break;
515	case IClasspathEntry.CPE_SOURCE:	519	case IClasspathEntry.CPE_SOURCE:
516	IClasspathEntry entry = newResolvedClasspath[i];
517	IPath path = entry.getPath();	520	IPath path = entry.getPath();
518	char[][] inclusionPatterns = ((ClasspathEntry)entry).fullInclusionPatternChars();	521	char[][] inclusionPatterns = ((ClasspathEntry)entry).fullInclusionPatternChars();
519	char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();	522	char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();
Lines 521-526 Link Here
521	break;	524	break;
522	}	525	}
523	}	526	}
		527	// since bug 12044, source attached are indexed instead of class files
		528	// hence needs to verify whether the source attachment has changed
		529	else if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
		530	IPath srcPath = entry.getSourceAttachmentPath();
		531	IPath oldSrcPath = this.oldResolvedClasspath[index].getSourceAttachmentPath();
		532	if (srcPath == null && oldSrcPath != null) {
		533	indexManager.removeIndex(entry.getPath());
		534	} else if (srcPath != null && !srcPath.equals(oldSrcPath)) {
		535	indexManager.indexLibrary(entry, this.project);
		536	}
		537	}
524	}	538	}
525	}	539	}
526		540

Lines 862-869 Link Here

(-)model/org/eclipse/jdt/internal/core/DeltaProcessor.java (-6 / +7 lines)
862	continue;	862	continue;
863	}	863	}
864	for (int j = 0; j < entries.length; j++){	864	for (int j = 0; j < entries.length; j++){
865	if (entries[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {	865	IClasspathEntry entry = entries[j];
866	IPath entryPath = entries[j].getPath();	866	if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
		867	IPath entryPath = entry.getPath();
867		868
868	if (!archivePathsToRefresh.contains(entryPath)) continue; // not supposed to be refreshed	869	if (!archivePathsToRefresh.contains(entryPath)) continue; // not supposed to be refreshed
869		870
Lines 902-908 Link Here
902	// first remove the index so that it is forced to be re-indexed	903	// first remove the index so that it is forced to be re-indexed
903	this.manager.indexManager.removeIndex(entryPath);	904	this.manager.indexManager.removeIndex(entryPath);
904	// then index the jar	905	// then index the jar
905	this.manager.indexManager.indexLibrary(entryPath, project.getProject());	906	this.manager.indexManager.indexLibrary(entry, javaProject);
906	} else {	907	} else {
907	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);	908	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
908	}	909	}
Lines 913-919 Link Here
913	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_ADDED);	914	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_ADDED);
914	this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));	915	this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));
915	// index the new jar	916	// index the new jar
916	this.manager.indexManager.indexLibrary(entryPath, project.getProject());	917	this.manager.indexManager.indexLibrary(entry, javaProject);
917	}	918	}
918	}	919	}
919	} else { // internal JAR	920	} else { // internal JAR
Lines 2503-2515 Link Here
2503	switch (delta.getKind()) {	2504	switch (delta.getKind()) {
2504	case IResourceDelta.ADDED:	2505	case IResourceDelta.ADDED:
2505	// index the new jar	2506	// index the new jar
2506	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject());	2507	indexManager.indexPackageFragmentRoot(root);
2507	break;	2508	break;
2508	case IResourceDelta.CHANGED:	2509	case IResourceDelta.CHANGED:
2509	// first remove the index so that it is forced to be re-indexed	2510	// first remove the index so that it is forced to be re-indexed
2510	indexManager.removeIndex(jarPath);	2511	indexManager.removeIndex(jarPath);
2511	// then index the jar	2512	// then index the jar
2512	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject());	2513	indexManager.indexPackageFragmentRoot(root);
2513	break;	2514	break;
2514	case IResourceDelta.REMOVED:	2515	case IResourceDelta.REMOVED:
2515	// the jar was physically removed: remove the index	2516	// the jar was physically removed: remove the index

Lines 251-257 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java (-37 / +33 lines)
251	* (regression test for bug 23112 search: need a way to search for references to the implicit non-arg constructor)	251	* (regression test for bug 23112 search: need a way to search for references to the implicit non-arg constructor)
252	*/	252	*/
253	public void testConstructorReference10() throws CoreException { // was testConstructorReferenceImplicitConstructorCall2	253	public void testConstructorReference10() throws CoreException { // was testConstructorReferenceImplicitConstructorCall2
254	this.resultCollector.showSynthetic = true;	254	this.resultCollector.showSynthetic();
255	search(	255	search(
256	"c11.A()",	256	"c11.A()",
257	CONSTRUCTOR,	257	CONSTRUCTOR,
Lines 814-820 Link Here
814	public void testFieldReference03() throws CoreException {	814	public void testFieldReference03() throws CoreException {
815	IType type = getCompilationUnit("JavaSearch", "src", "q8", "EclipseTest.java").getType("EclipseTest");	815	IType type = getCompilationUnit("JavaSearch", "src", "q8", "EclipseTest.java").getType("EclipseTest");
816	IField field = type.getField("test");	816	IField field = type.getField("test");
817	this.resultCollector.showPotential = false;	817	this.resultCollector.showPotential(false);
818	search(field, REFERENCES, getJavaSearchScope());	818	search(field, REFERENCES, getJavaSearchScope());
819	assertSearchResults(	819	assertSearchResults(
820	"src/q8/EclipseTest.java void q8.EclipseTest.main(String[]) [test]"	820	"src/q8/EclipseTest.java void q8.EclipseTest.main(String[]) [test]"
Lines 1124-1130 Link Here
1124	public void testFieldReference20() throws CoreException { // was testFieldReferenceInOutDocComment	1124	public void testFieldReference20() throws CoreException { // was testFieldReferenceInOutDocComment
1125	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");	1125	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
1126	IField field = type.getField("x");	1126	IField field = type.getField("x");
1127	this.resultCollector.showInsideDoc = true;	1127	this.resultCollector.showInsideDoc();
1128	search(field, REFERENCES, getJavaSearchScope(), this.resultCollector);	1128	search(field, REFERENCES, getJavaSearchScope(), this.resultCollector);
1129	assertSearchResults(	1129	assertSearchResults(
1130	"src/s4/X.java int s4.X.foo() [x] OUTSIDE_JAVADOC\n" +	1130	"src/s4/X.java int s4.X.foo() [x] OUTSIDE_JAVADOC\n" +
Lines 1734-1740 Link Here
1734	public void testMethodReference15() throws CoreException { // was testMethodReferenceInOutDocComment	1734	public void testMethodReference15() throws CoreException { // was testMethodReferenceInOutDocComment
1735	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");	1735	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
1736	IMethod method = type.getMethod("foo", new String[] {});	1736	IMethod method = type.getMethod("foo", new String[] {});
1737	this.resultCollector.showInsideDoc = true;	1737	this.resultCollector.showInsideDoc();
1738	search(method, REFERENCES, getJavaSearchScope(), this.resultCollector);	1738	search(method, REFERENCES, getJavaSearchScope(), this.resultCollector);
1739	assertSearchResults(	1739	assertSearchResults(
1740	"src/s4/X.java void s4.X.bar() [foo()] INSIDE_JAVADOC\n" +	1740	"src/s4/X.java void s4.X.bar() [foo()] INSIDE_JAVADOC\n" +
Lines 1759-1765 Link Here
1759	public void testMethodReference17() throws CoreException {	1759	public void testMethodReference17() throws CoreException {
1760	IType type = getCompilationUnit("JavaSearch/src/b111416/X.java").getType("X");	1760	IType type = getCompilationUnit("JavaSearch/src/b111416/X.java").getType("X");
1761	IMethod method = type.getMethod("open", new String[] {"QString;"});	1761	IMethod method = type.getMethod("open", new String[] {"QString;"});
1762	this.resultCollector.showAccuracy = true;	1762	this.resultCollector.showAccuracy(true);
1763	search(method, REFERENCES, ERASURE_RULE, getJavaSearchScope(), this.resultCollector);	1763	search(method, REFERENCES, ERASURE_RULE, getJavaSearchScope(), this.resultCollector);
1764	assertSearchResults(	1764	assertSearchResults(
1765	"src/b111416/X.java void b111416.X.foo() [open(\"\")] EXACT_MATCH",	1765	"src/b111416/X.java void b111416.X.foo() [open(\"\")] EXACT_MATCH",
Lines 1777-1783 Link Here
1777	.getType("A1").getMethod("m", new String[] {});	1777	.getType("A1").getMethod("m", new String[] {});
1778	SearchPattern rightPattern = createPattern(rightMethod, ALL_OCCURRENCES);	1778	SearchPattern rightPattern = createPattern(rightMethod, ALL_OCCURRENCES);
1779	SearchPattern orPattern = SearchPattern.createOrPattern(leftPattern, rightPattern);	1779	SearchPattern orPattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
1780	this.resultCollector.showAccuracy = true;	1780	this.resultCollector.showAccuracy(true);
1781	search(	1781	search(
1782	orPattern,	1782	orPattern,
1783	getJavaSearchScope(),	1783	getJavaSearchScope(),
Lines 1868-1874 Link Here
1868	*/	1868	*/
1869	public void testPackageDeclarationBug73551() throws CoreException {	1869	public void testPackageDeclarationBug73551() throws CoreException {
1870	JavaSearchResultCollector result = new JavaSearchResultCollector();	1870	JavaSearchResultCollector result = new JavaSearchResultCollector();
1871	result.showAccuracy = true;	1871	result.showAccuracy(true);
1872	IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "p71267", "Test.java").getPackageDeclaration("p71267");	1872	IPackageDeclaration packDecl = getCompilationUnit("JavaSearch", "src", "p71267", "Test.java").getPackageDeclaration("p71267");
1873	search(packDecl, DECLARATIONS, getJavaSearchScope(), result);	1873	search(packDecl, DECLARATIONS, getJavaSearchScope(), result);
1874	assertSearchResults(	1874	assertSearchResults(
Lines 1886-1892 Link Here
1886	try {	1886	try {
1887	test = srcRoot.createPackageFragment("b117020", true, null);	1887	test = srcRoot.createPackageFragment("b117020", true, null);
1888	JavaSearchResultCollector result = new JavaSearchResultCollector();	1888	JavaSearchResultCollector result = new JavaSearchResultCollector();
1889	result.showAccuracy = true;	1889	result.showAccuracy(true);
1890	search(test, DECLARATIONS, getJavaSearchScope(), result);	1890	search(test, DECLARATIONS, getJavaSearchScope(), result);
1891	assertSearchResults(	1891	assertSearchResults(
1892	"src/b117020 b117020 EXACT_MATCH",	1892	"src/b117020 b117020 EXACT_MATCH",
Lines 2145-2151 Link Here
2145	JAVA_PROJECT.setRawClasspath(newClasspath, null);	2145	JAVA_PROJECT.setRawClasspath(newClasspath, null);
2146		2146
2147	// potential match for a field declaration	2147	// potential match for a field declaration
2148	this.resultCollector.showAccuracy = true;	2148	this.resultCollector.showAccuracy(true);
2149	search("MissingFieldType.*", FIELD, DECLARATIONS, getJavaSearchScope());	2149	search("MissingFieldType.*", FIELD, DECLARATIONS, getJavaSearchScope());
2150	assertSearchResults(	2150	assertSearchResults(
2151	"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +	2151	"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +
Lines 2177-2183 Link Here
2177	}	2177	}
2178	}	2178	}
2179	};	2179	};
2180	collector.showAccuracy = true;	2180	collector.showAccuracy(true);
2181	search("*", FIELD, DECLARATIONS, getJavaSearchScope(), collector);	2181	search("*", FIELD, DECLARATIONS, getJavaSearchScope(), collector);
2182	assertSearchResults(	2182	assertSearchResults(
2183	"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +	2183	"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] EXACT_MATCH\n" +
Lines 2206-2212 Link Here
2206	JAVA_PROJECT.setRawClasspath(newClasspath, null);	2206	JAVA_PROJECT.setRawClasspath(newClasspath, null);
2207		2207
2208	// potential match for a method declaration	2208	// potential match for a method declaration
2209	this.resultCollector.showAccuracy = true;	2209	this.resultCollector.showAccuracy(true);
2210	search("MissingArgumentType.foo*", METHOD, DECLARATIONS, getJavaSearchScope());	2210	search("MissingArgumentType.foo*", METHOD, DECLARATIONS, getJavaSearchScope());
2211	assertSearchResults(	2211	assertSearchResults(
2212	"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +	2212	"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +
Lines 2238-2244 Link Here
2238	}	2238	}
2239	}	2239	}
2240	};	2240	};
2241	collector.showAccuracy = true;	2241	collector.showAccuracy(true);
2242	search("*", METHOD, DECLARATIONS, getJavaSearchScope(), collector);	2242	search("*", METHOD, DECLARATIONS, getJavaSearchScope(), collector);
2243	assertSearchResults(	2243	assertSearchResults(
2244	"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +	2244	"AbortCompilation.jar void AbortCompilation.MissingArgumentType.foo() [No source] EXACT_MATCH\n" +
Lines 2268-2274 Link Here
2268	JAVA_PROJECT.setRawClasspath(newClasspath, null);	2268	JAVA_PROJECT.setRawClasspath(newClasspath, null);
2269		2269
2270	// exact match for a type declaration	2270	// exact match for a type declaration
2271	this.resultCollector.showAccuracy = true;	2271	this.resultCollector.showAccuracy(true);
2272	search("AbortCompilation.Missing", TYPE, DECLARATIONS, getJavaSearchScope());	2272	search("AbortCompilation.Missing", TYPE, DECLARATIONS, getJavaSearchScope());
2273	assertSearchResults(	2273	assertSearchResults(
2274	"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +	2274	"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +
Lines 2291-2297 Link Here
2291	JAVA_PROJECT.setRawClasspath(newClasspath, null);	2291	JAVA_PROJECT.setRawClasspath(newClasspath, null);
2292		2292
2293	// exact match for a type declaration	2293	// exact match for a type declaration
2294	this.resultCollector.showAccuracy = true;	2294	this.resultCollector.showAccuracy(true);
2295	search("Missing*", TYPE, DECLARATIONS, getJavaSearchScope());	2295	search("Missing*", TYPE, DECLARATIONS, getJavaSearchScope());
2296	assertSearchResults(	2296	assertSearchResults(
2297	"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +	2297	"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +
Lines 2491-2505 Link Here
2491	IPackageFragmentRoot root = getPackageFragmentRoot("JavaSearch", "test20631.jar");	2491	IPackageFragmentRoot root = getPackageFragmentRoot("JavaSearch", "test20631.jar");
2492	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});	2492	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});
2493		2493
2494	search(	2494	this.resultCollector.showJarFile();
2495	"Y",	2495	search("Y", TYPE, DECLARATIONS, scope);
2496	TYPE,
2497	DECLARATIONS,
2498	scope,
2499	this.resultCollector);
2500	assertSearchResults(	2496	assertSearchResults(
2501	"test20631.jar Y",	2497	"test20631.jar\|X$Y.class X$Y"
2502	this.resultCollector);	2498	);
2503	}	2499	}
2504	/**	2500	/**
2505	* Type declaration using a package scope test.	2501	* Type declaration using a package scope test.
Lines 2737-2743 Link Here
2737	public void testTypeReference03() throws CoreException {	2733	public void testTypeReference03() throws CoreException {
2738	SearchPattern pattern = createPattern("x31985", TYPE, REFERENCES, false);	2734	SearchPattern pattern = createPattern("x31985", TYPE, REFERENCES, false);
2739		2735
2740	this.resultCollector.showAccuracy = true;	2736	this.resultCollector.showAccuracy(true);
2741	search(	2737	search(
2742	pattern,	2738	pattern,
2743	getJavaSearchScope(),	2739	getJavaSearchScope(),
Lines 2857-2863 Link Here
2857	public void testTypeReference10() throws CoreException { // was testMemberTypeReference	2853	public void testTypeReference10() throws CoreException { // was testMemberTypeReference
2858	// references to second level member type	2854	// references to second level member type
2859		2855
2860	this.resultCollector.showAccuracy = true;	2856	this.resultCollector.showAccuracy(true);
2861	search(	2857	search(
2862	"BMember",	2858	"BMember",
2863	TYPE,	2859	TYPE,
Lines 2874-2880 Link Here
2874		2870
2875	// references to first level member type	2871	// references to first level member type
2876	this.resultCollector = new JavaSearchResultCollector();	2872	this.resultCollector = new JavaSearchResultCollector();
2877	this.resultCollector.showAccuracy = true;	2873	this.resultCollector.showAccuracy(true);
2878	search(	2874	search(
2879	"AzzMember",	2875	"AzzMember",
2880	TYPE,	2876	TYPE,
Lines 2889-2895 Link Here
2889		2885
2890	// no reference to a field with same name as member type	2886	// no reference to a field with same name as member type
2891	this.resultCollector = new JavaSearchResultCollector();	2887	this.resultCollector = new JavaSearchResultCollector();
2892	this.resultCollector.showAccuracy = true;	2888	this.resultCollector.showAccuracy(true);
2893	search(	2889	search(
2894	"BMember",	2890	"BMember",
2895	FIELD,	2891	FIELD,
Lines 2927-2933 Link Here
2927	.getType("A")	2923	.getType("A")
2928	.getType("Object");	2924	.getType("Object");
2929		2925
2930	this.resultCollector.showAccuracy = true;	2926	this.resultCollector.showAccuracy(true);
2931	search(	2927	search(
2932	type,	2928	type,
2933	REFERENCES,	2929	REFERENCES,
Lines 3136-3142 Link Here
3136	public void testTypeReference24() throws CoreException { // was testTypeReferenceInThrows	3132	public void testTypeReference24() throws CoreException { // was testTypeReferenceInThrows
3137	IType type = getCompilationUnit("JavaSearch", "src", "a7", "X.java").getType("MyException");	3133	IType type = getCompilationUnit("JavaSearch", "src", "a7", "X.java").getType("MyException");
3138		3134
3139	this.resultCollector.showAccuracy = true;	3135	this.resultCollector.showAccuracy(true);
3140	search(	3136	search(
3141	type,	3137	type,
3142	REFERENCES,	3138	REFERENCES,
Lines 3173-3180 Link Here
3173	*/	3169	*/
3174	public void testTypeReference26() throws CoreException { // was testInnacurateTypeReference2	3170	public void testTypeReference26() throws CoreException { // was testInnacurateTypeReference2
3175		3171
3176	this.resultCollector.showAccuracy = true;	3172	this.resultCollector.showAccuracy(true);
3177	this.resultCollector.showSelection = true;	3173	this.resultCollector.showSelection();
3178	search(	3174	search(
3179	"p.Zork",	3175	"p.Zork",
3180	TYPE,	3176	TYPE,
Lines 3196-3202 Link Here
3196	public void testTypeReference27() throws CoreException { // was testInnacurateTypeReference3	3192	public void testTypeReference27() throws CoreException { // was testInnacurateTypeReference3
3197	IType type = getCompilationUnit("JavaSearch", "src", "r3", "A21485.java").getType("A21485");	3193	IType type = getCompilationUnit("JavaSearch", "src", "r3", "A21485.java").getType("A21485");
3198		3194
3199	this.resultCollector.showAccuracy = true;	3195	this.resultCollector.showAccuracy(true);
3200	search(	3196	search(
3201	type,	3197	type,
3202	REFERENCES,	3198	REFERENCES,
Lines 3298-3304 Link Here
3298	public void testTypeReference33() throws CoreException { // was testTypeReferenceWithRecovery	3294	public void testTypeReference33() throws CoreException { // was testTypeReferenceWithRecovery
3299	IType type = getCompilationUnit("JavaSearch", "src", "e1", "A29366.java").getType("A29366");	3295	IType type = getCompilationUnit("JavaSearch", "src", "e1", "A29366.java").getType("A29366");
3300		3296
3301	this.resultCollector.showAccuracy = true;	3297	this.resultCollector.showAccuracy(true);
3302	search(	3298	search(
3303	type,	3299	type,
3304	REFERENCES,	3300	REFERENCES,
Lines 3315-3321 Link Here
3315	public void testTypeReference34() throws CoreException { // was testTypeReferenceWithProblem	3311	public void testTypeReference34() throws CoreException { // was testTypeReferenceWithProblem
3316	IType type = getCompilationUnit("JavaSearch", "src", "e6", "A.java").getType("A");	3312	IType type = getCompilationUnit("JavaSearch", "src", "e6", "A.java").getType("A");
3317		3313
3318	this.resultCollector.showAccuracy = true;	3314	this.resultCollector.showAccuracy(true);
3319	search(	3315	search(
3320	"B36479",	3316	"B36479",
3321	TYPE,	3317	TYPE,
Lines 3343-3349 Link Here
3343		3339
3344	IType type = getCompilationUnit("JavaSearch", "src", "e7", "A.java").getType("A");	3340	IType type = getCompilationUnit("JavaSearch", "src", "e7", "A.java").getType("A");
3345		3341
3346	this.resultCollector.showAccuracy = true;	3342	this.resultCollector.showAccuracy(true);
3347	search(	3343	search(
3348	type,	3344	type,
3349	REFERENCES,	3345	REFERENCES,
Lines 3363-3369 Link Here
3363	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "f2");	3359	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "f2");
3364	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});	3360	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});
3365		3361
3366	this.resultCollector.showSelection = true;	3362	this.resultCollector.showSelection();
3367	search(	3363	search(
3368	"Y",	3364	"Y",
3369	TYPE,	3365	TYPE,
Lines 3384-3390 Link Here
3384		3380
3385	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();	3381	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
3386		3382
3387	this.resultCollector.showSelection = true;	3383	this.resultCollector.showSelection();
3388	search(	3384	search(
3389	localType,	3385	localType,
3390	REFERENCES,	3386	REFERENCES,
Lines 3399-3405 Link Here
3399	*/	3395	*/
3400	public void testTypeReference38() throws CoreException { // was testTypeReferenceInOutDocComment	3396	public void testTypeReference38() throws CoreException { // was testTypeReferenceInOutDocComment
3401	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");	3397	IType type = getCompilationUnit("JavaSearch", "src", "s4", "X.java").getType("X");
3402	this.resultCollector.showInsideDoc = true;	3398	this.resultCollector.showInsideDoc();
3403	search(type, REFERENCES, getJavaSearchScope(), this.resultCollector);	3399	search(type, REFERENCES, getJavaSearchScope(), this.resultCollector);
3404	assertSearchResults(	3400	assertSearchResults(
3405	"src/s4/X.java void s4.X.bar() [X] INSIDE_JAVADOC\n" +	3401	"src/s4/X.java void s4.X.bar() [X] INSIDE_JAVADOC\n" +

Lines 16-22 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchScopeTests.java (-6 / +6 lines)
16		16
17	import org.eclipse.core.resources.IncrementalProjectBuilder;	17	import org.eclipse.core.resources.IncrementalProjectBuilder;
18	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.core.runtime.Path;
20	import org.eclipse.jdt.core.*;	19	import org.eclipse.jdt.core.*;
21	import org.eclipse.jdt.core.search.*;	20	import org.eclipse.jdt.core.search.*;
22	import org.eclipse.jdt.core.tests.model.AbstractJavaSearchTests.JavaSearchResultCollector;	21	import org.eclipse.jdt.core.tests.model.AbstractJavaSearchTests.JavaSearchResultCollector;
Lines 873-879 Link Here
873	IPackageFragmentRoot root = project.getPackageFragmentRoot(getFolder("/P1/test"));	872	IPackageFragmentRoot root = project.getPackageFragmentRoot(getFolder("/P1/test"));
874	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});	873	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});
875	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();	874	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
876	resultCollector.showProject = true;	875	resultCollector.showProject();
877	search("foo", METHOD, DECLARATIONS, scope, resultCollector);	876	search("foo", METHOD, DECLARATIONS, scope, resultCollector);
878	assertSearchResults(	877	assertSearchResults(
879	"test/Test.java [in P1] void Test.foo() [foo]",	878	"test/Test.java [in P1] void Test.foo() [foo]",
Lines 910-916 Link Here
910	);	909	);
911	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});	910	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
912	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();	911	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
913	resultCollector.showProject = true;	912	resultCollector.showProject();
914	search("ITest", TYPE, REFERENCES, scope, resultCollector);	913	search("ITest", TYPE, REFERENCES, scope, resultCollector);
915	assertSearchResults(	914	assertSearchResults(
916	"test/Test.java [in P1] Test.test [ITest]\n" +	915	"test/Test.java [in P1] Test.test [ITest]\n" +
Lines 947-953 Link Here
947	assertNotNull("We should have a default fragment for project P1!", defaultFragment);	946	assertNotNull("We should have a default fragment for project P1!", defaultFragment);
948	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {defaultFragment});	947	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {defaultFragment});
949	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();	948	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
950	resultCollector.showProject = true;	949	resultCollector.showProject();
951	search("main(String[]) void", METHOD, DECLARATIONS, scope, resultCollector);	950	search("main(String[]) void", METHOD, DECLARATIONS, scope, resultCollector);
952	assertSearchResults(	951	assertSearchResults(
953	"Test.java [in P1] void Test.main(String[]) [main]",	952	"Test.java [in P1] void Test.main(String[]) [main]",
Lines 982-988 Link Here
982	);	981	);
983	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });	982	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
984	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();	983	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
985	resultCollector.showProject = true;	984	resultCollector.showProject();
986	search("Test", TYPE, REFERENCES, scope, resultCollector);	985	search("Test", TYPE, REFERENCES, scope, resultCollector);
987	assertSearchResults(	986	assertSearchResults(
988	"src/X.java [in P1] X.test [Test]",	987	"src/X.java [in P1] X.test [Test]",
Lines 1023-1029 Link Here
1023		1022
1024	// Index the output location as it is a library for the project	1023	// Index the output location as it is a library for the project
1025	IndexManager indexManager = JavaModelManager.getIndexManager();	1024	IndexManager indexManager = JavaModelManager.getIndexManager();
1026	indexManager.indexLibrary(new Path("/P1/bin"), project.getProject());	1025	IPackageFragmentRoot root = project.getPackageFragmentRoot(getWorkspaceRoot().findMember("/P1/bin"));
		1026	indexManager.indexPackageFragmentRoot(root);
1027	waitUntilIndexesReady();	1027	waitUntilIndexesReady();
1028		1028
1029	// Search for all types	1029	// Search for all types

Lines 24-29 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (-21 / +85 lines)
24	import org.eclipse.jdt.core.compiler.CharOperation;	24	import org.eclipse.jdt.core.compiler.CharOperation;
25	import org.eclipse.jdt.core.search.*;	25	import org.eclipse.jdt.core.search.*;
26	import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;	26	import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;
		27	import org.eclipse.jdt.internal.core.Member;
27	import org.eclipse.jdt.internal.core.PackageFragment;	28	import org.eclipse.jdt.internal.core.PackageFragment;
28	//import org.eclipse.jdt.internal.core.ResolvedSourceMethod;	29	//import org.eclipse.jdt.internal.core.ResolvedSourceMethod;
29	//import org.eclipse.jdt.internal.core.ResolvedSourceType;	30	//import org.eclipse.jdt.internal.core.ResolvedSourceType;
Lines 47-68 Link Here
47	// boolean discard;	48	// boolean discard;
48		49
49	/**	50	/**
		51	* Flags for the default search result collector
		52	*/
		53	static protected final int SHOW_ACCURACY = 0x0001;
		54	static protected final int SHOW_SELECTION = 0x0002;
		55	static protected final int SHOW_RULE = 0x0004;
		56	static protected final int SHOW_INSIDE_DOC = 0x0008;
		57	static protected final int SHOW_POTENTIAL = 0x0010;
		58	static protected final int SHOW_PROJECT = 0x0020;
		59	static protected final int SHOW_SYNTHETIC = 0x0040;
		60	static protected final int SHOW_OFFSET = 0x0080;
		61	static protected final int SHOW_ACCESS = 0x0100;
		62	static protected final int SHOW_MATCH_KIND = 0x0200;
		63	static protected final int SHOW_JAR_FILE = 0x0400;
		64
		65	/**
50	* Collects results as a string.	66	* Collects results as a string.
51	*/	67	*/
52	public static class JavaSearchResultCollector extends SearchRequestor {	68	public static class JavaSearchResultCollector extends SearchRequestor {
		69	int flags = SHOW_POTENTIAL; // default
53	protected SearchMatch match;	70	protected SearchMatch match;
54	public StringBuffer results = new StringBuffer(), line;	71	public StringBuffer results = new StringBuffer(), line;
55	public boolean showAccuracy;
56	public boolean showSelection;
57	public boolean showRule;
58	public boolean showInsideDoc;
59	public boolean showPotential = true;
60	public boolean showProject;
61	public boolean showSynthetic;
62	public boolean showOffset = false;
63	public boolean showAccess = false;
64	public int showFlavors = 0;	72	public int showFlavors = 0;
65	public boolean showMatchKind = false;
66	public int count = 0;	73	public int count = 0;
67	List lines = new ArrayList();	74	List lines = new ArrayList();
68	boolean sorted;	75	boolean sorted;
Lines 76-82 Link Here
76	this.count++;	83	this.count++;
77	this.match = searchMatch;	84	this.match = searchMatch;
78	writeLine();	85	writeLine();
79	if (this.line != null && (this.match.getAccuracy() == SearchMatch.A_ACCURATE \|\| this.showPotential)) {	86	if (this.line != null && (this.match.getAccuracy() == SearchMatch.A_ACCURATE \|\| (this.flags & SHOW_POTENTIAL) != 0)) {
80	this.lines.add(this.line);	87	this.lines.add(this.line);
81	}	88	}
82	}	89	}
Lines 88-100 Link Here
88	IResource resource = this.match.getResource();	95	IResource resource = this.match.getResource();
89	IJavaElement element = getElement(this.match);	96	IJavaElement element = getElement(this.match);
90	this.line = new StringBuffer();	97	this.line = new StringBuffer();
91	if (this.showMatchKind) {	98	if ((this.flags & SHOW_MATCH_KIND) != 0) {
92	String matchClassName = this.match.getClass().getName();	99	String matchClassName = this.match.getClass().getName();
93	this.line.append(matchClassName.substring(matchClassName.lastIndexOf('.')+1));	100	this.line.append(matchClassName.substring(matchClassName.lastIndexOf('.')+1));
94	this.line.append(": ");	101	this.line.append(": ");
95	}	102	}
96	this.line.append(getPathString(resource, element));	103	this.line.append(getPathString(resource, element));
97	if (this.showProject) {	104	if ((this.flags & SHOW_PROJECT) != 0) {
98	IProject project = element.getJavaProject().getProject();	105	IProject project = element.getJavaProject().getProject();
99	this.line.append(" [in ");	106	this.line.append(" [in ");
100	this.line.append(project.getName());	107	this.line.append(project.getName());
Lines 174-180 Link Here
174	if (start == -1 \|\| (contents != null && contents.length > 0)) { // retrieving attached source not implemented here	181	if (start == -1 \|\| (contents != null && contents.length > 0)) { // retrieving attached source not implemented here
175	this.line.append(" [");	182	this.line.append(" [");
176	if (start > -1) {	183	if (start > -1) {
177	if (this.showSelection) {	184	if ((this.flags & SHOW_SELECTION) != 0) {
178	int lineStart1 = CharOperation.lastIndexOf('\n', contents, 0, start);	185	int lineStart1 = CharOperation.lastIndexOf('\n', contents, 0, start);
179	int lineStart2 = CharOperation.lastIndexOf('\r', contents, 0, start);	186	int lineStart2 = CharOperation.lastIndexOf('\r', contents, 0, start);
180	int lineStart = Math.max(lineStart1, lineStart2) + 1;	187	int lineStart = Math.max(lineStart1, lineStart2) + 1;
Lines 182-188 Link Here
182	this.line.append("§\|");	189	this.line.append("§\|");
183	}	190	}
184	this.line.append(CharOperation.subarray(contents, start, end));	191	this.line.append(CharOperation.subarray(contents, start, end));
185	if (this.showSelection) {	192	if ((this.flags & SHOW_SELECTION) != 0) {
186	this.line.append("\|§");	193	this.line.append("\|§");
187	int lineEnd1 = CharOperation.indexOf('\n', contents, end);	194	int lineEnd1 = CharOperation.indexOf('\n', contents, end);
188	int lineEnd2 = CharOperation.indexOf('\r', contents, end);	195	int lineEnd2 = CharOperation.indexOf('\r', contents, end);
Lines 190-196 Link Here
190	if (lineEnd == -1) lineEnd = contents.length;	197	if (lineEnd == -1) lineEnd = contents.length;
191	this.line.append(CharOperation.subarray(contents, end, lineEnd));	198	this.line.append(CharOperation.subarray(contents, end, lineEnd));
192	}	199	}
193	if (this.showOffset) {	200	if ((this.flags & SHOW_OFFSET) != 0) {
194	this.line.append('@');	201	this.line.append('@');
195	this.line.append(start);	202	this.line.append(start);
196	}	203	}
Lines 200-209 Link Here
200	this.line.append("]");	207	this.line.append("]");
201	}	208	}
202	}	209	}
203	if (this.showAccuracy) {	210	if ((this.flags & SHOW_ACCURACY) != 0) {
204	this.line.append(" ");	211	this.line.append(" ");
205	if (this.match.getAccuracy() == SearchMatch.A_ACCURATE) {	212	if (this.match.getAccuracy() == SearchMatch.A_ACCURATE) {
206	if (this.showRule) {	213	if ((this.flags & SHOW_RULE) != 0) {
207	if (this.match.isExact()) {	214	if (this.match.isExact()) {
208	this.line.append("EXACT_");	215	this.line.append("EXACT_");
209	} else if (this.match.isEquivalent()) {	216	} else if (this.match.isEquivalent()) {
Lines 224-230 Link Here
224	this.line.append("POTENTIAL_MATCH");	231	this.line.append("POTENTIAL_MATCH");
225	}	232	}
226	}	233	}
227	if (this.showInsideDoc) {	234	if ((this.flags & SHOW_INSIDE_DOC) != 0) {
228	this.line.append(" ");	235	this.line.append(" ");
229	if (this.match.isInsideDocComment()) {	236	if (this.match.isInsideDocComment()) {
230	this.line.append("INSIDE_JAVADOC");	237	this.line.append("INSIDE_JAVADOC");
Lines 232-238 Link Here
232	this.line.append("OUTSIDE_JAVADOC");	239	this.line.append("OUTSIDE_JAVADOC");
233	}	240	}
234	}	241	}
235	if (this.showSynthetic) {	242	if ((this.flags & SHOW_SYNTHETIC) != 0) {
236	if (this.match instanceof MethodReferenceMatch) {	243	if (this.match instanceof MethodReferenceMatch) {
237	MethodReferenceMatch methRef = (MethodReferenceMatch) this.match;	244	MethodReferenceMatch methRef = (MethodReferenceMatch) this.match;
238	if (methRef.isSynthetic()) {	245	if (methRef.isSynthetic()) {
Lines 248-254 Link Here
248	}	255	}
249	}	256	}
250	}	257	}
251	if (this.showAccess) {	258	if ((this.flags & SHOW_ACCESS) != 0) {
252	if (this.match instanceof FieldReferenceMatch) {	259	if (this.match instanceof FieldReferenceMatch) {
253	FieldReferenceMatch fieldRef = (FieldReferenceMatch) this.match;	260	FieldReferenceMatch fieldRef = (FieldReferenceMatch) this.match;
254	if (fieldRef.isReadAccess()) {	261	if (fieldRef.isReadAccess()) {
Lines 277-282 Link Here
277	private boolean showSuperInvocation() {	284	private boolean showSuperInvocation() {
278	return (this.showFlavors & PatternLocator.SUPER_INVOCATION_FLAVOR) != 0;	285	return (this.showFlavors & PatternLocator.SUPER_INVOCATION_FLAVOR) != 0;
279	}	286	}
		287	public void showAccess() {
		288	this.flags \|= SHOW_ACCESS;
		289	}
		290	public void showAccuracy(boolean on) {
		291	if (on) {
		292	this.flags \|= SHOW_ACCURACY;
		293	} else {
		294	this.flags &= ~SHOW_ACCURACY;
		295	}
		296	}
		297	public void showInsideDoc() {
		298	this.flags \|= SHOW_INSIDE_DOC;
		299	}
		300	public void showJarFile() {
		301	this.flags \|= SHOW_JAR_FILE;
		302	}
		303	public void showMatchKind() {
		304	this.flags \|= SHOW_MATCH_KIND;
		305	}
		306	public void showOffset() {
		307	this.flags \|= SHOW_OFFSET;
		308	}
		309	public void showPotential(boolean on) {
		310	if (on) {
		311	this.flags \|= SHOW_POTENTIAL;
		312	} else {
		313	this.flags &= ~SHOW_POTENTIAL;
		314	}
		315	}
		316	public void showProject() {
		317	this.flags \|= SHOW_PROJECT;
		318	}
		319	public void showRule() {
		320	this.flags \|= SHOW_RULE;
		321	}
		322	public void showSelection() {
		323	this.flags \|= SHOW_SELECTION;
		324	}
		325	public void showSynthetic() {
		326	this.flags \|= SHOW_SYNTHETIC;
		327	}
280	protected void append(IAnnotation annotation) throws JavaModelException {	328	protected void append(IAnnotation annotation) throws JavaModelException {
281	this.line.append("@");	329	this.line.append("@");
282	this.line.append(annotation.getElementName());	330	this.line.append(annotation.getElementName());
Lines 405-410 Link Here
405	String pathString;	453	String pathString;
406	if (resource != null) {	454	if (resource != null) {
407	IPath path = resource.getProjectRelativePath();	455	IPath path = resource.getProjectRelativePath();
		456	if ((this.flags & SHOW_JAR_FILE) != 0 && element instanceof Member) {
		457	IPackageFragmentRoot pkgFragmentRoot = null;
		458	try {
		459	pkgFragmentRoot = element.getJavaProject().findPackageFragmentRoot(resource.getFullPath());
		460	} catch (JavaModelException e) {
		461	// ignore
		462	}
		463	if (pkgFragmentRoot != null && pkgFragmentRoot.isArchive()) {
		464	if (pkgFragmentRoot.isExternal()) {
		465	pathString = pkgFragmentRoot.getPath().toOSString();
		466	} else {
		467	pathString = path.toString();
		468	}
		469	return pathString + "\|" + ((Member)element).getTypeRoot().getElementName();
		470	}
		471	}
408	if (path.segmentCount() == 0) {	472	if (path.segmentCount() == 0) {
409	IJavaElement root = element;	473	IJavaElement root = element;
410	while (root != null && !(root instanceof IPackageFragmentRoot)) {	474	while (root != null && !(root instanceof IPackageFragmentRoot)) {

Lines 380-386 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/IndexManager.java (-1 / +47 lines)
380	for (int i = 0; i < entries.length; i++) {	380	for (int i = 0; i < entries.length; i++) {
381	IClasspathEntry entry= entries[i];	381	IClasspathEntry entry= entries[i];
382	if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)	382	if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
383	indexLibrary(entry.getPath(), project);	383	indexLibrary(entry, javaProject);
384	}	384	}
385	} catch(JavaModelException e){ // cannot retrieve classpath info	385	} catch(JavaModelException e){ // cannot retrieve classpath info
386	}	386	}
Lines 394-399 Link Here
394	* Trigger addition of a library to an index	394	* Trigger addition of a library to an index
395	* Note: the actual operation is performed in background	395	* Note: the actual operation is performed in background
396	*/	396	*/
		397	public void indexLibrary(IClasspathEntry classpathEntry, IJavaProject requestingProject) {
		398
		399	// Otherwise index it as a jar file
		400	IPath path = classpathEntry.getPath();
		401	IndexRequest request = indexLibraryRequest(path);
		402	if (request == null) return;
		403	if (request instanceof AddJarFileToIndex) {
		404	AddJarFileToIndex jarFileRequest = (AddJarFileToIndex) request;
		405	jarFileRequest.setJavaProject(requestingProject);
		406	jarFileRequest.setSourceMapper(classpathEntry);
		407	}
		408	if (!isJobWaiting(request)) {
		409	request(request);
		410	}
		411	}
		412	public void indexPackageFragmentRoot(IPackageFragmentRoot fragmentRoot) {
		413	IPath path = fragmentRoot.getPath();
		414	IndexRequest request = indexLibraryRequest(path);
		415	if (request == null) return;
		416	if (request instanceof AddJarFileToIndex) {
		417	AddJarFileToIndex jarFileRequest = (AddJarFileToIndex) request;
		418	jarFileRequest.setSourceMapper(fragmentRoot);
		419	}
		420	if (!isJobWaiting(request)) {
		421	request(request);
		422	}
		423	}
		424	private IndexRequest indexLibraryRequest(IPath path) {
		425	// requestingProject is no longer used to cancel jobs but leave it here just in case
		426	if (JavaCore.getPlugin() == null) return null;
		427
		428	Object target = JavaModel.getTarget(path, true);
		429	IndexRequest request = null;
		430	if (target instanceof IFile) {
		431	request = new AddJarFileToIndex((IFile) target, this);
		432	} else if (target instanceof File) {
		433	request = new AddJarFileToIndex(path, this);
		434	} else if (target instanceof IContainer) {
		435	request = new IndexBinaryFolder((IContainer) target, this);
		436	}
		437	return request;
		438	}
		439	/**
		440	* Trigger addition of a library to an index
		441	* Note: the actual operation is performed in background
		442	*/
397	public void indexLibrary(IPath path, IProject requestingProject) {	443	public void indexLibrary(IPath path, IProject requestingProject) {
398	// requestingProject is no longer used to cancel jobs but leave it here just in case	444	// requestingProject is no longer used to cancel jobs but leave it here just in case
399	if (JavaCore.getPlugin() == null) return;	445	if (JavaCore.getPlugin() == null) return;

Lines 105-111 Link Here

(-)search/org/eclipse/jdt/internal/core/search/TypeNameMatchRequestorWrapper.java (-3 / +16 lines)
105	int separatorIndex= path.indexOf(IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR);	105	int separatorIndex= path.indexOf(IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR);
106	type = separatorIndex == -1	106	type = separatorIndex == -1
107	? createTypeFromPath(path, new String(simpleTypeName), enclosingTypeNames)	107	? createTypeFromPath(path, new String(simpleTypeName), enclosingTypeNames)
108	: createTypeFromJar(path, separatorIndex);	108	: createTypeFromJar(path, separatorIndex, new String(simpleTypeName), enclosingTypeNames); // need to provide simpleTypeName and enclosing type names when the type has been found in attached source!
109	}	109	}
110	if (type != null) {	110	if (type != null) {
111	this.requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, modifiers));	111	this.requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, modifiers));
Lines 114-120 Link Here
114	// skip	114	// skip
115	}	115	}
116	}	116	}
117	private IType createTypeFromJar(String resourcePath, int separatorIndex) throws JavaModelException {	117	private IType createTypeFromJar(String resourcePath, int separatorIndex, String simpleTypeName, char[][] enclosingTypeNames) throws JavaModelException {
118	// path to a class file inside a jar	118	// path to a class file inside a jar
119	// Optimization: cache package fragment root handle and package handles	119	// Optimization: cache package fragment root handle and package handles
120	if (this.lastPkgFragmentRootPath == null	120	if (this.lastPkgFragmentRootPath == null
Lines 143-149 Link Here
143	pkgFragment= ((PackageFragmentRoot) this.lastPkgFragmentRoot).getPackageFragment(pkgName);	143	pkgFragment= ((PackageFragmentRoot) this.lastPkgFragmentRoot).getPackageFragment(pkgName);
144	this.packageHandles.put(pkgName, pkgFragment);	144	this.packageHandles.put(pkgName, pkgFragment);
145	}	145	}
146	return pkgFragment.getClassFile(simpleNames[length]).getType();	146	String simpleName= simpleNames[length];
		147	IClassFile classFile= pkgFragment.getClassFile(simpleName);
		148	IType type = classFile.getType();
		149	int etnLength = enclosingTypeNames == null ? 0 : enclosingTypeNames.length;
		150	if (etnLength > 0) {
		151	if (etnLength > 0) {
		152	for (int i=1; i<etnLength; i++) {
		153	type = type.getType(new String(enclosingTypeNames[i]));
		154	}
		155	type = type.getType(simpleTypeName);
		156	}
		157	}
		158	return type;
		159	// return pkgFragment.getClassFile(simpleNames[length]).getType();
147	}	160	}
148	private IType createTypeFromPath(String resourcePath, String simpleTypeName, char[][] enclosingTypeNames) throws JavaModelException {	161	private IType createTypeFromPath(String resourcePath, String simpleTypeName, char[][] enclosingTypeNames) throws JavaModelException {
149	// path to a file in a directory	162	// path to a file in a directory