Attachment #38116 for bug #124489

Lines 144-150 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodPattern.java (-1 / +2 lines)
144	String genericDeclaringTypeSignature = null;	144	String genericDeclaringTypeSignature = null;
145	// String genericSignature = null;	145	// String genericSignature = null;
146	String key;	146	String key;
147	if (method.isResolved() && (new BindingKey(key = method.getKey())).isParameterizedType()) {	147	BindingKey bindingKey;
		148	if (method.isResolved() && ((bindingKey = new BindingKey(key = method.getKey())).isParameterizedType() \|\| bindingKey.isRawType())) {
148	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);	149	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
149	} else {	150	} else {
150	methodParameters = true;	151	methodParameters = true;




	char[][] extractMethodArguments(IMethod method) {
		String[] argumentsSignatures = null;
		BindingKey key;
		if (method.isResolved() && ((key = new BindingKey(method.getKey())).isParameterizedType() || key.isRawType())) {
			argumentsSignatures = key.getTypeArguments();
		} else {
			try {
				ITypeParameter[] parameters = method.getTypeParameters();
				if (parameters != null) {
					int length = parameters.length;
					if (length > 0) {
						char[][] arguments = new char[length][];
						for (int i=0; i<length; i++) {
							arguments[i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
						}
						return arguments;
					}
				}
			}
			catch (JavaModelException jme) {
				// do nothing
			}
			return null;
		}
		/*
		 * If the method has no generic information, don't add any to the
		 * pattern!  See comment in storeTypeSignaturesAndArguments.
		 */

		// Parameterized method
		if (argumentsSignatures != null) {

	 */
	void storeTypeSignaturesAndArguments(IType type) {
		BindingKey key;
		if (type.isResolved() && ((key = new BindingKey(type.getKey())).isParameterizedType() || key.isRawType())) {
			String signature = key.toSignature();
			this.typeSignatures = Util.splitTypeLevelsSignature(signature);
			setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
		} else {
			// Scan hierachy to store type arguments at each level
			char[][][] typeParameters = new char[10][][];
			int ptr = -1;
			boolean hasParameters = false;
			try {
				IJavaElement parent = type;
				ITypeParameter[] parameters = null;
				while (parent != null && parent.getElementType() == IJavaElement.TYPE) {
					if (++ptr > typeParameters.length) {
						System.arraycopy(typeParameters, 0, typeParameters = new char[typeParameters.length+10][][], 0, ptr);
					}
					IType parentType = (IType) parent;
					parameters = parentType.getTypeParameters();
					if (parameters !=null) {
						int length = parameters.length;
						if (length > 0) {
							hasParameters = true;
							typeParameters[ptr] = new char[length][];
							for (int i=0; i<length; i++)
								typeParameters[ptr][i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
						}
					}
					parent = parent.getParent();
				}
			}
			catch (JavaModelException jme) {
				return;
			}
			// Store type arguments if any
			if (hasParameters) {
				if (++ptr < typeParameters.length)
					System.arraycopy(typeParameters, 0, typeParameters = new char[ptr][][], 0, ptr);
				setTypeArguments(typeParameters);
			}
		}
		/*
		 * If the type has no generic information, don't add any to the pattern!
		 * This way, a search for references to Collection can find
		 * "Collection<Integer>", not just "Collection<E>" (which is unlikely to
		 * occur outside the source for Collection anyway).  See bug 124489.
		 */
	}
	public final String toString() {
		return print(new StringBuffer(30)).toString();

Lines 122-128 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.java (-1 / +2 lines)
122	// Get unique key for parameterized constructors	122	// Get unique key for parameterized constructors
123	String genericDeclaringTypeSignature = null;	123	String genericDeclaringTypeSignature = null;
124	String key;	124	String key;
125	if (method.isResolved() && new BindingKey(key = method.getKey()).isParameterizedType()) {	125	BindingKey bindingKey;
		126	if (method.isResolved() && ((bindingKey = new BindingKey(key = method.getKey())).isParameterizedType() \|\| bindingKey.isRawType())) {
126	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);	127	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
127	} else {	128	} else {
128	constructorParameters = true;	129	constructorParameters = true;

Return to bug 124489

Lines 110-136 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/JavaSearchPattern.java (-55 / +12 lines)
110	char[][] extractMethodArguments(IMethod method) {	110	char[][] extractMethodArguments(IMethod method) {
111	String[] argumentsSignatures = null;	111	String[] argumentsSignatures = null;
112	BindingKey key;	112	BindingKey key;
113	if (method.isResolved() && (key = new BindingKey(method.getKey())).isParameterizedType()) {	113	if (method.isResolved() && ((key = new BindingKey(method.getKey())).isParameterizedType() \|\| key.isRawType())) {
114	argumentsSignatures = key.getTypeArguments();	114	argumentsSignatures = key.getTypeArguments();
115	} else {
116	try {
117	ITypeParameter[] parameters = method.getTypeParameters();
118	if (parameters != null) {
119	int length = parameters.length;
120	if (length > 0) {
121	char[][] arguments = new char[length][];
122	for (int i=0; i<length; i++) {
123	arguments[i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
124	}
125	return arguments;
126	}
127	}
128	}
129	catch (JavaModelException jme) {
130	// do nothing
131	}
132	return null;
133	}	115	}
		116	/*
		117	* If the method has no generic information, don't add any to the
		118	* pattern! See comment in storeTypeSignaturesAndArguments.
		119	*/
134		120
135	// Parameterized method	121	// Parameterized method
136	if (argumentsSignatures != null) {	122	if (argumentsSignatures != null) {
Lines 240-285 Link Here
240	*/	226	*/
241	void storeTypeSignaturesAndArguments(IType type) {	227	void storeTypeSignaturesAndArguments(IType type) {
242	BindingKey key;	228	BindingKey key;
243	if (type.isResolved() && (key = new BindingKey(type.getKey())).isParameterizedType()) {	229	if (type.isResolved() && ((key = new BindingKey(type.getKey())).isParameterizedType() \|\| key.isRawType())) {
244	String signature = key.toSignature();	230	String signature = key.toSignature();
245	this.typeSignatures = Util.splitTypeLevelsSignature(signature);	231	this.typeSignatures = Util.splitTypeLevelsSignature(signature);
246	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));	232	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
247	} else {
248	// Scan hierachy to store type arguments at each level
249	char[][][] typeParameters = new char[10][][];
250	int ptr = -1;
251	boolean hasParameters = false;
252	try {
253	IJavaElement parent = type;
254	ITypeParameter[] parameters = null;
255	while (parent != null && parent.getElementType() == IJavaElement.TYPE) {
256	if (++ptr > typeParameters.length) {
257	System.arraycopy(typeParameters, 0, typeParameters = new char[typeParameters.length+10][][], 0, ptr);
258	}
259	IType parentType = (IType) parent;
260	parameters = parentType.getTypeParameters();
261	if (parameters !=null) {
262	int length = parameters.length;
263	if (length > 0) {
264	hasParameters = true;
265	typeParameters[ptr] = new char[length][];
266	for (int i=0; i<length; i++)
267	typeParameters[ptr][i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
268	}
269	}
270	parent = parent.getParent();
271	}
272	}
273	catch (JavaModelException jme) {
274	return;
275	}
276	// Store type arguments if any
277	if (hasParameters) {
278	if (++ptr < typeParameters.length)
279	System.arraycopy(typeParameters, 0, typeParameters = new char[ptr][][], 0, ptr);
280	setTypeArguments(typeParameters);
281	}
282	}	233	}
		234	/*
		235	* If the type has no generic information, don't add any to the pattern!
		236	* This way, a search for references to Collection can find
		237	* "Collection<Integer>", not just "Collection<E>" (which is unlikely to
		238	* occur outside the source for Collection anyway). See bug 124489.
		239	*/
283	}	240	}
284	public final String toString() {	241	public final String toString() {
285	return print(new StringBuffer(30)).toString();	242	return print(new StringBuffer(30)).toString();