Attachment #156008 for bug #295894

Lines 1-5 Link Here

(-)search/org/eclipse/jdt/core/search/SearchEngine.java (-2 / +33 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-13 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 215139	10	* Stephan Herrmann - Contributions for bug 215139 and bug 295894
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.core.search;	12	package org.eclipse.jdt.core.search;
13		13
Lines 212-217 Link Here
212	* or <code>null</code> if the primary working copy owner should be used	212	* or <code>null</code> if the primary working copy owner should be used
213	* @return a new hierarchy scope	213	* @return a new hierarchy scope
214	* @exception JavaModelException if the hierarchy could not be computed on the given type	214	* @exception JavaModelException if the hierarchy could not be computed on the given type
		215	* @deprecated Will be removed shortly before 3.6M5. Use {@link #createStrictHierarchyScope(IJavaProject, IType, boolean, boolean, WorkingCopyOwner)} instead.
215	* @since 3.6	216	* @since 3.6
216	*/	217	*/
217	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {	218	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {
Lines 219-224 Link Here
219	}	220	}
220		221
221	/**	222	/**
		223	* Returns a Java search scope limited to the hierarchy of the given type and to a given project.
		224	* The Java elements resulting from a search with this scope will be types in this hierarchy.
		225	* <p>
		226	* Unlike the <code>createHierarchyScope</code> methods, this method creates <em>strict</em>
		227	* scopes that only contain types that actually span the hierarchy of the focus
		228	* type, but do not include additional enclosing or member types.
		229	* </p>
		230	* <p>
		231	* By default, hierarchy scopes include all direct and indirect supertypes and subtypes of the
		232	* focus type. This method, however, allows to restrict the hierarchy to true subtypes,
		233	* not including supertypes. Also inclusion of the focus type itself is controled by a parameter.
		234	* </p>
		235	*
		236	* @param project the project to which to constrain the search, or <code>null</code> if
		237	* search should consider all types in the workspace
		238	* @param type the focus of the hierarchy scope
		239	* @param onlySubtypes if true only subtypes of <code>type</code> are considered
		240	* @param includeFocusType if true the focus type <code>type</code> is included in the resulting scope,
		241	* otherwise it is excluded
		242	* @param owner the owner of working copies that take precedence over original compilation units,
		243	* or <code>null</code> if the primary working copy owner should be used
		244	* @return a new hierarchy scope
		245	* @exception JavaModelException if the hierarchy could not be computed on the given type
		246	* @since 3.6
		247	*/
		248	public static IJavaSearchScope createStrictHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean includeFocusType, WorkingCopyOwner owner) throws JavaModelException {
		249	return BasicSearchEngine.createStrictHierarchyScope(project, type, onlySubtypes, includeFocusType, owner);
		250	}
		251
		252	/**
222	* Returns a Java search scope limited to the given resources.	253	* Returns a Java search scope limited to the given resources.
223	* The Java elements resulting from a search with this scope will	254	* The Java elements resulting from a search with this scope will
224	* have their underlying resource included in or equals to one of the given	255	* have their underlying resource included in or equals to one of the given




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for bug 215139 and bug 295894
 *******************************************************************************/
package org.eclipse.jdt.internal.core.search;



	/**
	 * @see SearchEngine#createHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.
	 * @deprecated Will be removed shortly before 3.6M5. Use {@link #createHierarchyScope(IJavaProject, IType, boolean, boolean, WorkingCopyOwner)} instead.
	 */
	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {
		return new HierarchyScope(project, type, owner, onlySubtypes, noMemberTypes, !onlySubtypes);
	}

	/**
	 * @see SearchEngine#createStrictHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.
	 */
	public static IJavaSearchScope createStrictHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean includeFocusType, WorkingCopyOwner owner) throws JavaModelException {
		return new HierarchyScope(project, type, owner, onlySubtypes, true, includeFocusType);
	}

	/**




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for bug 215139 and bug 295894
 *******************************************************************************/
package org.eclipse.jdt.internal.core.search;



	private HashSet subTypes = null; // null means: don't filter for subTypes
	private IJavaProject javaProject = null; // null means: don't constrain the search to a project
	private boolean allowMemberAndEnclosingTypes = true;
	private boolean includeFocusType = true;

	/* (non-Javadoc)
	 * Adds the given resource to this search scope.

	}

	/**
	 * Creates a new hierarchy scope for the given type with the given configuration options.
	 * @param project      constrain the search result to this project, 
	 *                     or <code>null</code> if search should consider all types in the workspace 
	 * @param type         the focus type of the hierarchy
	 * @param owner 	   the owner of working copies that take precedence over original compilation units, 
	 *                     or <code>null</code> if the primary working copy owner should be used
	 * @param onlySubtypes if true search only subtypes of 'type'
	 * @param noMembersOrEnclosingTypes if true the hierarchy is strict, 
	 * 					   i.e., no additional member types or enclosing types of types spanning the hierarchy are included,
	 * 					   otherwise all member and enclosing types of types in the hierarchy are included.
	 * @param includeFocusType if true the focus type <code>type</code> is included in the resulting scope, otherwise it is excluded
	 */
	public HierarchyScope(IJavaProject project, IType type, WorkingCopyOwner owner, boolean onlySubtypes, boolean noMembersOrEnclosingTypes, boolean includeFocusType) throws JavaModelException {
		this(type, owner);
		this.javaProject = project;
		if (onlySubtypes) {
			this.subTypes = new HashSet();
		}
		this.includeFocusType = includeFocusType;
		this.allowMemberAndEnclosingTypes = !noMembersOrEnclosingTypes;
	}

	/* (non-Javadoc)

	 *         (regarding subtypes and members) is requested
	 */
	public boolean enclosesFineGrained(IJavaElement element) {
		if ((this.subTypes == null) && this.allowMemberAndEnclosingTypes) 
			return true; // no fine grained checking requested
		return encloses(element);
	}

	 */
	public boolean encloses(IJavaElement element) {
		if (this.hierarchy == null) {
			if (this.includeFocusType && this.focusType.equals(element.getAncestor(IJavaElement.TYPE))) {
				return true;
			} else {
				if (this.needsRefresh) {

			type = ((IMember) element).getDeclaringType();
		}
		if (type != null) {
			if (this.focusType.equals(type))
				return this.includeFocusType;
			// potentially allow travelling in:
			if (enclosesType(type, this.allowMemberAndEnclosingTypes)) {
				return true;
			}
			if (this.allowMemberAndEnclosingTypes) {
				// travel out: queried type is enclosed in this scope if its (indirect) declaring type is:
				IType enclosing = type.getDeclaringType();
				while (enclosing != null) {




}

/**
 * @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
 * @test using the hierarchy with the old API includes the focus type. 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
 */
public void testBug295894() throws Exception {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" + 
		"    void test() {\n" + 
		"        Test t = new Test();\n" + 
		"        t.foo();\n" + 
		"    }\n" + 
		"    public void foo() {\n" + 
		"    }\n" + 
		"    public class Sub extends Test {\n" + 
		"        public void foo() {}\n" + 
		"    }\n" + 
		"}\n" + 
		""
	);
	search(
		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createHierarchyScope(this.workingCopies[0].findPrimaryType()),
		this.resultCollector);
	assertSearchResults(
		"src/Test.java void Test.foo() [foo] EXACT_MATCH\n" + 
		"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
	);
}
/**
 * @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
 * @test explicitly excluding the focus type
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
 */
public void testBug295894a() throws Exception {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" + 
		"    void test() {\n" + 
		"        Test t = new Test();\n" + 
		"        t.foo();\n" + 
		"    }\n" + 
		"    public void foo() {\n" + 
		"    }\n" + 
		"    public class Sub extends Test {\n" + 
		"        public void foo() {}\n" + 
		"    }\n" + 
		"}\n" + 
		""
	);
	search(
		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createStrictHierarchyScope(null, this.workingCopies[0].findPrimaryType(), true, false, null),
		this.resultCollector);
	// Test$Sub is a true sub type, not affected by filtering member types
	assertSearchResults(
		"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
	);
}
/**
 * @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
 * @test explicitly including the focus type
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
 */
public void testBug295894b() throws Exception {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"public class Test {\n" + 
		"    void test() {\n" + 
		"        Test t = new Test();\n" + 
		"        t.foo();\n" + 
		"    }\n" + 
		"    public void foo() {\n" + 
		"    }\n" + 
		"    public class Sub extends Test {\n" + 
		"        public void foo() {}\n" + 
		"    }\n" + 
		"}\n" + 
		""
	);
	search(
		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createStrictHierarchyScope(null, this.workingCopies[0].findPrimaryType(), false, true, null),
		this.resultCollector);
	// Same results as with the old API
	assertSearchResults(
		"src/Test.java void Test.foo() [foo] EXACT_MATCH\n" + 
		"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
	);
}

/**
 * @bug 288174: NullPointerException when searching for type references
 * @test Ensure that no NPE occurs when searching for type references
 * 		when a binary type has matches in several member or anonymous types




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

}
/**
 * Method declaration in hierarchy test.
 * Explicitly request behavior pre https://bugs.eclipse.org/bugs/show_bug.cgi?id=215139
 */
public void testMethodDeclaration04() throws CoreException { // was testMethodDeclarationInHierarchyScope1
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");

		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createHierarchyScope(null, type, false, true, null),
		this.resultCollector);
	assertSearchResults(
		"src/p/X.java void p.X.foo(int, String, X) [foo]\n" +
		"src/p/Z.java void p.Z.foo(int, String, X) [foo]",
		this.resultCollector);
}
/**
 * Method declaration in hierarchy test.
 * After https://bugs.eclipse.org/bugs/show_bug.cgi?id=215139 result contains more types.
 */
public void testMethodDeclaration04a() throws CoreException { // was testMethodDeclarationInHierarchyScope1
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");

	search(
		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createHierarchyScope(type),
		this.resultCollector);
	assertSearchResults(

    	ICompilationUnit cuB = this. getCompilationUnit("JavaSearch", "src", "a10", "B.java");
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // don't include super-classes:
        assertFalse("a10.A should not be included in hierarchy scope", scope.encloses(cuB.getType("A")));

public void testSearchScope07() throws CoreException {
    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // don't include focus type:
        assertFalse("a10.C should not be included in hierarchy scope", scope.encloses(type));
        assertFalse("a10/C.java should not be included in hierarchy scope", scope.encloses(cuC.getUnderlyingResource().getFullPath().toString()));       
}
/**
 * Hierarchy scope test.
 * test for enhancement bug 215139 encloses(): find only subtypes.
 * also test enhancement bug 295894: include focus type.
 */
public void testSearchScope07a() throws CoreException {
    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, true, null);
        
        // include focus type:
        assertTrue("a10.C should be included in hierarchy scope", scope.encloses(type));
        assertTrue("a10/C.java should be included in hierarchy scope", scope.encloses(cuC.getUnderlyingResource().getFullPath().toString()));       
}
/**
 * Hierarchy scope test.

        ICompilationUnit cuD = this. getCompilationUnit("JavaSearch", "src", "a10", "D.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // regular sub-types:
        assertTrue("a10.D should be included in hierarchy scope", scope.encloses(cuD.getType("D")));

    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // sub-type is a nested type:
        assertTrue("a10.H$I should be included in hierarchy scope", scope.encloses(cuE.getType("H").getType("I")));

    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // member of a sub-type:
        assertFalse("a10.F$G should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));
}
/**
 * Hierarchy scope test.
 * (test for enhancement bug 215139 encloses(): find only subtypes and their member types).
 */
public void testSearchScope11() throws CoreException {
    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, false, null);
        
        // member of a sub-type:
        assertTrue("a10.F$G should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));
}
/**
 * Hierarchy scope test.
 * (test for enhancement bug 215139 encloses(): find only subtypes).
 */
public void testSearchScope12() throws CoreException {
    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // enclosing of a sub-type:
        assertFalse("a10.H should not be included in hierarchy scope", scope.encloses(cuE.getType("H")));

public void testSearchScope13() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        search("**", TYPE, DECLARATIONS, scope);
        assertSearchResults(

public void testSearchScope14() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, /*onlySubTypes*/false, true, null);
        
        search("**", TYPE, DECLARATIONS, scope);
        assertSearchResults(

}
/**
 * Hierarchy scope test.
 * test for enhancement bug 215139 search: find only subtypes - disabled,
 * also test enhancement bug 295894: exclude focus type.
 */
public void testSearchScope14a() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, /*onlySubTypes*/false, false, null);
        
        search("**", TYPE, DECLARATIONS, scope);
        assertSearchResults(
        		"src/a10/B.java a10.A [A]\n" + 
        		"src/a10/B.java a10.B [B]\n" + 
        		"src/a10/D.java a10.D [D]\n" + 
        		"src/a10/E.java a10.E [E]\n" + 
        		"src/a10/E.java a10.F [F]\n" + 
        		"src/a10/E.java a10.H$I [I]\n" + 
        		getExternalJCLPathString() + " java.lang.Object"
        		);
    		null);
    	String expected = 
    			"a10.D\n" +
    			"a10.E\n" +
    			"a10.F\n" +
    			"a10.H$I";
    	assertTrue("We should get some types!", collector.size() > 0);
    	assertEquals("Found types sound not to be correct", expected, collector.toString());
}
/**
 * Hierarchy scope test.
 * (test for enhancement bug 215139 search: find only subtypes - different call chain).
 */
public void testSearchScope15() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
    	TypeNameMatchCollector collector = new TypeNameMatchCollector() {
    		public String toString(){
    			return toFullyQualifiedNamesString();

    			"a10.D\n" +
    			"a10.E\n" +
    			"a10.F\n" +
    			"a10.F$G\n" +
    			"a10.H\n" +
    			"a10.H$I";
    	assertTrue("We should get some types!", collector.size() > 0);
    	assertEquals("Found types sound not to be correct", expected, collector.toString());

    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createStrictHierarchyScope(null, type, true, false, null);
        
        // method of a member of a sub-type:
        assertFalse("a10.F$G.m() should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));
}
/**
 * Hierarchy scope test.
 * (test for enhancement bug 215139 encloses(method): find only subtypes but also member types).
 */
public void testSearchScope18() throws CoreException {
    	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, false, null);
        
        // method of a member of a sub-type:
        assertTrue("a10.F$G.m() should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));
}
/**
 * Simple type declaration test.
 */
public void testTypeDeclaration01() throws CoreException { // was testSimpleTypeDeclaration

Return to bug 295894

Lines 11039-11044 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (+98 lines)
11039	}	11039	}
11040		11040
11041	/**	11041	/**
		11042	* @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
		11043	* @test using the hierarchy with the old API includes the focus type.
		11044	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
		11045	*/
		11046	public void testBug295894() throws Exception {
		11047	this.workingCopies = new ICompilationUnit[1];
		11048	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		11049	"public class Test {\n" +
		11050	" void test() {\n" +
		11051	" Test t = new Test();\n" +
		11052	" t.foo();\n" +
		11053	" }\n" +
		11054	" public void foo() {\n" +
		11055	" }\n" +
		11056	" public class Sub extends Test {\n" +
		11057	" public void foo() {}\n" +
		11058	" }\n" +
		11059	"}\n" +
		11060	""
		11061	);
		11062	search(
		11063	"foo",
		11064	METHOD,
		11065	DECLARATIONS,
		11066	SearchEngine.createHierarchyScope(this.workingCopies[0].findPrimaryType()),
		11067	this.resultCollector);
		11068	assertSearchResults(
		11069	"src/Test.java void Test.foo() [foo] EXACT_MATCH\n" +
		11070	"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
		11071	);
		11072	}
		11073	/**
		11074	* @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
		11075	* @test explicitly excluding the focus type
		11076	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
		11077	*/
		11078	public void testBug295894a() throws Exception {
		11079	this.workingCopies = new ICompilationUnit[1];
		11080	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		11081	"public class Test {\n" +
		11082	" void test() {\n" +
		11083	" Test t = new Test();\n" +
		11084	" t.foo();\n" +
		11085	" }\n" +
		11086	" public void foo() {\n" +
		11087	" }\n" +
		11088	" public class Sub extends Test {\n" +
		11089	" public void foo() {}\n" +
		11090	" }\n" +
		11091	"}\n" +
		11092	""
		11093	);
		11094	search(
		11095	"foo",
		11096	METHOD,
		11097	DECLARATIONS,
		11098	SearchEngine.createStrictHierarchyScope(null, this.workingCopies[0].findPrimaryType(), true, false, null),
		11099	this.resultCollector);
		11100	// Test$Sub is a true sub type, not affected by filtering member types
		11101	assertSearchResults(
		11102	"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
		11103	);
		11104	}
		11105	/**
11106	* @bug 295894: Search shows focus type implementation for nested types even though the scope is restricted to subtypes.
11107	* @test explicitly including the focus type
11108	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=295894"
11109	*/
11110	public void testBug295894b() throws Exception {
11111	this.workingCopies = new ICompilationUnit[1];
11112	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
11113	"public class Test {\n" +
11114	" void test() {\n" +
11115	" Test t = new Test();\n" +
11116	" t.foo();\n" +
11117	" }\n" +
11118	" public void foo() {\n" +
11119	" }\n" +
11120	" public class Sub extends Test {\n" +
11121	" public void foo() {}\n" +
11122	" }\n" +
11123	"}\n" +
11124	""
11125	);
11126	search(
11127	"foo",
11128	METHOD,
11129	DECLARATIONS,
11130	SearchEngine.createStrictHierarchyScope(null, this.workingCopies[0].findPrimaryType(), false, true, null),
11131	this.resultCollector);
11132	// Same results as with the old API
11133	assertSearchResults(
11134	"src/Test.java void Test.foo() [foo] EXACT_MATCH\n" +
11135	"src/Test.java void Test$Sub.foo() [foo] EXACT_MATCH"
11136	);
11137	}
11138
11139	/**
11042	* @bug 288174: NullPointerException when searching for type references	11140	* @bug 288174: NullPointerException when searching for type references
11043	* @test Ensure that no NPE occurs when searching for type references	11141	* @test Ensure that no NPE occurs when searching for type references
11044	* when a binary type has matches in several member or anonymous types	11142	* when a binary type has matches in several member or anonymous types

Lines 1-5 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (-3 / +11 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-13 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 215139	10	* Stephan Herrmann - Contributions for bug 215139 and bug 295894
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.internal.core.search;	12	package org.eclipse.jdt.internal.core.search;
13		13
Lines 110-118 Link Here
110		110
111	/**	111	/**
112	* @see SearchEngine#createHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.	112	* @see SearchEngine#createHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.
		113	* @deprecated Will be removed shortly before 3.6M5. Use {@link #createHierarchyScope(IJavaProject, IType, boolean, boolean, WorkingCopyOwner)} instead.
113	*/	114	*/
114	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {	115	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {
115	return new HierarchyScope(project, type, owner, onlySubtypes, noMemberTypes);	116	return new HierarchyScope(project, type, owner, onlySubtypes, noMemberTypes, !onlySubtypes);
		117	}
		118
		119	/**
		120	* @see SearchEngine#createStrictHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.
		121	*/
		122	public static IJavaSearchScope createStrictHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean includeFocusType, WorkingCopyOwner owner) throws JavaModelException {
		123	return new HierarchyScope(project, type, owner, onlySubtypes, true, includeFocusType);
116	}	124	}
117		125
118	/**	126	/**