Attachment #20369 for bug #82208

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




import org.eclipse.jdt.internal.core.search.matching.*;

/**
 * A {@link SearchEngine} searches for Java elements following a search pattern.
 * The search can be limited to a search scope.
 * <p>
 * Various search patterns can be created using the factory methods 
 * {@link SearchPattern#createPattern(String, int, int, int)}, {@link SearchPattern#createPattern(IJavaElement, int)},
 * {@link SearchPattern#createOrPattern(SearchPattern, SearchPattern)}.
 * </p>
 * <p>For example, one can search for references to a method in the hierarchy of a type, 
 * or one can search for the declarations of types starting with "Abstract" in a project.

	 * @param stringPattern the given pattern
	 * @param searchFor determines the nature of the searched elements
	 *	<ul>
	 * 	<li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
	 *		<li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
	 * 	<li>{@link IJavaSearchConstants#TYPE}: look for both classes and interfaces</li>
	 *		<li>{@link IJavaSearchConstants#FIELD}: look for fields</li>
	 *		<li>{@link IJavaSearchConstants#METHOD}: look for methods</li>
	 *		<li>{@link IJavaSearchConstants#CONSTRUCTOR}: look for constructors</li>
	 *		<li>{@link IJavaSearchConstants#PACKAGE}: look for packages</li>
	 *	</ul>
	 * @param limitTo determines the nature of the expected matches
	 *	<ul>
	 * 		<li>{@link IJavaSearchConstants#DECLARATIONS}: will search declarations matching with the corresponding
	 * 			element. In case the element is a method, declarations of matching methods in subtypes will also
	 *  		be found, allowing to find declarations of abstract methods, etc.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#REFERENCES}: will search references to the given element.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: will search for either declarations or references as specified
	 *  		above.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#IMPLEMENTORS}: for interface, will find all types which implements a given interface.</li>
	 *	</ul>
	 *
	 * @param isCaseSensitive indicates whether the search is case sensitive or not.

	 * @param element the Java element the search pattern is based on
	 * @param limitTo determines the nature of the expected matches
	 * 	<ul>
	 * 		<li>{@link IJavaSearchConstants#DECLARATIONS}: will search declarations matching with the corresponding
	 * 			element. In case the element is a method, declarations of matching methods in subtypes will also
	 *  		be found, allowing to find declarations of abstract methods, etc.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#REFERENCES}: will search references to the given element.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: will search for either declarations or references as specified
	 *  		above.</li>
	 *
	 *		 <li>{@link IJavaSearchConstants#IMPLEMENTORS}: for interface, will find all types which implements a given interface.</li>
	 *	</ul>
	 * @return a search pattern for a Java element or <code>null</code> if the given element is ill-formed
	 * @deprecated Use {@link SearchPattern#createPattern(IJavaElement, int)} instead.

	 * @param workspace the workspace
	 * @param patternString the pattern to be searched for
	 * @param searchFor a hint what kind of Java element the string pattern represents.
	 *  Look into {@link IJavaSearchConstants} for valid values
	 * @param limitTo one of the following values:
	 *	<ul>
	 *	  <li>{@link IJavaSearchConstants#DECLARATIONS}: search 
	 *		  for declarations only </li>
	 *	  <li>{@link IJavaSearchConstants#REFERENCES}: search 
	 *		  for all references </li>
	 *	  <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: search 
	 *		  for both declarations and all references </li>
	 *	  <li>{@link IJavaSearchConstants#IMPLEMENTORS}: search for
	 *		  all implementors of an interface; the value is only valid if
	 *		  the Java element represents an interface</li>
	 * 	</ul>

	 * @param element the Java element to be searched for
	 * @param limitTo one of the following values:
	 *	<ul>
	 *	  <li>{@link IJavaSearchConstants#DECLARATIONS}: search 
	 *		  for declarations only </li>
	 *	  <li>{@link IJavaSearchConstants#REFERENCES}: search 
	 *		  for all references </li>
	 *	  <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: search 
	 *		  for both declarations and all references </li>
	 *	  <li>{@link IJavaSearchConstants#IMPLEMENTORS}: search for
	 *		  all implementors of an interface; the value is only valid if
	 *		  the Java element represents an interface</li>
	 * 	</ul>

	 *					for this type, or a wild-carded string for this type.
	 * @param matchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names
	 *			of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
	 *			of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
	 * </ul>
	 * combined with <code>SearchPattern.R_CASE_SENSITIVE</code>,
	 *   e.g. <code>R_EXACT_MATCH | R_CASE_SENSITIVE</code> if an exact and case sensitive match is requested, 
	 *   or <code>R_PREFIX_MATCH</code> if a prefix non case sensitive match is requested.
	 * @param searchFor one of
	 * <ul>
	 * 		<li><code>IJavaSearchConstants.CLASS</code> if searching for classes only</li>
	 * 		<li><code>IJavaSearchConstants.INTERFACE</code> if searching for interfaces only</li>
	 * 		<li><code>IJavaSearchConstants.TYPE</code> if searching for both classes and interfaces</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 
	 *   or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
	 * @param searchFor determines the nature of the searched elements
	 *	<ul>
	 * 	<li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
	 *		<li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
	 * 	<li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
	 *		<li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
	 * 	<li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
	 *		<li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
	 * 	<li>{@link IJavaSearchConstants#TYPE}: look for all types (ie. classes, interfaces, enum and annotation types)</li>
	 *	</ul>
	 * @param scope the scope to search in
	 * @param nameRequestor the requestor that collects the results of the search
	 * @param waitingPolicy one of
	 * <ul>
	 *		<li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
	 *		<li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
	 *			underlying indexer has not finished indexing the workspace</li>
	 *		<li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
	 *			underlying indexer to finish indexing the workspace</li>
	 * </ul>
	 * @param progressMonitor the progress monitor to report progress to, or <code>null</code> if no progress

	 * @param nameRequestor the requestor that collects the results of the search
	 * @param waitingPolicy one of
	 * <ul>
	 *		<li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
	 *		<li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
	 *			underlying indexer has not finished indexing the workspace</li>
	 *		<li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
	 *			underlying indexer to finish indexing the workspace</li>
	 * </ul>
	 * @param progressMonitor the progress monitor to report progress to, or <code>null</code> if no progress

	 *					for this type, or a wild-carded string for this type.
	 * @param matchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names
	 *			of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
	 *			of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 
	 *   or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
	 * @param searchFor one of
	 * <ul>
	 * 		<li>{@link IJavaSearchConstants#CLASS} if searching for classes only</li>
	 * 		<li>{@link IJavaSearchConstants#INTERFACE} if searching for interfaces only</li>
	 * 		<li>{@link IJavaSearchConstants#TYPE} if searching for both classes and interfaces</li>
	 * </ul>
	 * @param scope the scope to search in
	 * @param nameRequestor the requestor that collects the results of the search
	 * @param waitingPolicy one of
	 * <ul>
	 *		<li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
	 *		<li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
	 *			underlying indexer has not finished indexing the workspace</li>
	 *		<li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
	 *			underlying indexer to finish indexing the workspace</li>
	 * </ul>
	 * @param progressMonitor the progress monitor to report progress to, or <code>null</code> if no progress

	 *					for this type, or a wild-carded string for this type.
	 * @param matchMode one of
	 * <ul>
	 *		<li>{@link IJavaSearchConstants#EXACT_MATCH} if the package name and type name are the full names
	 *			of the searched types.</li>
	 *		<li>{@link IJavaSearchConstants#PREFIX_MATCH} if the package name and type name are prefixes of the names
	 *			of the searched types.</li>
	 *		<li>{@link IJavaSearchConstants#PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
	 * </ul>
	 * @param isCaseSensitive whether the search should be case sensitive
	 * @param searchFor one of
	 * <ul>
	 * 		<li>{@link IJavaSearchConstants#CLASS} if searching for classes only</li>
	 * 		<li>{@link IJavaSearchConstants#INTERFACE} if searching for interfaces only</li>
	 * 		<li>{@link IJavaSearchConstants#TYPE} if searching for both classes and interfaces</li>
	 * </ul>
	 * @param scope the scope to search in
	 * @param nameRequestor the requestor that collects the results of the search
	 * @param waitingPolicy one of
	 * <ul>
	 *		<li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
	 *		<li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
	 *			underlying indexer has not finished indexing the workspace</li>
	 *		<li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
	 *			underlying indexer to finish indexing the workspace</li>
	 * </ul>
	 * @param progressMonitor the progress monitor to report progress to, or <code>null</code> if no progress

Lines 339-345 Link Here

(-)search/org/eclipse/jdt/core/search/SearchPattern.java (-6 / +22 lines)
339	* <li><Exception>Sample(Exception)</li>	339	* <li><Exception>Sample(Exception)</li>
340	* </ul>	340	* </ul>
341	* Type arguments have the same pattern that for type patterns	341	* Type arguments have the same pattern that for type patterns
342	* @see #createTypePattern(String,int,int)	342	* @see #createTypePattern(String,int,int,char)
343	*/	343	*/
344	private static SearchPattern createMethodOrConstructorPattern(String patternString, int limitTo, int matchRule, boolean isConstructor) {	344	private static SearchPattern createMethodOrConstructorPattern(String patternString, int limitTo, int matchRule, boolean isConstructor) {
345		345
Lines 767-773 Link Here
767	* <ul>	767	* <ul>
768	* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>	768	* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
769	* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>	769	* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
770	* <li>{@link IJavaSearchConstants#TYPE}: look for both classes and interfaces</li>	770	* <li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
		771	* <li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
		772	* <li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
		773	* <li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
		774	* <li>{@link IJavaSearchConstants#TYPE}: look for all types (ie. classes, interfaces, enum and annotation types)</li>
771	* <li>{@link IJavaSearchConstants#FIELD}: look for fields</li>	775	* <li>{@link IJavaSearchConstants#FIELD}: look for fields</li>
772	* <li>{@link IJavaSearchConstants#METHOD}: look for methods</li>	776	* <li>{@link IJavaSearchConstants#METHOD}: look for methods</li>
773	* <li>{@link IJavaSearchConstants#CONSTRUCTOR}: look for constructors</li>	777	* <li>{@link IJavaSearchConstants#CONSTRUCTOR}: look for constructors</li>
Lines 808-815 Link Here
808	limitTo &= ~(IJavaSearchConstants.IGNORE_DECLARING_TYPE+IJavaSearchConstants.IGNORE_RETURN_TYPE);	812	limitTo &= ~(IJavaSearchConstants.IGNORE_DECLARING_TYPE+IJavaSearchConstants.IGNORE_RETURN_TYPE);
809		813
810	switch (searchFor) {	814	switch (searchFor) {
		815	case IJavaSearchConstants.CLASS:
		816	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.CLASS_SUFFIX);
		817	case IJavaSearchConstants.CLASS_AND_INTERFACE:
		818	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.CLASS_AND_INTERFACE_SUFFIX);
		819	case IJavaSearchConstants.CLASS_AND_ENUM:
		820	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.CLASS_AND_ENUM_SUFFIX);
		821	case IJavaSearchConstants.INTERFACE:
		822	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.INTERFACE_SUFFIX);
		823	case IJavaSearchConstants.ENUM:
		824	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.ENUM_SUFFIX);
		825	case IJavaSearchConstants.ANNOTATION_TYPE:
		826	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.ANNOTATION_TYPE_SUFFIX);
811	case IJavaSearchConstants.TYPE:	827	case IJavaSearchConstants.TYPE:
812	return createTypePattern(stringPattern, limitTo, matchRule);	828	return createTypePattern(stringPattern, limitTo, matchRule, IIndexConstants.TYPE_SUFFIX);
813	case IJavaSearchConstants.METHOD:	829	case IJavaSearchConstants.METHOD:
814	return createMethodOrConstructorPattern(stringPattern, limitTo, matchRule, false/not a constructor/);	830	return createMethodOrConstructorPattern(stringPattern, limitTo, matchRule, false/not a constructor/);
815	case IJavaSearchConstants.CONSTRUCTOR:	831	case IJavaSearchConstants.CONSTRUCTOR:
Lines 1274-1280 Link Here
1274	* - '*' is not valid inside type arguments definition <>	1290	* - '*' is not valid inside type arguments definition <>
1275	* - '?' is treated as a wildcard when it is inside <> (ie. it must be put on first position of the type argument)	1291	* - '?' is treated as a wildcard when it is inside <> (ie. it must be put on first position of the type argument)
1276	*/	1292	*/
1277	private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule) {	1293	private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule, char indexSuffix) {
1278		1294
1279	Scanner scanner = new Scanner(false /comment/, true /whitespace/, false /nls/, ClassFileConstants.JDK1_3/sourceLevel/, null /taskTags/, null/taskPriorities/, true/taskCaseSensitive/);	1295	Scanner scanner = new Scanner(false /comment/, true /whitespace/, false /nls/, ClassFileConstants.JDK1_3/sourceLevel/, null /taskTags/, null/taskPriorities/, true/taskCaseSensitive/);
1280	scanner.setSource(patternString.toCharArray());	1296	scanner.setSource(patternString.toCharArray());
Lines 1356-1369 Link Here
1356	}	1372	}
1357	switch (limitTo) {	1373	switch (limitTo) {
1358	case IJavaSearchConstants.DECLARATIONS : // cannot search for explicit member types	1374	case IJavaSearchConstants.DECLARATIONS : // cannot search for explicit member types
1359	return new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, IIndexConstants.TYPE_SUFFIX, matchRule);	1375	return new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule);
1360	case IJavaSearchConstants.REFERENCES :	1376	case IJavaSearchConstants.REFERENCES :
1361	return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, matchRule);	1377	return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, matchRule);
1362	case IJavaSearchConstants.IMPLEMENTORS :	1378	case IJavaSearchConstants.IMPLEMENTORS :
1363	return new SuperTypeReferencePattern(qualificationChars, typeChars, true, matchRule);	1379	return new SuperTypeReferencePattern(qualificationChars, typeChars, true, matchRule);
1364	case IJavaSearchConstants.ALL_OCCURRENCES :	1380	case IJavaSearchConstants.ALL_OCCURRENCES :
1365	return new OrPattern(	1381	return new OrPattern(
1366	new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, IIndexConstants.TYPE_SUFFIX, matchRule),// cannot search for explicit member types	1382	new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule),// cannot search for explicit member types
1367	new TypeReferencePattern(qualificationChars, typeChars, matchRule));	1383	new TypeReferencePattern(qualificationChars, typeChars, matchRule));
1368	}	1384	}
1369	return null;	1385	return null;

Lines 343-348 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (-6 / +28 lines)
343	case IIndexConstants.CLASS_SUFFIX :	343	case IIndexConstants.CLASS_SUFFIX :
344	if (typeKind != IGenericType.CLASS_DECL) return false;	344	if (typeKind != IGenericType.CLASS_DECL) return false;
345	break;	345	break;
		346	case IIndexConstants.CLASS_AND_INTERFACE_SUFFIX:
		347	if (typeKind != IGenericType.CLASS_DECL && typeKind != IGenericType.INTERFACE_DECL) return false;
		348	break;
		349	case IIndexConstants.CLASS_AND_ENUM_SUFFIX:
		350	if (typeKind != IGenericType.CLASS_DECL && typeKind != IGenericType.ENUM_DECL) return false;
		351	break;
346	case IIndexConstants.INTERFACE_SUFFIX :	352	case IIndexConstants.INTERFACE_SUFFIX :
347	if (typeKind != IGenericType.INTERFACE_DECL) return false;	353	if (typeKind != IGenericType.INTERFACE_DECL) return false;
348	break;	354	break;
Lines 415-426 Link Here
415	* combined with <code>SearchPattern.R_CASE_SENSITIVE</code>,	421	* combined with <code>SearchPattern.R_CASE_SENSITIVE</code>,
416	* e.g. <code>R_EXACT_MATCH \| R_CASE_SENSITIVE</code> if an exact and case sensitive match is requested,	422	* e.g. <code>R_EXACT_MATCH \| R_CASE_SENSITIVE</code> if an exact and case sensitive match is requested,
417	* or <code>R_PREFIX_MATCH</code> if a prefix non case sensitive match is requested.	423	* or <code>R_PREFIX_MATCH</code> if a prefix non case sensitive match is requested.
418	* @param searchFor one of	424	* @param searchFor determines the nature of the searched elements
419	* <ul>	425	* <ul>
420	* <li><code>IJavaSearchConstants.CLASS</code> if searching for classes only</li>	426	* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
421	* <li><code>IJavaSearchConstants.INTERFACE</code> if searching for interfaces only</li>	427	* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
422	* <li><code>IJavaSearchConstants.TYPE</code> if searching for both classes and interfaces</li>	428	* <li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
423	* </ul>	429	* <li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
		430	* <li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
		431	* <li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
		432	* <li>{@link IJavaSearchConstants#TYPE}: look for all types (ie. classes, interfaces, enum and annotation types)</li>
		433	* </ul>
424	* @param scope the scope to search in	434	* @param scope the scope to search in
425	* @param nameRequestor the requestor that collects the results of the search	435	* @param nameRequestor the requestor that collects the results of the search
426	* @param waitingPolicy one of	436	* @param waitingPolicy one of
Lines 456-461 Link Here
456	case IJavaSearchConstants.CLASS :	466	case IJavaSearchConstants.CLASS :
457	typeSuffix = IIndexConstants.CLASS_SUFFIX;	467	typeSuffix = IIndexConstants.CLASS_SUFFIX;
458	break;	468	break;
		469	case IJavaSearchConstants.CLASS_AND_INTERFACE :
		470	typeSuffix = IIndexConstants.CLASS_AND_INTERFACE_SUFFIX;
		471	break;
		472	case IJavaSearchConstants.CLASS_AND_ENUM :
		473	typeSuffix = IIndexConstants.CLASS_AND_ENUM_SUFFIX;
		474	break;
459	case IJavaSearchConstants.INTERFACE :	475	case IJavaSearchConstants.INTERFACE :
460	typeSuffix = IIndexConstants.INTERFACE_SUFFIX;	476	typeSuffix = IIndexConstants.INTERFACE_SUFFIX;
461	break;	477	break;
Lines 678-683 Link Here
678	case IJavaSearchConstants.CLASS :	694	case IJavaSearchConstants.CLASS :
679	typeSuffix = IIndexConstants.CLASS_SUFFIX;	695	typeSuffix = IIndexConstants.CLASS_SUFFIX;
680	break;	696	break;
		697	case IJavaSearchConstants.CLASS_AND_INTERFACE :
		698	typeSuffix = IIndexConstants.CLASS_AND_INTERFACE_SUFFIX;
		699	break;
		700	case IJavaSearchConstants.CLASS_AND_ENUM :
		701	typeSuffix = IIndexConstants.CLASS_AND_ENUM_SUFFIX;
		702	break;
681	case IJavaSearchConstants.INTERFACE :	703	case IJavaSearchConstants.INTERFACE :
682	typeSuffix = IIndexConstants.INTERFACE_SUFFIX;	704	typeSuffix = IIndexConstants.INTERFACE_SUFFIX;
683	break;	705	break;

Lines 10-15 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/IIndexConstants.java (+4 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core.search.indexing;	11	package org.eclipse.jdt.internal.core.search.indexing;
12		12
		13	import org.eclipse.jdt.core.search.IJavaSearchConstants;
		14
13	public interface IIndexConstants {	15	public interface IIndexConstants {
14		16
15	/* index encoding */	17	/* index encoding */
Lines 31-36 Link Here
31	char ENUM_SUFFIX = 'E';	33	char ENUM_SUFFIX = 'E';
32	char ANNOTATION_TYPE_SUFFIX = 'A';	34	char ANNOTATION_TYPE_SUFFIX = 'A';
33	char TYPE_SUFFIX = 0;	35	char TYPE_SUFFIX = 0;
		36	char CLASS_AND_ENUM_SUFFIX = IJavaSearchConstants.CLASS_AND_ENUM;
		37	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;
34	char SEPARATOR= '/';	38	char SEPARATOR= '/';
35		39
36	char[] ONE_STAR = new char[] {'*'};	40	char[] ONE_STAR = new char[] {'*'};




		if (!checkTypeName(pattern.simpleName, patternString, fullyQualifiedTypeName, pattern.isCaseSensitive())) return false;
	}

	int kind  = type.getKind();
	switch (pattern.typeSuffix) {
		case CLASS_SUFFIX:
			return kind == IGenericType.CLASS_DECL;
		case INTERFACE_SUFFIX:
			return kind == IGenericType.INTERFACE_DECL;
		case ENUM_SUFFIX:
			return kind == IGenericType.ENUM_DECL;
		case ANNOTATION_TYPE_SUFFIX:
			return kind == IGenericType.ANNOTATION_TYPE_DECL;
		case CLASS_AND_INTERFACE_SUFFIX:
			return kind == IGenericType.CLASS_DECL || kind == IGenericType.INTERFACE_DECL;
		case CLASS_AND_ENUM_SUFFIX:
			return kind == IGenericType.CLASS_DECL || kind == IGenericType.ENUM_DECL;
		case TYPE_SUFFIX: // nothing
	}
	return true;

Lines 59-65 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MultiTypeDeclarationPattern.java (-1 / +9 lines)
59	}	59	}
60	this.typeSuffix = typeSuffix;	60	this.typeSuffix = typeSuffix;
61		61
62	((InternalSearchPattern)this).mustResolve = false; // only used to report type declarations, not their positions	62	((InternalSearchPattern)this).mustResolve = typeSuffix != TYPE_SUFFIX; // only used to report type declarations, not their positions
63	}	63	}
64	MultiTypeDeclarationPattern(int matchRule) {	64	MultiTypeDeclarationPattern(int matchRule) {
65	super(TYPE_DECL_PATTERN, matchRule);	65	super(TYPE_DECL_PATTERN, matchRule);
Lines 74-79 Link Here
74	QualifiedTypeDeclarationPattern pattern = (QualifiedTypeDeclarationPattern) decodedPattern;	74	QualifiedTypeDeclarationPattern pattern = (QualifiedTypeDeclarationPattern) decodedPattern;
75	switch(this.typeSuffix) {	75	switch(this.typeSuffix) {
76	case CLASS_SUFFIX :	76	case CLASS_SUFFIX :
		77	case CLASS_AND_INTERFACE_SUFFIX:
		78	case CLASS_AND_ENUM_SUFFIX:
77	case INTERFACE_SUFFIX :	79	case INTERFACE_SUFFIX :
78	case ENUM_SUFFIX :	80	case ENUM_SUFFIX :
79	case ANNOTATION_TYPE_SUFFIX :	81	case ANNOTATION_TYPE_SUFFIX :
Lines 143-148 Link Here
143	case CLASS_SUFFIX :	145	case CLASS_SUFFIX :
144	output.append("MultiClassDeclarationPattern: "); //$NON-NLS-1$	146	output.append("MultiClassDeclarationPattern: "); //$NON-NLS-1$
145	break;	147	break;
		148	case CLASS_AND_INTERFACE_SUFFIX :
		149	output.append("MultiClassAndInterfaceDeclarationPattern: "); //$NON-NLS-1$
		150	break;
		151	case CLASS_AND_ENUM_SUFFIX :
		152	output.append("MultiClassAndEnumDeclarationPattern: "); //$NON-NLS-1$
		153	break;
146	case INTERFACE_SUFFIX :	154	case INTERFACE_SUFFIX :
147	output.append("MultiInterfaceDeclarationPattern: "); //$NON-NLS-1$	155	output.append("MultiInterfaceDeclarationPattern: "); //$NON-NLS-1$
148	break;	156	break;

Lines 26-32 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/QualifiedTypeDeclarationPattern.java (-1 / +9 lines)
26	this.simpleName = isCaseSensitive() ? simpleName : CharOperation.toLowerCase(simpleName);	26	this.simpleName = isCaseSensitive() ? simpleName : CharOperation.toLowerCase(simpleName);
27	this.typeSuffix = typeSuffix;	27	this.typeSuffix = typeSuffix;
28		28
29	((InternalSearchPattern)this).mustResolve = this.qualification != null;	29	((InternalSearchPattern)this).mustResolve = this.qualification != null \|\| typeSuffix != TYPE_SUFFIX;
30	}	30	}
31	QualifiedTypeDeclarationPattern(int matchRule) {	31	QualifiedTypeDeclarationPattern(int matchRule) {
32	super(matchRule);	32	super(matchRule);
Lines 75-80 Link Here
75	QualifiedTypeDeclarationPattern pattern = (QualifiedTypeDeclarationPattern) decodedPattern;	75	QualifiedTypeDeclarationPattern pattern = (QualifiedTypeDeclarationPattern) decodedPattern;
76	switch(this.typeSuffix) {	76	switch(this.typeSuffix) {
77	case CLASS_SUFFIX :	77	case CLASS_SUFFIX :
		78	case CLASS_AND_INTERFACE_SUFFIX :
		79	case CLASS_AND_ENUM_SUFFIX :
78	case INTERFACE_SUFFIX :	80	case INTERFACE_SUFFIX :
79	case ENUM_SUFFIX :	81	case ENUM_SUFFIX :
80	case ANNOTATION_TYPE_SUFFIX :	82	case ANNOTATION_TYPE_SUFFIX :
Lines 88-93 Link Here
88	case CLASS_SUFFIX :	90	case CLASS_SUFFIX :
89	output.append("ClassDeclarationPattern: qualification<"); //$NON-NLS-1$	91	output.append("ClassDeclarationPattern: qualification<"); //$NON-NLS-1$
90	break;	92	break;
		93	case CLASS_AND_INTERFACE_SUFFIX:
		94	output.append("ClassAndInterfaceDeclarationPattern: qualification<"); //$NON-NLS-1$
		95	break;
		96	case CLASS_AND_ENUM_SUFFIX :
		97	output.append("ClassAndEnumDeclarationPattern: qualification<"); //$NON-NLS-1$
		98	break;
91	case INTERFACE_SUFFIX :	99	case INTERFACE_SUFFIX :
92	output.append("InterfaceDeclarationPattern: qualification<"); //$NON-NLS-1$	100	output.append("InterfaceDeclarationPattern: qualification<"); //$NON-NLS-1$
93	break;	101	break;

Lines 52-61 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeDeclarationLocator.java (-2 / +14 lines)
52		52
53	switch (this.pattern.typeSuffix) {	53	switch (this.pattern.typeSuffix) {
54	case CLASS_SUFFIX:	54	case CLASS_SUFFIX:
55	if (type.isInterface()) return IMPOSSIBLE_MATCH;	55	if (!type.isClass()) return IMPOSSIBLE_MATCH;
		56	break;
		57	case CLASS_AND_INTERFACE_SUFFIX:
		58	if (!(type.isClass() \|\| (type.isInterface() && !type.isAnnotationType()))) return IMPOSSIBLE_MATCH;
		59	break;
		60	case CLASS_AND_ENUM_SUFFIX:
		61	if (!(type.isClass() \|\| type.isEnum())) return IMPOSSIBLE_MATCH;
56	break;	62	break;
57	case INTERFACE_SUFFIX:	63	case INTERFACE_SUFFIX:
58	if (!type.isInterface()) return IMPOSSIBLE_MATCH;	64	if (!type.isInterface() \|\| type.isAnnotationType()) return IMPOSSIBLE_MATCH;
		65	break;
		66	case ENUM_SUFFIX:
		67	if (!type.isEnum()) return IMPOSSIBLE_MATCH;
		68	break;
		69	case ANNOTATION_TYPE_SUFFIX:
		70	if (!type.isAnnotationType()) return IMPOSSIBLE_MATCH;
59	break;	71	break;
60	case TYPE_SUFFIX : // nothing	72	case TYPE_SUFFIX : // nothing
61	}	73	}

Lines 143-149 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeDeclarationPattern.java (-1 / +11 lines)
143	this.simpleName = isCaseSensitive() ? simpleName : CharOperation.toLowerCase(simpleName);	143	this.simpleName = isCaseSensitive() ? simpleName : CharOperation.toLowerCase(simpleName);
144	this.typeSuffix = typeSuffix;	144	this.typeSuffix = typeSuffix;
145		145
146	((InternalSearchPattern)this).mustResolve = this.pkg != null && this.enclosingTypeNames != null;	146	((InternalSearchPattern)this).mustResolve = (this.pkg != null && this.enclosingTypeNames != null) \|\| typeSuffix != TYPE_SUFFIX;
147	}	147	}
148	TypeDeclarationPattern(int matchRule) {	148	TypeDeclarationPattern(int matchRule) {
149	super(TYPE_DECL_PATTERN, matchRule);	149	super(TYPE_DECL_PATTERN, matchRule);
Lines 203-208 Link Here
203	TypeDeclarationPattern pattern = (TypeDeclarationPattern) decodedPattern;	203	TypeDeclarationPattern pattern = (TypeDeclarationPattern) decodedPattern;
204	switch(this.typeSuffix) {	204	switch(this.typeSuffix) {
205	case CLASS_SUFFIX :	205	case CLASS_SUFFIX :
		206	case CLASS_AND_INTERFACE_SUFFIX :
		207	case CLASS_AND_ENUM_SUFFIX :
206	case INTERFACE_SUFFIX :	208	case INTERFACE_SUFFIX :
207	case ENUM_SUFFIX :	209	case ENUM_SUFFIX :
208	case ANNOTATION_TYPE_SUFFIX :	210	case ANNOTATION_TYPE_SUFFIX :
Lines 251-256 Link Here
251	if (this.simpleName == null) {	253	if (this.simpleName == null) {
252	switch(this.typeSuffix) {	254	switch(this.typeSuffix) {
253	case CLASS_SUFFIX :	255	case CLASS_SUFFIX :
		256	case CLASS_AND_INTERFACE_SUFFIX :
		257	case CLASS_AND_ENUM_SUFFIX :
254	case INTERFACE_SUFFIX :	258	case INTERFACE_SUFFIX :
255	case ENUM_SUFFIX :	259	case ENUM_SUFFIX :
256	case ANNOTATION_TYPE_SUFFIX :	260	case ANNOTATION_TYPE_SUFFIX :
Lines 276-281 Link Here
276	case CLASS_SUFFIX :	280	case CLASS_SUFFIX :
277	output.append("ClassDeclarationPattern: pkg<"); //$NON-NLS-1$	281	output.append("ClassDeclarationPattern: pkg<"); //$NON-NLS-1$
278	break;	282	break;
		283	case CLASS_AND_INTERFACE_SUFFIX:
		284	output.append("ClassAndInterfaceDeclarationPattern: pkg<"); //$NON-NLS-1$
		285	break;
		286	case CLASS_AND_ENUM_SUFFIX :
		287	output.append("ClassAndEnumDeclarationPattern: pkg<"); //$NON-NLS-1$
		288	break;
279	case INTERFACE_SUFFIX :	289	case INTERFACE_SUFFIX :
280	output.append("InterfaceDeclarationPattern: pkg<"); //$NON-NLS-1$	290	output.append("InterfaceDeclarationPattern: pkg<"); //$NON-NLS-1$
281	break;	291	break;

Return to bug 82208

Lines 246-260 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ClassFileMatchLocator.java (-4 / +9 lines)
246	if (!checkTypeName(pattern.simpleName, patternString, fullyQualifiedTypeName, pattern.isCaseSensitive())) return false;	246	if (!checkTypeName(pattern.simpleName, patternString, fullyQualifiedTypeName, pattern.isCaseSensitive())) return false;
247	}	247	}
248		248
		249	int kind = type.getKind();
249	switch (pattern.typeSuffix) {	250	switch (pattern.typeSuffix) {
250	case CLASS_SUFFIX:	251	case CLASS_SUFFIX:
251	return type.getKind() == IGenericType.CLASS_DECL;	252	return kind == IGenericType.CLASS_DECL;
252	case INTERFACE_SUFFIX:	253	case INTERFACE_SUFFIX:
253	return type.getKind() == IGenericType.INTERFACE_DECL;	254	return kind == IGenericType.INTERFACE_DECL;
254	case ENUM_SUFFIX:	255	case ENUM_SUFFIX:
255	return type.getKind() == IGenericType.ENUM_DECL;	256	return kind == IGenericType.ENUM_DECL;
256	case ANNOTATION_TYPE_SUFFIX:	257	case ANNOTATION_TYPE_SUFFIX:
257	return type.getKind() == IGenericType.ANNOTATION_TYPE_DECL;	258	return kind == IGenericType.ANNOTATION_TYPE_DECL;
		259	case CLASS_AND_INTERFACE_SUFFIX:
		260	return kind == IGenericType.CLASS_DECL \|\| kind == IGenericType.INTERFACE_DECL;
		261	case CLASS_AND_ENUM_SUFFIX:
		262	return kind == IGenericType.CLASS_DECL \|\| kind == IGenericType.ENUM_DECL;
258	case TYPE_SUFFIX: // nothing	263	case TYPE_SUFFIX: // nothing
259	}	264	}
260	return true;	265	return true;