Attachment #84733 for bug #209993

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




	 * and type parameters for non-generic ones.
	 */
	char[][] extractMethodArguments(IMethod method) {

		// Use bind key if the element is resolved
		if (method.isResolved()) {
			BindingKey bindingKey = new BindingKey(method.getKey());
			if (bindingKey.isParameterizedMethod()) {
				String[] argumentsSignatures = bindingKey.getTypeArguments();
				int length = argumentsSignatures.length;
				if (length > 0) {
					char[][] methodArguments = new char[length][];
					for (int i=0; i<length; i++) {
						methodArguments[i] = argumentsSignatures[i].toCharArray();
						CharOperation.replace(methodArguments[i], new char[] { '$', '/' }, '.');
							arguments[i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
						}
						return arguments;
					}
					return methodArguments;
				}
			}
			catch (JavaModelException jme) {
				// do nothing
			}
			return null;
		}
		
		// Try to get the argument using the JavaModel info
		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;
				}
				return methodArguments;
			}
		}
		catch (JavaModelException jme) {
			// do nothing
		}
		return null;
	}


	 * and type parameters for non-generic ones
	 */
	void storeTypeSignaturesAndArguments(IType type) {
		if (type.isResolved()) {
			BindingKey bindingKey = new BindingKey(type.getKey());
			if (bindingKey.isParameterizedType() || bindingKey.isRawType()) {
				String signature = bindingKey.toSignature();
				this.typeSignatures = Util.splitTypeLevelsSignature(signature);
				setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
			}
			return;
		}

		// Scan hierarchy 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();
				}
				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);
		}
	}
	public final String toString() {





	// Get unique key for parameterized constructors
	String genericDeclaringTypeSignature = null;
	if (method.isResolved()) {
		String key = method.getKey();
		BindingKey bindingKey = new BindingKey(key);
		if (bindingKey.isParameterizedType()) {
			genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
			// Store type signature and arguments for declaring type
			if (genericDeclaringTypeSignature != null) {
					this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
					setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
			}
		}
		setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
	} else {
		this.constructorParameters = true;
		storeTypeSignaturesAndArguments(method.getDeclaringType());
	}






	// Get unique key for parameterized constructors
	String genericDeclaringTypeSignature = null;
	if (method.isResolved()) {
		String key = method.getKey();
		BindingKey bindingKey = new BindingKey(key);
		if (bindingKey.isParameterizedType()) {
			genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
			// Store type signature and arguments for declaring type
			if (genericDeclaringTypeSignature != null) {
					this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
					setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
			}
		}
	} else {
		methodParameters = true;
	}

	// Store type signature and arguments for declaring type
	if (genericDeclaringTypeSignature != null) {
		this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
		setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
	} else {
		storeTypeSignaturesAndArguments(declaringType);
	}


Lines 48-54 Link Here

(-)buildnotes_jdt-core.html (-1 / +5 lines)
48	<h2>What's new in this drop</h2>	48	<h2>What's new in this drop</h2>
49		49
50	<h3>Problem Reports Fixed</h3>	50	<h3>Problem Reports Fixed</h3>
51	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=211781">211781</a>	51	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=209993">209993</a>
		52	[1.5][search] Generic search does not work properly while using BindingKey
		53	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=209993">209993</a>
		54	[1.5][search] Generic search does not work properly while using BindingKey
		55	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=211781">211781</a>
52	[search] clarify 'ALLOCATION_EXPRESSION_TYPE_REFERENCE'	56	[search] clarify 'ALLOCATION_EXPRESSION_TYPE_REFERENCE'
53	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=211779">211779</a>	57	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=211779">211779</a>
54	[search] better name for SUPERTYPE_TYPE_REFERENCE?	58	[search] better name for SUPERTYPE_TYPE_REFERENCE?

Return to bug 209993

Lines 191-232 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/JavaSearchPattern.java (-65 / +69 lines)
191	* and type parameters for non-generic ones.	191	* and type parameters for non-generic ones.
192	*/	192	*/
193	char[][] extractMethodArguments(IMethod method) {	193	char[][] extractMethodArguments(IMethod method) {
194	String[] argumentsSignatures = null;	194
195	BindingKey key;	195	// Use bind key if the element is resolved
196	if (method.isResolved() && (key = new BindingKey(method.getKey())).isParameterizedMethod()) {	196	if (method.isResolved()) {
197	argumentsSignatures = key.getTypeArguments();	197	BindingKey bindingKey = new BindingKey(method.getKey());
198	} else {	198	if (bindingKey.isParameterizedMethod()) {
199	try {	199	String[] argumentsSignatures = bindingKey.getTypeArguments();
200	ITypeParameter[] parameters = method.getTypeParameters();	200	int length = argumentsSignatures.length;
201	if (parameters != null) {	201	if (length > 0) {
202	int length = parameters.length;	202	char[][] methodArguments = new char[length][];
203	if (length > 0) {	203	for (int i=0; i<length; i++) {
204	char[][] arguments = new char[length][];	204	methodArguments[i] = argumentsSignatures[i].toCharArray();
205	for (int i=0; i<length; i++) {	205	CharOperation.replace(methodArguments[i], new char[] { '$', '/' }, '.');
206	arguments[i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
207	}
208	return arguments;
209	}	206	}
		207	return methodArguments;
210	}	208	}
211	}	209	}
212	catch (JavaModelException jme) {
213	// do nothing
214	}
215	return null;	210	return null;
216	}	211	}
217		212
218	// Parameterized method	213	// Try to get the argument using the JavaModel info
219	if (argumentsSignatures != null) {	214	try {
220	int length = argumentsSignatures.length;	215	ITypeParameter[] parameters = method.getTypeParameters();
221	if (length > 0) {	216	if (parameters != null) {
222	char[][] methodArguments = new char[length][];	217	int length = parameters.length;
223	for (int i=0; i<length; i++) {	218	if (length > 0) {
224	methodArguments[i] = argumentsSignatures[i].toCharArray();	219	char[][] arguments = new char[length][];
225	CharOperation.replace(methodArguments[i], new char[] { '$', '/' }, '.');	220	for (int i=0; i<length; i++) {
		221	arguments[i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
		222	}
		223	return arguments;
226	}	224	}
227	return methodArguments;
228	}	225	}
229	}	226	}
		227	catch (JavaModelException jme) {
		228	// do nothing
		229	}
230	return null;	230	return null;
231	}	231	}
232		232
Lines 394-439 Link Here
394	* and type parameters for non-generic ones	394	* and type parameters for non-generic ones
395	*/	395	*/
396	void storeTypeSignaturesAndArguments(IType type) {	396	void storeTypeSignaturesAndArguments(IType type) {
397	BindingKey key;	397	if (type.isResolved()) {
398	if (type.isResolved() && ((key = new BindingKey(type.getKey())).isParameterizedType() \|\| key.isRawType())) {	398	BindingKey bindingKey = new BindingKey(type.getKey());
399	String signature = key.toSignature();	399	if (bindingKey.isParameterizedType() \|\| bindingKey.isRawType()) {
400	this.typeSignatures = Util.splitTypeLevelsSignature(signature);	400	String signature = bindingKey.toSignature();
401	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));	401	this.typeSignatures = Util.splitTypeLevelsSignature(signature);
402	} else {	402	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
403	// Scan hierachy to store type arguments at each level	403	}
404	char[][][] typeParameters = new char[10][][];	404	return;
405	int ptr = -1;	405	}
406	boolean hasParameters = false;	406
407	try {	407	// Scan hierarchy to store type arguments at each level
408	IJavaElement parent = type;	408	char[][][] typeParameters = new char[10][][];
409	ITypeParameter[] parameters = null;	409	int ptr = -1;
410	while (parent != null && parent.getElementType() == IJavaElement.TYPE) {	410	boolean hasParameters = false;
411	if (++ptr > typeParameters.length) {	411	try {
412	System.arraycopy(typeParameters, 0, typeParameters = new char[typeParameters.length+10][][], 0, ptr);	412	IJavaElement parent = type;
413	}	413	ITypeParameter[] parameters = null;
414	IType parentType = (IType) parent;	414	while (parent != null && parent.getElementType() == IJavaElement.TYPE) {
415	parameters = parentType.getTypeParameters();	415	if (++ptr > typeParameters.length) {
416	if (parameters !=null) {	416	System.arraycopy(typeParameters, 0, typeParameters = new char[typeParameters.length+10][][], 0, ptr);
417	int length = parameters.length;	417	}
418	if (length > 0) {	418	IType parentType = (IType) parent;
419	hasParameters = true;	419	parameters = parentType.getTypeParameters();
420	typeParameters[ptr] = new char[length][];	420	if (parameters !=null) {
421	for (int i=0; i<length; i++)	421	int length = parameters.length;
422	typeParameters[ptr][i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();	422	if (length > 0) {
423	}	423	hasParameters = true;
		424	typeParameters[ptr] = new char[length][];
		425	for (int i=0; i<length; i++)
		426	typeParameters[ptr][i] = Signature.createTypeSignature(parameters[i].getElementName(), false).toCharArray();
424	}	427	}
425	parent = parent.getParent();
426	}	428	}
		429	parent = parent.getParent();
427	}	430	}
428	catch (JavaModelException jme) {	431	}
429	return;	432	catch (JavaModelException jme) {
430	}	433	return;
431	// Store type arguments if any	434	}
432	if (hasParameters) {	435
433	if (++ptr < typeParameters.length)	436	// Store type arguments if any
434	System.arraycopy(typeParameters, 0, typeParameters = new char[ptr][][], 0, ptr);	437	if (hasParameters) {
435	setTypeArguments(typeParameters);	438	if (++ptr < typeParameters.length)
436	}	439	System.arraycopy(typeParameters, 0, typeParameters = new char[ptr][][], 0, ptr);
		440	setTypeArguments(typeParameters);
437	}	441	}
438	}	442	}
439	public final String toString() {	443	public final String toString() {

Lines 143-161 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.java (-12 / +12 lines)
143		143
144	// Get unique key for parameterized constructors	144	// Get unique key for parameterized constructors
145	String genericDeclaringTypeSignature = null;	145	String genericDeclaringTypeSignature = null;
146	String key;	146	if (method.isResolved()) {
147	BindingKey bindingKey;	147	String key = method.getKey();
148	if (method.isResolved() && ((bindingKey = new BindingKey(key = method.getKey())).isParameterizedType() \|\| bindingKey.isParameterizedMethod())) {	148	BindingKey bindingKey = new BindingKey(key);
149	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);	149	if (bindingKey.isParameterizedType()) {
150	} else {	150	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
151	constructorParameters = true;	151	// Store type signature and arguments for declaring type
152	}	152	if (genericDeclaringTypeSignature != null) {
153		153	this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
154	// Store type signature and arguments for declaring type	154	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
155	if (genericDeclaringTypeSignature != null) {	155	}
156	this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);	156	}
157	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
158	} else {	157	} else {
		158	this.constructorParameters = true;
159	storeTypeSignaturesAndArguments(method.getDeclaringType());	159	storeTypeSignaturesAndArguments(method.getDeclaringType());
160	}	160	}
161		161

Lines 158-176 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodPattern.java (-11 / +11 lines)
158		158
159	// Get unique key for parameterized constructors	159	// Get unique key for parameterized constructors
160	String genericDeclaringTypeSignature = null;	160	String genericDeclaringTypeSignature = null;
161	// String genericSignature = null;	161	if (method.isResolved()) {
162	String key;	162	String key = method.getKey();
163	if (method.isResolved() && (new BindingKey(key = method.getKey())).isParameterizedMethod()) {	163	BindingKey bindingKey = new BindingKey(key);
164	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);	164	if (bindingKey.isParameterizedType()) {
		165	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
		166	// Store type signature and arguments for declaring type
		167	if (genericDeclaringTypeSignature != null) {
		168	this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
		169	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
		170	}
		171	}
165	} else {	172	} else {
166	methodParameters = true;	173	methodParameters = true;
167	}
168
169	// Store type signature and arguments for declaring type
170	if (genericDeclaringTypeSignature != null) {
171	this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
172	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
173	} else {
174	storeTypeSignaturesAndArguments(declaringType);	174	storeTypeSignaturesAndArguments(declaringType);
175	}	175	}
176		176