Attachment #152945 for bug #295894




	 * neither including supertypes nor the focus type itself.
	 * </p>
	 * <p>
	 * Unlike the other <code>createHierarchyScope</code> methods, this method creates
	 * scopes that only contain types that actually span the hierarchy of the focus
	 * type, but do not include additional enclosing or member types.
	 * </p>
	 * 
	 * @param project the project to which to constrain the search, or <code>null</code> if
	 *        search should consider all types in the workspace 
	 * @param type the focus of the hierarchy scope
	 * @param onlySubtypes if true only subtypes of <code>type</code> are considered
	 * @param noMemberTypes if true do not consider member or enclosing types of types in the given type hiearchy
	 * @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
	 * @return a new hierarchy scope
	 * @exception JavaModelException if the hierarchy could not be computed on the given type
	 * @since 3.6
	 */
	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, WorkingCopyOwner owner) throws JavaModelException {
		return BasicSearchEngine.createHierarchyScope(project, type, onlySubtypes, owner);
	}

	/**

Lines 109-118 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (-3 / +3 lines)
109	}	109	}
110		110
111	/**	111	/**
112	* @see SearchEngine#createHierarchyScope(IJavaProject,IType,boolean,boolean,WorkingCopyOwner) for detailed comment.	112	* @see SearchEngine#createHierarchyScope(IJavaProject,IType,boolean,WorkingCopyOwner) for detailed comment.
113	*/	113	*/
114	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {	114	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, WorkingCopyOwner owner) throws JavaModelException {
115	return new HierarchyScope(project, type, owner, onlySubtypes, noMemberTypes);	115	return new HierarchyScope(project, type, owner, onlySubtypes);
116	}	116	}
117		117
118	/**	118	/**





	/**
	 * Creates a new hierarchy scope for the given type.
	 * Unlike the other constructor, this constructor creates scopes that only contain types
	 * that actually span the hierarchy of the focus type, but do not include additional
	 * enclosing or member types.
	 * @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' (not including 'type')
	 * @param noMemberTypes if true do not consider member or enclosing types of types in the given type hierarchy.
	 */
	public HierarchyScope(IJavaProject project, IType type, WorkingCopyOwner owner, boolean onlySubtypes) throws JavaModelException {
		this(type, owner);
		this.javaProject = project;
		if (onlySubtypes) {
			this.subTypes = new HashSet();
		}
		this.allowMemberTypes = false;
	}

	/* (non-Javadoc)




		this.resultCollector.showSelection();
		search(packageFragment, REFERENCES);
		assertSearchResults(
			"src/b153765/test/SomeClass.java void b153765.test.SomeClass.foo() [        @�|b153765|�.Unimportant public void foo() {}] EXACT_MATCH"
		);
	}
	finally {

	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java void test.Test.method() [        @Annot(clazz=�|Test|�.class) int x;]+[@Annot on x]",
		collector
	);
}

	collector.showSelection();
	search("Deprecated", TYPE, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java void test.Test.foo() [        @�|Deprecated|� foo() {}]+[@Deprecated on foo]",
		collector
	);
}

	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment5/Ref.java void comment5.Ref.doA(Ref) [    void doA(�|Ref|� ref) {}]+[ref]\n" + 
		"src/comment5/Ref.java void comment5.Ref.doB(List<Ref>) [    void doB(List<�|Ref|�> ref) {}]+[ref]\n" + 
		"src/comment5/Ref.java void comment5.Ref.doC(Ref) [    void doC(@Tag(�|Ref|�.class) Ref ref) {}]+[@Tag on ref]\n" + 
		"src/comment5/Ref.java void comment5.Ref.doC(Ref) [    void doC(@Tag(Ref.class) �|Ref|� ref) {}]+[ref]\n" + 
		"src/comment5/Ref.java void comment5.Ref.dontD(Object) [    void dontD(@Tag(�|Ref|�.class) Object ref) {}]+[@Tag on ref]",
		collector
	);
}

	collector.showSelection();
	search(field, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment10/Ref.java comment10.Num [@Num(number= Num.�|CONST|�)]+[@Num on Num]",
		collector
	);
}

	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/comment22/Test.java comment22.Test.test1 [    @�|Tag|� Test test1, test2, test3;]+[@Tag on test1]+[@Tag on test2,@Tag on test3]\n" + 
		"src/comment22/Test.java void comment22.Test.method() [        @�|Tag|� Test local= null;]+[@Tag on local]\n" + 
		"src/comment22/Test.java void comment22.Test.method() [        @�|Tag|� Test local1, local2, local3;]+[@Tag on local1]+[@Tag on local2,@Tag on local3]",
		collector
	);
}

	collector.showSelection();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/test/Test.java test.TestMethodReference.x [    @Annot(clazz = �|test.Test|�.class) int x, y;]+[@Annot on x]+[@Annot on y]",
		collector
	);
}

	this.resultCollector.showSelection();
	search("*", TYPE, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/generics/Generic.java [import �|java.io.Serializable|�;] EXACT_MATCH\n" +
		"src/generics/Generic.java [import �|type.def.Types|�;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends �|Types|�, U extends Types & Comparable<Types> & Serializable, V extends A<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends �|Types|� & Comparable<Types> & Serializable, V extends A<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends Types & �|Comparable|�<Types> & Serializable, V extends A<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends Types & Comparable<�|Types|�> & Serializable, V extends A<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends Types & Comparable<Types> & �|Serializable|�, V extends A<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends Types & Comparable<Types> & Serializable, V extends �|A|�<? super Types>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic [public class Generic<T extends Types, U extends Types & Comparable<Types> & Serializable, V extends A<? super �|Types|�>> {] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.field [	�|Generic|�<? extends Types, ?, ?> field;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.field [	Generic<? extends �|Types|�, ?, ?> field;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.comp [	�|Comparable|�<String> comp;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.comp [	Comparable<�|String|�> comp;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.clazz [	�|Class|�<? extends Exception> clazz;] EXACT_MATCH\n" +
		"src/generics/Generic.java generics.Generic.clazz [	Class<? extends �|Exception|�> clazz;] EXACT_MATCH"
	);
}


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


	ILocalVariable variable = selectLocalVariable(this.workingCopies[0], "test");
	search(variable, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/Test.java void Test.m() [        �|test|�.fField = 42; // match for t is writeAccess, should be readAccess] EXACT_MATCH"
	);
}
public void testBug216875b() throws CoreException {

	IField field = this.workingCopies[0].getType("Test").getField("fWrapped");
	search(field, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/Test.java void Test.wrapper() [        �|fWrapped|�.fField = 12; // match for fWrapped is writeAccess] EXACT_MATCH"
	);
}
public void testBug216875c() throws CoreException {

	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo(Test, Test) [		�|t1|�.field = t1.field;] EXACT_MATCH\n" +
		"src/test/X.java void test.X.foo(Test, Test) [		t1.field = �|t1|�.field;] EXACT_MATCH\n" +
		"src/test/X.java void test.X.foo(Test, Test) [		t2.field = �|t1|�.field;] EXACT_MATCH"
	);
}
public void testBug216875d() throws CoreException {

	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, READ_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo() [		�|t1|�.field = t1.field;] EXACT_MATCH\n" +
		"src/test/X.java void test.X.foo() [		t1.field = �|t1|�.field;] EXACT_MATCH\n" +
		"src/test/X.java void test.X.foo() [		t2.field = �|t1|�.field;] EXACT_MATCH"
	);
}
public void testBug216875e() throws CoreException {

	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, WRITE_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo(Test, Test) [		�|t1|� = t2;] EXACT_MATCH"
	);
}
public void testBug216875f() throws CoreException {

	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, WRITE_ACCESSES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo() [		�|t1|� = t2;] EXACT_MATCH"
	);
}
public void testBug216875g() throws CoreException {

	ILocalVariable variable = selectLocalVariable(this.workingCopies[1], "t1");
	search(variable, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo(Test, Test) [		�|t1|� = t2;] WRITE ACCESS\n" +
		"src/test/X.java void test.X.foo(Test, Test) [		�|t1|�.field = t1.field;] READ ACCESS\n" +
		"src/test/X.java void test.X.foo(Test, Test) [		t1.field = �|t1|�.field;] READ ACCESS\n" +
		"src/test/X.java void test.X.foo(Test, Test) [		t2.field = �|t1|�.field;] READ ACCESS"
	);
}
public void testBug216875h() throws CoreException {

	IField field = this.workingCopies[1].getType("X").getField("t1");
	search(field, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/test/X.java void test.X.foo() [		�|t1|� = t2;] WRITE ACCESS\n" +
		"src/test/X.java void test.X.foo() [		�|t1|�.field = t1.field;] READ ACCESS\n" +
		"src/test/X.java void test.X.foo() [		t1.field = �|t1|�.field;] READ ACCESS\n" +
		"src/test/X.java void test.X.foo() [		t2.field = �|t1|�.field;] READ ACCESS"
	);
}


	IType type = selectType(this.workingCopies[0], "Row");
	search(type, REFERENCES, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/Bug.java Bug.{}:Inner#1.field [			�|Row|� field;//LINE 3] EXACT_MATCH"
	);
}


		this.resultCollector,
		null);
	assertSearchResults(
		"src/Test.java Test [public class �|Test|� {] EXACT_MATCH\n" +
		"src/Test.java Test.test [	Test �|test|�;] EXACT_MATCH\n" +
		"src/Test.java Test.test [	�|Test|� test;] EXACT_MATCH\n" +
		"src/Test.java void Test.test(Test) [	void �|test|�(Test test) {] EXACT_MATCH\n" +
		"src/Test.java void Test.test(Test) [	void test(�|Test|� test) {] EXACT_MATCH\n" +
		"src/Test.java void Test.test(Test) [		if (test == this.�|test|�) {] EXACT_MATCH"
	);
}


	IType type = this.workingCopies[0].getType("X");
	search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/Y.java Y [public class Y<T extends �|X|�<?>> {] ERASURE_MATCH"
	);
}
public void testBug221110b() throws CoreException {

	IType type = this.workingCopies[0].getType("I");
	search(type, REFERENCES, SearchPattern.R_ERASURE_MATCH, getJavaSearchWorkingCopiesScope(), this.resultCollector);
	assertSearchResults(
		"src/Z.java Z [public class Z<T extends X<?> & �|I|�<?>> {] ERASURE_MATCH"
	);
}


	this.resultCollector.showSelection();
	search("B251827*", TYPE, REFERENCES);
	assertSearchResults(
		"src/b251827/X.java [import static b251827.�|B251827|�.VAL;] EXACT_MATCH\n" + 
		"src/b251827/X.java [import static b251827.�|B251827|�.foo;] EXACT_MATCH"
	);
}
public void testBug251827b() throws CoreException {

	this.resultCollector.showSelection();
	search("B251827*", TYPE, REFERENCES);
	assertSearchResults(
		"src/b251827/X.java [import static b251827.�|B251827|�.*;] EXACT_MATCH"
	);
}
public void testBug251827c() throws CoreException {

	);
	search("B251827*", TYPE, REFERENCES);
	assertSearchResults(
		"src/b251827/X.java void b251827.X.bar(B251827) [	void bar(�|B251827|� m) {;] EXACT_MATCH"
	);
}


		deleteProject("P");
	}
}

static { TESTS_PREFIX = "testBug295894"; }
/**
 * @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 when restricting the hierarchy to sub types the focus should not be included 
 * @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.createHierarchyScope(null, this.workingCopies[0].findPrimaryType(), true, 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 when not restricting the hierarchy to sub types the focus should be included 
 * @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.createHierarchyScope(null, this.workingCopies[0].findPrimaryType(), false, 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"
	);
}
}




		"foo",
		METHOD,
		DECLARATIONS,
		SearchEngine.createHierarchyScope(null, type, false, null),
		this.resultCollector);
	assertSearchResults(
		"src/p/X.java void p.X.foo(int, String, X) [foo]\n" +

    	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.createHierarchyScope(null, type, true, 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.createHierarchyScope(null, type, true, null);
        
        // don't include focus type:
        assertFalse("a10.C should be not included in hierarchy scope", scope.encloses(type));

        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.createHierarchyScope(null, type, true, 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.createHierarchyScope(null, type, true, 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.createHierarchyScope(null, type, true, 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).
 * Note: this combination of arguments is no longer supported after the change from bug 295894
 */
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, null);
        
        // member of a sub-type:
        assertTrue("a10.F$G should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));

    	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, 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.createHierarchyScope(null, type, true, 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.createHierarchyScope(null, type, /*onlySubTypes*/false, null);
        
        search("**", TYPE, DECLARATIONS, scope);
        assertSearchResults(

public void testSearchScope15() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
    	TypeNameMatchCollector collector = new TypeNameMatchCollector() {
    		public String toString(){
    			return toFullyQualifiedNamesString();

/**
 * Hierarchy scope test.
 * (test for enhancement bug 215139 search: find only subtypes plus member & enclosing types - different call chain).
 * Note: this combination of arguments is no longer supported after the change from bug 295894
 */
public void _testSearchScope16() throws CoreException {
        ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
        IType type = cuC.getType("C");
        IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
    	TypeNameMatchCollector collector = new TypeNameMatchCollector() {
    		public String toString(){
    			return toFullyQualifiedNamesString();

    	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, 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).
 * Note: this combination of arguments is no longer supported after the change from bug 295894
 */
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, 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])));

		}),
		this.resultCollector);
	assertSearchResults(
			"src/b5/A.java b5.A.{} [    �|Zork|�[] zork = new Zork[0];] POTENTIAL_MATCH\n" +
			"src/b5/A.java b5.A.{} [    Zork[] zork = new �|Zork|�[0];] POTENTIAL_MATCH\n" +
			"src/b5/A.java b5.A.{} [    int i = �|Zork|�.foo;] POTENTIAL_MATCH",
		this.resultCollector);
}
/**

		scope,
		this.resultCollector);
	assertSearchResults(
		"src/f2/X.java Object f2.X.foo1() [		return new �|Y|�();]",
		this.resultCollector);
}
/*

		scope,
		this.resultCollector);
	assertSearchResults(
		"src/f2/X.java Object f2.X.foo1() [		return new �|Y|�();]",
		this.resultCollector);
}
/**

Return to bug 295894

Lines 198-221 Link Here

(-)search/org/eclipse/jdt/core/search/SearchEngine.java (-6 / +5 lines)
198	* neither including supertypes nor the focus type itself.	198	* neither including supertypes nor the focus type itself.
199	* </p>	199	* </p>
200	* <p>	200	* <p>
201	* By default, hierarchy scopes include also member types and enclosing types of those types	201	* Unlike the other <code>createHierarchyScope</code> methods, this method creates
202	* that actually span the hierarchy. This method, however, allows to inhibit this behavior,	202	* scopes that only contain types that actually span the hierarchy of the focus
203	* by passing <code>true</code> to the parameter <code>noMemberTypes</code>.	203	* type, but do not include additional enclosing or member types.
204	* </p>	204	* </p>
205	*	205	*
206	* @param project the project to which to constrain the search, or <code>null</code> if	206	* @param project the project to which to constrain the search, or <code>null</code> if
207	* search should consider all types in the workspace	207	* search should consider all types in the workspace
208	* @param type the focus of the hierarchy scope	208	* @param type the focus of the hierarchy scope
209	* @param onlySubtypes if true only subtypes of <code>type</code> are considered	209	* @param onlySubtypes if true only subtypes of <code>type</code> are considered
210	* @param noMemberTypes if true do not consider member or enclosing types of types in the given type hiearchy
211	* @param owner the owner of working copies that take precedence over original compilation units,	210	* @param owner the owner of working copies that take precedence over original compilation units,
212	* or <code>null</code> if the primary working copy owner should be used	211	* or <code>null</code> if the primary working copy owner should be used
213	* @return a new hierarchy scope	212	* @return a new hierarchy scope
214	* @exception JavaModelException if the hierarchy could not be computed on the given type	213	* @exception JavaModelException if the hierarchy could not be computed on the given type
215	* @since 3.6	214	* @since 3.6
216	*/	215	*/
217	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean noMemberTypes, WorkingCopyOwner owner) throws JavaModelException {	216	public static IJavaSearchScope createHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, WorkingCopyOwner owner) throws JavaModelException {
218	return BasicSearchEngine.createHierarchyScope(project, type, onlySubtypes, noMemberTypes, owner);	217	return BasicSearchEngine.createHierarchyScope(project, type, onlySubtypes, owner);
219	}	218	}
220		219
221	/**	220	/**

Lines 62-82 Link Here

(-)search/org/eclipse/jdt/internal/core/search/HierarchyScope.java (-3 / +5 lines)
62		62
63	/**	63	/**
64	* Creates a new hierarchy scope for the given type.	64	* Creates a new hierarchy scope for the given type.
		65	* Unlike the other constructor, this constructor creates scopes that only contain types
		66	* that actually span the hierarchy of the focus type, but do not include additional
		67	* enclosing or member types.
65	* @param project constrain the search result to this project,	68	* @param project constrain the search result to this project,
66	* or <code>null</code> if search should consider all types in the workspace	69	* or <code>null</code> if search should consider all types in the workspace
67	* @param type the focus type of the hierarchy	70	* @param type the focus type of the hierarchy
68	* @param owner the owner of working copies that take precedence over original compilation units,	71	* @param owner the owner of working copies that take precedence over original compilation units,
69	* or <code>null</code> if the primary working copy owner should be used	72	* or <code>null</code> if the primary working copy owner should be used
70	* @param onlySubtypes if true search only subtypes of 'type' (not including 'type')	73	* @param onlySubtypes if true search only subtypes of 'type' (not including 'type')
71	* @param noMemberTypes if true do not consider member or enclosing types of types in the given type hierarchy.
72	*/	74	*/
73	public HierarchyScope(IJavaProject project, IType type, WorkingCopyOwner owner, boolean onlySubtypes, boolean noMemberTypes) throws JavaModelException {	75	public HierarchyScope(IJavaProject project, IType type, WorkingCopyOwner owner, boolean onlySubtypes) throws JavaModelException {
74	this(type, owner);	76	this(type, owner);
75	this.javaProject = project;	77	this.javaProject = project;
76	if (onlySubtypes) {	78	if (onlySubtypes) {
77	this.subTypes = new HashSet();	79	this.subTypes = new HashSet();
78	}	80	}
79	this.allowMemberTypes = !noMemberTypes;	81	this.allowMemberTypes = false;
80	}	82	}
81		83
82	/* (non-Javadoc)	84	/* (non-Javadoc)

Lines 1365-1371 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java (-22 / +25 lines)
1365	"foo",	1365	"foo",
1366	METHOD,	1366	METHOD,
1367	DECLARATIONS,	1367	DECLARATIONS,
1368	SearchEngine.createHierarchyScope(null, type, false, true, null),	1368	SearchEngine.createHierarchyScope(null, type, false, null),
1369	this.resultCollector);	1369	this.resultCollector);
1370	assertSearchResults(	1370	assertSearchResults(
1371	"src/p/X.java void p.X.foo(int, String, X) [foo]\n" +	1371	"src/p/X.java void p.X.foo(int, String, X) [foo]\n" +
Lines 2450-2456 Link Here
2450	ICompilationUnit cuB = this. getCompilationUnit("JavaSearch", "src", "a10", "B.java");	2450	ICompilationUnit cuB = this. getCompilationUnit("JavaSearch", "src", "a10", "B.java");
2451	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2451	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2452	IType type = cuC.getType("C");	2452	IType type = cuC.getType("C");
2453	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2453	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2454		2454
2455	// don't include super-classes:	2455	// don't include super-classes:
2456	assertFalse("a10.A should not be included in hierarchy scope", scope.encloses(cuB.getType("A")));	2456	assertFalse("a10.A should not be included in hierarchy scope", scope.encloses(cuB.getType("A")));
Lines 2464-2470 Link Here
2464	public void testSearchScope07() throws CoreException {	2464	public void testSearchScope07() throws CoreException {
2465	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2465	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2466	IType type = cuC.getType("C");	2466	IType type = cuC.getType("C");
2467	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2467	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2468		2468
2469	// don't include focus type:	2469	// don't include focus type:
2470	assertFalse("a10.C should be not included in hierarchy scope", scope.encloses(type));	2470	assertFalse("a10.C should be not included in hierarchy scope", scope.encloses(type));
Lines 2479-2485 Link Here
2479	ICompilationUnit cuD = this. getCompilationUnit("JavaSearch", "src", "a10", "D.java");	2479	ICompilationUnit cuD = this. getCompilationUnit("JavaSearch", "src", "a10", "D.java");
2480	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2480	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2481	IType type = cuC.getType("C");	2481	IType type = cuC.getType("C");
2482	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2482	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2483		2483
2484	// regular sub-types:	2484	// regular sub-types:
2485	assertTrue("a10.D should be included in hierarchy scope", scope.encloses(cuD.getType("D")));	2485	assertTrue("a10.D should be included in hierarchy scope", scope.encloses(cuD.getType("D")));
Lines 2496-2502 Link Here
2496	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2496	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2497	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2497	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2498	IType type = cuC.getType("C");	2498	IType type = cuC.getType("C");
2499	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2499	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2500		2500
2501	// sub-type is a nested type:	2501	// sub-type is a nested type:
2502	assertTrue("a10.H$I should be included in hierarchy scope", scope.encloses(cuE.getType("H").getType("I")));	2502	assertTrue("a10.H$I should be included in hierarchy scope", scope.encloses(cuE.getType("H").getType("I")));
Lines 2509-2515 Link Here
2509	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2509	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2510	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2510	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2511	IType type = cuC.getType("C");	2511	IType type = cuC.getType("C");
2512	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2512	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2513		2513
2514	// member of a sub-type:	2514	// member of a sub-type:
2515	assertFalse("a10.F$G should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));	2515	assertFalse("a10.F$G should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));
Lines 2517-2528 Link Here
2517	/**	2517	/**
2518	* Hierarchy scope test.	2518	* Hierarchy scope test.
2519	* (test for enhancement bug 215139 encloses(): find only subtypes and their member types).	2519	* (test for enhancement bug 215139 encloses(): find only subtypes and their member types).
		2520	* Note: this combination of arguments is no longer supported after the change from bug 295894
2520	*/	2521	*/
2521	public void testSearchScope11() throws CoreException {	2522	public void _testSearchScope11() throws CoreException {
2522	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2523	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2523	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2524	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2524	IType type = cuC.getType("C");	2525	IType type = cuC.getType("C");
2525	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, false, null);	2526	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2526		2527
2527	// member of a sub-type:	2528	// member of a sub-type:
2528	assertTrue("a10.F$G should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));	2529	assertTrue("a10.F$G should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G")));
Lines 2535-2541 Link Here
2535	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2536	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2536	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2537	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2537	IType type = cuC.getType("C");	2538	IType type = cuC.getType("C");
2538	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2539	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2539		2540
2540	// enclosing of a sub-type:	2541	// enclosing of a sub-type:
2541	assertFalse("a10.H should not be included in hierarchy scope", scope.encloses(cuE.getType("H")));	2542	assertFalse("a10.H should not be included in hierarchy scope", scope.encloses(cuE.getType("H")));
Lines 2548-2554 Link Here
2548	public void testSearchScope13() throws CoreException {	2549	public void testSearchScope13() throws CoreException {
2549	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2550	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2550	IType type = cuC.getType("C");	2551	IType type = cuC.getType("C");
2551	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2552	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2552		2553
2553	search("**", TYPE, DECLARATIONS, scope);	2554	search("**", TYPE, DECLARATIONS, scope);
2554	assertSearchResults(	2555	assertSearchResults(
Lines 2565-2571 Link Here
2565	public void testSearchScope14() throws CoreException {	2566	public void testSearchScope14() throws CoreException {
2566	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2567	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2567	IType type = cuC.getType("C");	2568	IType type = cuC.getType("C");
2568	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, /onlySubTypes/false, true, null);	2569	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, /onlySubTypes/false, null);
2569		2570
2570	search("**", TYPE, DECLARATIONS, scope);	2571	search("**", TYPE, DECLARATIONS, scope);
2571	assertSearchResults(	2572	assertSearchResults(
Lines 2586-2592 Link Here
2586	public void testSearchScope15() throws CoreException {	2587	public void testSearchScope15() throws CoreException {
2587	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2588	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2588	IType type = cuC.getType("C");	2589	IType type = cuC.getType("C");
2589	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2590	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2590	TypeNameMatchCollector collector = new TypeNameMatchCollector() {	2591	TypeNameMatchCollector collector = new TypeNameMatchCollector() {
2591	public String toString(){	2592	public String toString(){
2592	return toFullyQualifiedNamesString();	2593	return toFullyQualifiedNamesString();
Lines 2610-2620 Link Here
2610	/**	2611	/**
2611	* Hierarchy scope test.	2612	* Hierarchy scope test.
2612	* (test for enhancement bug 215139 search: find only subtypes plus member & enclosing types - different call chain).	2613	* (test for enhancement bug 215139 search: find only subtypes plus member & enclosing types - different call chain).
		2614	* Note: this combination of arguments is no longer supported after the change from bug 295894
2613	*/	2615	*/
2614	public void testSearchScope16() throws CoreException {	2616	public void _testSearchScope16() throws CoreException {
2615	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2617	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2616	IType type = cuC.getType("C");	2618	IType type = cuC.getType("C");
2617	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, false, null);	2619	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2618	TypeNameMatchCollector collector = new TypeNameMatchCollector() {	2620	TypeNameMatchCollector collector = new TypeNameMatchCollector() {
2619	public String toString(){	2621	public String toString(){
2620	return toFullyQualifiedNamesString();	2622	return toFullyQualifiedNamesString();
Lines 2645-2651 Link Here
2645	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2647	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2646	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2648	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2647	IType type = cuC.getType("C");	2649	IType type = cuC.getType("C");
2648	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, true, null);	2650	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2649		2651
2650	// method of a member of a sub-type:	2652	// method of a member of a sub-type:
2651	assertFalse("a10.F$G.m() should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));	2653	assertFalse("a10.F$G.m() should not be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));
Lines 2653-2664 Link Here
2653	/**	2655	/**
2654	* Hierarchy scope test.	2656	* Hierarchy scope test.
2655	* (test for enhancement bug 215139 encloses(method): find only subtypes but also member types).	2657	* (test for enhancement bug 215139 encloses(method): find only subtypes but also member types).
		2658	* Note: this combination of arguments is no longer supported after the change from bug 295894
2656	*/	2659	*/
2657	public void testSearchScope18() throws CoreException {	2660	public void _testSearchScope18() throws CoreException {
2658	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");	2661	ICompilationUnit cuC = this. getCompilationUnit("JavaSearch", "src", "a10", "C.java");
2659	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");	2662	ICompilationUnit cuE = this. getCompilationUnit("JavaSearch", "src", "a10", "E.java");
2660	IType type = cuC.getType("C");	2663	IType type = cuC.getType("C");
2661	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, false, null);	2664	IJavaSearchScope scope = SearchEngine.createHierarchyScope(null, type, true, null);
2662		2665
2663	// method of a member of a sub-type:	2666	// method of a member of a sub-type:
2664	assertTrue("a10.F$G.m() should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));	2667	assertTrue("a10.F$G.m() should be included in hierarchy scope", scope.encloses(cuE.getType("F").getType("G").getMethod("m", new String[0])));
Lines 3426-3434 Link Here
3426	}),	3429	}),
3427	this.resultCollector);	3430	this.resultCollector);
3428	assertSearchResults(	3431	assertSearchResults(
3429	"src/b5/A.java b5.A.{} [ �\|Zork\|�[] zork = new Zork[0];] POTENTIAL_MATCH\n" +	3432	"src/b5/A.java b5.A.{} [ �\|Zork\|�[] zork = new Zork[0];] POTENTIAL_MATCH\n" +
3430	"src/b5/A.java b5.A.{} [ Zork[] zork = new �\|Zork\|�[0];] POTENTIAL_MATCH\n" +	3433	"src/b5/A.java b5.A.{} [ Zork[] zork = new �\|Zork\|�[0];] POTENTIAL_MATCH\n" +
3431	"src/b5/A.java b5.A.{} [ int i = �\|Zork\|�.foo;] POTENTIAL_MATCH",	3434	"src/b5/A.java b5.A.{} [ int i = �\|Zork\|�.foo;] POTENTIAL_MATCH",
3432	this.resultCollector);	3435	this.resultCollector);
3433	}	3436	}
3434	/**	3437	/**
Lines 3613-3619 Link Here
3613	scope,	3616	scope,
3614	this.resultCollector);	3617	this.resultCollector);
3615	assertSearchResults(	3618	assertSearchResults(
3616	"src/f2/X.java Object f2.X.foo1() [ return new �\|Y\|�();]",	3619	"src/f2/X.java Object f2.X.foo1() [ return new �\|Y\|�();]",
3617	this.resultCollector);	3620	this.resultCollector);
3618	}	3621	}
3619	/*	3622	/*
Lines 3633-3639 Link Here
3633	scope,	3636	scope,
3634	this.resultCollector);	3637	this.resultCollector);
3635	assertSearchResults(	3638	assertSearchResults(
3636	"src/f2/X.java Object f2.X.foo1() [ return new �\|Y\|�();]",	3639	"src/f2/X.java Object f2.X.foo1() [ return new �\|Y\|�();]",
3637	this.resultCollector);	3640	this.resultCollector);
3638	}	3641	}
3639	/**	3642	/**