Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
  
  package org.eclipse.jdt.internal.core;
  
  
Implementation of ISelectionRequestor to assist with code resolve in a compilation unit. Translates names to elements.
  
  public class SelectionRequestor implements ISelectionRequestor {
  	/*
  	 * The name lookup facility used to resolve packages
  	 */
  	protected NameLookup nameLookup;
  
  	/*
  	 * The compilation unit or class file we are resolving in
  	 */
  	protected Openable openable;
  
  	/*
  	 * The collection of resolved elements.
  	 */
  	protected int elementIndex = -1;
  
  	protected HandleFactory handleFactory = new HandleFactory();

Creates a selection requestor that uses that given name lookup facility to resolve names. Fix for 1FVXGDK
  
  public SelectionRequestor(NameLookup nameLookupOpenable openable) {
  	super();
  	this. = nameLookup;
  	this. = openable;
  }
  private void acceptBinaryMethod(
  		IType type,
  		IMethod method,
  		char[] uniqueKey,
  		boolean isConstructor) {
  	try {
  		if(!isConstructor || ((JavaElement)method).getClassFile().getBuffer() == null) {
  			if (uniqueKey != null) {
  				ResolvedBinaryMethod resolvedMethod = new ResolvedBinaryMethod(
  						(JavaElement)method.getParent(),
  						method.getElementName(),
  						method.getParameterTypes(),
  						new String(uniqueKey));
  				resolvedMethod.occurrenceCount = method.getOccurrenceCount();
  				method = resolvedMethod;
  			}
  
  			addElement(method);
  				..print("SELECTION - accept method("); //$NON-NLS-1$
  				..print(method.toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		} else {
 			ISourceRange range = method.getSourceRange();
 			if (range.getOffset() != -1 && range.getLength() != 0 ) {
 				if (uniqueKey != null) {
 					ResolvedBinaryMethod resolvedMethod = new ResolvedBinaryMethod(
 							method.getElementName(),
 							new String(uniqueKey));
 					resolvedMethod.occurrenceCount = method.getOccurrenceCount();
 					method = resolvedMethod;
 				}
 				addElement(method);
 					..print("SELECTION - accept method("); //$NON-NLS-1$
 					..print(method.toString());
 					..println(")"); //$NON-NLS-1$
 				}
 			} else {
 				// no range was actually found, but a method was originally given -> default constructor
 				addElement(type);
 					..print("SELECTION - accept type("); //$NON-NLS-1$
 					..println(")"); //$NON-NLS-1$
 				}
 			}
 		}
 	} catch (JavaModelException e) {
 		// an exception occurs, return nothing
 	}
 }
Resolve the binary method fix for 1FWFT6Q
 
 protected void acceptBinaryMethod(
 		IType type,
 		char[] selector,
 		char[][] parameterPackageNames,
 		char[][] parameterTypeNames,
 		String[] parameterSignatures,
 		char[][] typeParameterNames,
 		char[][][] typeParameterBoundNames,
 		char[] uniqueKey,
 		boolean isConstructor) {
 	IMethod methodtype.getMethod(new String(selector), parameterSignatures);
 
 	if (method.exists()) {
 		if (typeParameterNames != null && typeParameterNames.length != 0) {
 			IMethod[] methods = type.findMethods(method);
 			if (methods != null && methods.length > 1) {
 				for (int i = 0; i < methods.lengthi++) {
 					if (areTypeParametersCompatible(methods[i], typeParameterNamestypeParameterBoundNames)) {
 						acceptBinaryMethod(typemethoduniqueKeyisConstructor);
 					}
 				}
 				return;
 			}
 		}
 		acceptBinaryMethod(typemethoduniqueKeyisConstructor);
 	}
 }
Resolve the type.
 
 public void acceptType(char[] packageNamechar[] typeNameint modifiersboolean isDeclarationchar[] uniqueKeyint startint end) {
 	int acceptFlags = 0;
 	switch (kind) {
 			acceptFlags = .;
 			break;
 			acceptFlags = .;
 			break;
 			acceptFlags = .;
 			break;
 		default:
 			acceptFlags = .;
 			break;
 	}
 	IType type = null;
 	if(isDeclaration) {
 		type = resolveTypeByLocation(packageNametypeNameacceptFlagsstartend);
 	} else {
 		type = resolveType(packageNametypeNameacceptFlags);
 		if(type != null ) {
 			String key = uniqueKey == null ? type.getKey() : new String(uniqueKey);
 			if(type.isBinary()) {
 				ResolvedBinaryType resolvedType = new ResolvedBinaryType((JavaElement)type.getParent(), type.getElementName(), key);
 				resolvedType.occurrenceCount = type.getOccurrenceCount();
 				type = resolvedType;
 			} else {
 				ResolvedSourceType resolvedType = new ResolvedSourceType((JavaElement)type.getParent(), type.getElementName(), key);
 				resolvedType.occurrenceCount = type.getOccurrenceCount();
 				type = resolvedType;
 			}
 		}
 	}
 
 	if (type != null) {
 		addElement(type);
 			..print("SELECTION - accept type("); //$NON-NLS-1$
 			..println(")"); //$NON-NLS-1$
 		}
 	}
 }
Resolve the type.
 
 public void acceptType(IType type) {
 	String key = type.getKey();
 	if(type.isBinary()) {
 		ResolvedBinaryType resolvedType = new ResolvedBinaryType((JavaElement)type.getParent(), type.getElementName(), key);
 		resolvedType.occurrenceCount = type.getOccurrenceCount();
 		type = resolvedType;
 	} else {
 		ResolvedSourceType resolvedType = new ResolvedSourceType((JavaElement)type.getParent(), type.getElementName(), key);
 		resolvedType.occurrenceCount = type.getOccurrenceCount();
 		type = resolvedType;
 	}
 
 	addElement(type);
 		..print("SELECTION - accept type("); //$NON-NLS-1$
 		..println(")"); //$NON-NLS-1$
 	}
 }
 
 public void acceptError(CategorizedProblem error) {
 	// do nothing
 }
Resolve the field.
 
 public void acceptField(char[] declaringTypePackageNamechar[] declaringTypeNamechar[] nameboolean isDeclarationchar[] uniqueKeyint startint end) {
 	if(isDeclaration) {
 		IType typeresolveTypeByLocation(declaringTypePackageNamedeclaringTypeName,
 				startend);
 		if(type != null) {
 			try {
 				IField[] fields = type.getFields();
 				for (int i = 0; i < fields.lengthi++) {
 					IField field = fields[i];
 					ISourceRange range = field.getNameRange();
 					if(range.getOffset() <= start
 							&& range.getOffset() + range.getLength() >= end
 							&& field.getElementName().equals(new String(name))) {
 						addElement(fields[i]);
 							..print("SELECTION - accept field("); //$NON-NLS-1$
 							..println(")"); //$NON-NLS-1$
 						}
 						return// only one method is possible
 					}
 				}
 			} catch (JavaModelException e) {
 				return;
 			}
 		}
 	} else {
 		IType typeresolveType(declaringTypePackageNamedeclaringTypeName.);
 		if (type != null) {
 			IField fieldtype.getField(new String(name));
 			if (field.exists()) {
 				if (uniqueKey != null) {
 					if(field.isBinary()) {
 						ResolvedBinaryField resolvedField = new ResolvedBinaryField(
 								field.getElementName(),
 								new String(uniqueKey));
 						resolvedField.occurrenceCount = field.getOccurrenceCount();
 						field = resolvedField;
 					} else {
 						ResolvedSourceField resolvedField = new ResolvedSourceField(
 								field.getElementName(),
 								new String(uniqueKey));
 						resolvedField.occurrenceCount = field.getOccurrenceCount();
 						field = resolvedField;
 					}
 				}
 				addElement(field);
 					..print("SELECTION - accept field("); //$NON-NLS-1$
 					..println(")"); //$NON-NLS-1$
 				}
 			}
 		}
 	}
 }
 public void acceptLocalField(FieldBinding fieldBinding) {
 	if(fieldBinding.declaringClass instanceof ParameterizedTypeBinding) {
 		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)fieldBinding.declaringClass).genericType();
 		res = findLocalElement(localTypeBinding.sourceStart());
 	} else {
 		SourceTypeBinding typeBinding = (SourceTypeBinding)fieldBinding.declaringClass;
 		res = findLocalElement(typeBinding.sourceStart());
 	}
 	if (res != null && res.getElementType() == .) {
 		IType type = (ITyperes;
 		IField fieldtype.getField(new String(fieldBinding.name));
 		if (field.exists()) {
 			char[] uniqueKey = fieldBinding.computeUniqueKey();
 			if(field.isBinary()) {
 				ResolvedBinaryField resolvedField = new ResolvedBinaryField(
 						field.getElementName(),
 						new String(uniqueKey));
 				resolvedField.occurrenceCount = field.getOccurrenceCount();
 				field = resolvedField;
 			} else {
 				ResolvedSourceField resolvedField = new ResolvedSourceField(
 						field.getElementName(),
 						new String(uniqueKey));
 				resolvedField.occurrenceCount = field.getOccurrenceCount();
 				field = resolvedField;
 			}
 			addElement(field);
 				..print("SELECTION - accept field("); //$NON-NLS-1$
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
 public void acceptLocalMethod(MethodBinding methodBinding) {
 	IJavaElement res = findLocalElement(methodBinding.original().sourceStart());
 	if(res != null) {
 			IMethod method = (IMethodres;
 
 			char[] uniqueKey = methodBinding.computeUniqueKey();
 			if(method.isBinary()) {
 						method.getElementName(),
 						new String(uniqueKey));
 				resolvedRes.occurrenceCount = method.getOccurrenceCount();
 				res = resolvedRes;
 			} else {
 						method.getElementName(),
 						new String(uniqueKey));
 				resolvedRes.occurrenceCount = method.getOccurrenceCount();
 				res = resolvedRes;
 			}
 			addElement(res);
 				..print("SELECTION - accept method("); //$NON-NLS-1$
 				..println(")"); //$NON-NLS-1$
 			}
 		} else if(methodBinding.selector == . && res.getElementType() == .) {
 			// it's a default constructor
 			res = ((JavaElement)res).resolved(methodBinding.declaringClass);
 			addElement(res);
 				..print("SELECTION - accept type("); //$NON-NLS-1$
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
 public void acceptLocalType(TypeBinding typeBinding) {
 	IJavaElement res =  null;
 	if(typeBinding instanceof ParameterizedTypeBinding) {
 		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeBinding).genericType();
 		res = findLocalElement(localTypeBinding.sourceStart());
 	} else if(typeBinding instanceof SourceTypeBinding) {
 		res = findLocalElement(((SourceTypeBinding)typeBinding).sourceStart());
 	}
 	if(res != null && res.getElementType() == .) {
 		res = ((JavaElement)res).resolved(typeBinding);
 		addElement(res);
 			..print("SELECTION - accept type("); //$NON-NLS-1$
 			..println(")"); //$NON-NLS-1$
 		}
 	}
 }
 public void acceptLocalTypeParameter(TypeVariableBinding typeVariableBinding) {
 	if(typeVariableBinding.declaringElement instanceof ParameterizedTypeBinding) {
 		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeVariableBinding.declaringElement).genericType();
 		res = findLocalElement(localTypeBinding.sourceStart());
 	} else {
 		SourceTypeBinding typeBinding = (SourceTypeBinding)typeVariableBinding.declaringElement;
 		res = findLocalElement(typeBinding.sourceStart());
 	}
 	if (res != null && res.getElementType() == .) {
 		IType type = (ITyperes;
 		ITypeParameter typeParameter = type.getTypeParameter(new String(typeVariableBinding.sourceName));
 		if (typeParameter.exists()) {
 			addElement(typeParameter);
 				..print("SELECTION - accept type parameter("); //$NON-NLS-1$
 				..print(typeParameter.toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
 public void acceptLocalMethodTypeParameter(TypeVariableBinding typeVariableBinding) {
 	MethodBinding methodBinding = (MethodBinding)typeVariableBinding.declaringElement;
 	IJavaElement res = findLocalElement(methodBinding.sourceStart());
 	if(res != null && res.getElementType() == .) {
 		IMethod method = (IMethodres;
 
 		ITypeParameter typeParameter = method.getTypeParameter(new String(typeVariableBinding.sourceName));
 		if (typeParameter.exists()) {
 			addElement(typeParameter);
 				..print("SELECTION - accept type parameter("); //$NON-NLS-1$
 				..print(typeParameter.toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
 public void acceptLocalVariable(LocalVariableBinding binding) {
 	LocalDeclaration local = binding.declaration;
 	IJavaElement parent = findLocalElement(local.sourceStart); // findLocalElement() cannot find local variable
 	LocalVariable localVar = null;
 	if(parent != null) {
 		localVar = new LocalVariable(
 				(JavaElement)parent,
 				new String(local.name),
 				local.declarationSourceStart,
 				local.declarationSourceEnd,
 				local.sourceStart,
 				local.sourceEnd,
 				Util.typeSignature(local.type),
 				local.annotations,
 				local.modifiers,
 	}
 	if (localVar != null) {
 		addElement(localVar);
 			..print("SELECTION - accept local variable("); //$NON-NLS-1$
 			..print(localVar.toString());
 			..println(")"); //$NON-NLS-1$
 		}
 	}
 }
Resolve the method
 
 public void acceptMethod(
 		char[] declaringTypePackageName,
 		char[] declaringTypeName,
 		String enclosingDeclaringTypeSignature,
 		char[] selector,
 		char[][] parameterPackageNames,
 		char[][] parameterTypeNames,
 		String[] parameterSignatures,
 		char[][] typeParameterNames,
 		char[][][] typeParameterBoundNames,
 		boolean isConstructor,
 		boolean isDeclaration,
 		char[] uniqueKey,
 		int start,
 		int end) {
 	IJavaElement[] previousElement = this.;
 	int previousElementIndex = this.;
 	this. = -1;
 
 	if(isDeclaration) {
 		IType type = resolveTypeByLocation(declaringTypePackageNamedeclaringTypeName,
 				startend);
 
 		if(type != null) {
 			acceptMethodDeclaration(typeselectorstartend);
 		}
 	} else {
 		IType type = resolveType(declaringTypePackageNamedeclaringTypeName,
 		// fix for 1FWFT6Q
 		if (type != null) {
 			if (type.isBinary()) {
 
 				// need to add a paramater for constructor in binary type
 				IType declaringDeclaringType = type.getDeclaringType();
 
 				boolean isStatic = false;
 				try {
 					isStatic = Flags.isStatic(type.getFlags());
 				} catch (JavaModelException e) {
 					// isStatic == false
 				}
 
 				if(declaringDeclaringType != null && isConstructor	&& !isStatic) {
 					int length = parameterPackageNames.length;
 					System.arraycopy(parameterPackageNames, 0, parameterPackageNames = new char[length+1][], 1, length);
 					System.arraycopy(parameterTypeNames, 0, parameterTypeNames = new char[length+1][], 1, length);
 					System.arraycopy(parameterSignatures, 0, parameterSignatures = new String[length+1], 1, length);
 
 					parameterPackageNames[0] = declaringDeclaringType.getPackageFragment().getElementName().toCharArray();
 					parameterTypeNames[0] = declaringDeclaringType.getTypeQualifiedName().toCharArray();
 					parameterSignatures[0] = Signature.getTypeErasure(enclosingDeclaringTypeSignature);
 				}
 
 				acceptBinaryMethod(typeselectorparameterPackageNamesparameterTypeNamesparameterSignaturestypeParameterNamestypeParameterBoundNamesuniqueKeyisConstructor);
 			} else {
 				acceptSourceMethod(typeselectorparameterPackageNamesparameterTypeNamesparameterSignaturestypeParameterNamestypeParameterBoundNamesuniqueKey);
 			}
 		}
 	}
 
 	if(previousElementIndex > -1) {
 		int elementsLength = this. + previousElementIndex + 2;
 		if(elementsLength > this..length) {
 			System.arraycopy(this., 0, this. = new IJavaElement[elementsLength * 2 + 1], 0, this. + 1);
 		}
 		System.arraycopy(previousElement, 0, this.this. + 1, previousElementIndex + 1);
 		this. += previousElementIndex + 1;
 	}
 }
Resolve the package
 
 public void acceptPackage(char[] packageName) {
 	IPackageFragment[] pkgs = this..findPackageFragments(new String(packageName), false);
 	if (pkgs != null) {
 		for (int i = 0, length = pkgs.lengthi < lengthi++) {
 			addElement(pkgs[i]);
 				..print("SELECTION - accept package("); //$NON-NLS-1$
 				..print(pkgs[i].toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
Resolve the source method fix for 1FWFT6Q
 
 protected void acceptSourceMethod(
 		IType type,
 		char[] selector,
 		char[][] parameterPackageNames,
 		char[][] parameterTypeNames,
 		String[] parameterSignatures,
 		char[][] typeParameterNames,
 		char[][][] typeParameterBoundNames,
 		char[] uniqueKey) {
 
 	String name = new String(selector);
 	IMethod[] methods = null;
 	try {
 		methods = type.getMethods();
 		for (int i = 0; i < methods.lengthi++) {
 			if (methods[i].getElementName().equals(name)
 					&& methods[i].getParameterTypes().length == parameterTypeNames.length) {
 				IMethod method = methods[i];
 				if (uniqueKey != null) {
 					ResolvedSourceMethod resolvedMethod = new ResolvedSourceMethod(
 						method.getElementName(),
 						new String(uniqueKey));
 					resolvedMethod.occurrenceCount = method.getOccurrenceCount();
 					method = resolvedMethod;
 				}
 				addElement(method);
 			}
 		}
 	} catch (JavaModelException e) {
 		return;
 	}
 
 	// if no matches, nothing to report
 	if (this. == -1) {
 		// no match was actually found, but a method was originally given -> default constructor
 		addElement(type);
 			..print("SELECTION - accept type("); //$NON-NLS-1$
 			..println(")"); //$NON-NLS-1$
 		}
 		return;
 	}
 
 	// if there is only one match, we've got it
 	if (this. == 0) {
 			..print("SELECTION - accept method("); //$NON-NLS-1$
 			..println(")"); //$NON-NLS-1$
 		}
 		return;
 	}
 
 	// more than one match - must match simple parameter types
 	IJavaElement[] matches = this.;
 	int matchesIndex = this.;
 	this. = -1;
 	for (int i = 0; i <= matchesIndexi++) {
 		IMethod method= (IMethod)matches[i];
 		String[] signatures = method.getParameterTypes();
 		boolean matchtrue;
 		for (int p = 0; p < signatures.lengthp++) {
 			String simpleName= Signature.getSimpleName(Signature.toString(Signature.getTypeErasure(signatures[p])));
 			char[] simpleParameterName = CharOperation.lastSegment(parameterTypeNames[p], '.');
 			if (!simpleName.equals(new String(simpleParameterName))) {
 				match = false;
 				break;
 			}
 		}
 
 		if (match && !areTypeParametersCompatible(methodtypeParameterNamestypeParameterBoundNames)) {
 			match = false;
 		}
 
 		if (match) {
 			addElement(method);
 				..print("SELECTION - accept method("); //$NON-NLS-1$
 				..print(method.toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 
 }
 protected void acceptMethodDeclaration(IType typechar[] selectorint startint end) {
 	String name = new String(selector);
 	IMethod[] methods = null;
 	try {
 		methods = type.getMethods();
 		for (int i = 0; i < methods.lengthi++) {
 			ISourceRange range = methods[i].getNameRange();
 			if(range.getOffset() <= start
 					&& range.getOffset() + range.getLength() >= end
 					&& methods[i].getElementName().equals(name)) {
 				addElement(methods[i]);
 					..print("SELECTION - accept method("); //$NON-NLS-1$
 					..println(")"); //$NON-NLS-1$
 				}
 				return// only one method is possible
 			}
 		}
 	} catch (JavaModelException e) {
 		return;
 	}
 
 	// no match was actually found
 	addElement(type);
 		..print("SELECTION - accept type("); //$NON-NLS-1$
 		..println(")"); //$NON-NLS-1$
 	}
 	return;
 }
 public void acceptTypeParameter(char[] declaringTypePackageNamechar[] declaringTypeNamechar[] typeParameterNameboolean isDeclarationint startint end) {
 	IType type;
 	if(isDeclaration) {
 		type = resolveTypeByLocation(declaringTypePackageNamedeclaringTypeName,
 				startend);
 	} else {
 		type = resolveType(declaringTypePackageNamedeclaringTypeName,
 	}
 
 	if(type != null) {
 		ITypeParameter typeParameter = type.getTypeParameter(new String(typeParameterName));
 		if(typeParameter == null) {
 			addElement(type);
 				..print("SELECTION - accept type("); //$NON-NLS-1$
 				..println(")"); //$NON-NLS-1$
 			}
 		} else {
 			addElement(typeParameter);
 				..print("SELECTION - accept type parameter("); //$NON-NLS-1$
 				..print(typeParameter.toString());
 				..println(")"); //$NON-NLS-1$
 			}
 		}
 	}
 }
 public void acceptMethodTypeParameter(char[] declaringTypePackageNamechar[] declaringTypeNamechar[] selector,int selectorStartint selectorEndchar[] typeParameterNameboolean isDeclarationint startint end) {
 	IType type = resolveTypeByLocation(declaringTypePackageNamedeclaringTypeName,
 			selectorStartselectorEnd);
 
 	if(type != null) {
 		IMethod method = null;
 
 		String name = new String(selector);
 		IMethod[] methods = null;
 
 		try {
 			methods = type.getMethods();
 			done : for (int i = 0; i < methods.lengthi++) {
 				ISourceRange range = methods[i].getNameRange();
 				if(range.getOffset() >= selectorStart
 						&& range.getOffset() + range.getLength() <= selectorEnd
 						&& methods[i].getElementName().equals(name)) {
 					method = methods[i];
 					break done;
 				}
 			}
 		} catch (JavaModelException e) {
 			//nothing to do
 		}
 
 		if(method == null) {
 			addElement(type);
 				..print("SELECTION - accept type("); //$NON-NLS-1$
 				..println(")"); //$NON-NLS-1$
 			}
 		} else {
 			ITypeParameter typeParameter = method.getTypeParameter(new String(typeParameterName));
 			if(typeParameter == null) {
 				addElement(method);
 					..print("SELECTION - accept method("); //$NON-NLS-1$
 					..print(method.toString());
 					..println(")"); //$NON-NLS-1$
 				}
 			} else {
 				addElement(typeParameter);
 					..print("SELECTION - accept method type parameter("); //$NON-NLS-1$
 					..print(typeParameter.toString());
 					..println(")"); //$NON-NLS-1$
 				}
 			}
 		}
 	}
 }
 /*
  * Adds the given element to the list of resolved elements.
  */
 protected void addElement(IJavaElement element) {
 	int elementLength = this. + 1;
 
 	for (int i = 0; i < elementLengthi++) {
 		if (this.[i].equals(element)) {
 			return;
 		}
 	}
 
 	if (elementLength == this..length) {
 		System.arraycopy(this., 0, this. = new IJavaElement[(elementLength*2) + 1], 0, elementLength);
 	}
 	this.[++this.] = element;
 }
 private boolean areTypeParametersCompatible(IMethod methodchar[][] typeParameterNameschar[][][] typeParameterBoundNames) {
 	try {
 		ITypeParameter[] typeParameters = method.getTypeParameters();
 		int length1 = typeParameters == null ? 0 : typeParameters.length;
 		int length2 = typeParameterNames == null ? 0 : typeParameterNames.length;
 		if (length1 != length2) {
 			return false;
 		} else {
 			for (int j = 0; j < length1j++) {
 				ITypeParameter typeParameter = typeParameters[j];
 				String typeParameterName = typeParameter.getElementName();
 				if (!typeParameterName.equals(new String(typeParameterNames[j]))) {
 					return false;
 				}
 
 				String[] bounds = typeParameter.getBounds();
 				int boundCount = typeParameterBoundNames[j] == null ? 0 : typeParameterBoundNames[j].length;
 
 				if (bounds.length != boundCount) {
 					return false;
 				} else {
 					for (int k = 0; k < boundCountk++) {
 						String simpleName = Signature.getSimpleName(bounds[k]);
 						int index = simpleName.indexOf('<');
 						if (index != -1) {
 							simpleName = simpleName.substring(0, index);
 						}
 						if (!simpleName.equals(new String(typeParameterBoundNames[j][k]))) {
 							return false;
 						}
 					}
 				}
 			}
 		}
 	} catch (JavaModelException e) {
 		return false;
 	}
 	return true;
 }
 /*
  * findLocalElement() cannot find local variable
  */
 protected IJavaElement findLocalElement(int pos) {
 	IJavaElement res = null;
 	if(this. instanceof ICompilationUnit) {
 		try {
 			res = cu.getElementAt(pos);
 		} catch (JavaModelException e) {
 			// do nothing
 		}
 	} else if (this. instanceof ClassFile) {
 		ClassFile cf = (ClassFilethis.;
 		try {
 			 res = cf.getElementAtConsideringSibling(pos);
 		} catch (JavaModelException e) {
 			// do nothing
 		}
 	}
 	return res;
 }

This method returns an IMethod element from the given method and declaring type bindings. However, unlike org.eclipse.jdt.internal.core.util.Util.findMethod(org.eclipse.jdt.core.IType,char[],java.lang.String[],boolean) , this does not require an IType to get the IMethod element.

Parameters:
method the given method binding
signatures the type signatures of the method arguments
declaringClass the binding of the method's declaring class
Returns:
an IMethod corresponding to the method binding given, or null if none is found.
 
 public IJavaElement findMethodFromBinding(MethodBinding methodString[] signaturesReferenceBinding declaringClass) {
 	IType foundType = this.resolveType(declaringClass.qualifiedPackageName(), declaringClass.qualifiedSourceName(), . & .);
 	if (foundType != null) {
 		if (foundType instanceof BinaryType) {
 			try {
 				return Util.findMethod(foundTypemethod.selectorsignaturesmethod.isConstructor());
 			} catch (JavaModelException e) {
 				return null;
 			}
 		} else {
 			return foundType.getMethod(new String(method.selector), signatures);
 		}
 	}
 	return null;
 }
Returns the resolved elements.
 
 public IJavaElement[] getElements() {
 	int elementLength = this. + 1;
 	if (this..length != elementLength) {
 		System.arraycopy(this., 0, this. = new IJavaElement[elementLength], 0, elementLength);
 	}
 	return this.;
 }
Resolve the type
 
 protected IType resolveType(char[] packageNamechar[] typeNameint acceptFlags) {
 
 	IType typenull;
 
 	if (this. instanceof CompilationUnit && ((CompilationUnit)this.).isWorkingCopy()) {
 		try {
 			if(((packageName == null || packageName.length == 0) && wc.getPackageDeclarations().length == 0) ||
 				(!(packageName == null || packageName.length == 0) && wc.getPackageDeclaration(new String(packageName)).exists())) {
 
 				char[][] compoundName = CharOperation.splitOn('.'typeName);
 				if(compoundName.length > 0) {
 					type = wc.getType(new String(compoundName[0]));
 					for (int i = 1, length = compoundName.lengthi < lengthi++) {
 						type = type.getType(new String(compoundName[i]));
 					}
 				}
 
 				if(type != null && !type.exists()) {
 					type = null;
 				}
 			}
 		}catch (JavaModelException e) {
 			// type is null
 		}
 	}
 
 	if(type == null) {
 			(packageName == null || packageName.length == 0) ? . : new String(packageName),
 			false);
 		// iterate type lookup in each package fragment
 		for (int i = 0, length = pkgs == null ? 0 : pkgs.lengthi < lengthi++) {
 			typethis..findType(new String(typeName), pkgs[i], falseacceptFlagstrue/*consider secondary types*/);
 			if (type != nullbreak;
 		}
 		if (type == null) {
 			if (packageName != null) {
 				pName = new String(packageName);
 			}
 			if (this. != null && this..getParent().getElementName().equals(pName)) {
 				// look inside the type in which we are resolving in
 				String tNamenew String(typeName);
 				tName = tName.replace('.','$');
 				IType[] allTypesnull;
 				try {
 					allTypes = new IType[list.size()];
 					list.toArray(allTypes);
 				} catch (JavaModelException e) {
 					return null;
 				}
 				for (int i= 0; i < allTypes.lengthi++) {
 					if (allTypes[i].getTypeQualifiedName().equals(tName)) {
 						return allTypes[i];
 					}
 				}
 			}
 		}
 	}
 	return type;
 }
 protected IType resolveTypeByLocation(char[] packageNamechar[] typeNameint acceptFlagsint startint end) {
 
 	IType typenull;
 
 	// TODO (david) post 3.0 should remove isOpen check, and investigate reusing ICompilationUnit#getElementAt. may need to optimize #getElementAt to remove recursions
 	if (this. instanceof CompilationUnit && ((CompilationUnit)this.).isOpen()) {
 		try {
 			if(((packageName == null || packageName.length == 0) && wc.getPackageDeclarations().length == 0) ||
 				(!(packageName == null || packageName.length == 0) && wc.getPackageDeclaration(new String(packageName)).exists())) {
 
 				char[][] compoundName = CharOperation.splitOn('.'typeName);
 				if(compoundName.length > 0) {
 
 					IType[] tTypes = wc.getTypes();
 					int i = 0;
 					int depth = 0;
 					done : while(i < tTypes.length) {
 						ISourceRange range = tTypes[i].getSourceRange();
 						if(range.getOffset() <= start
 								&& range.getOffset() + range.getLength() >= end
 								&& tTypes[i].getElementName().equals(new String(compoundName[depth]))) {
 							if(depth == compoundName.length - 1) {
 								type = tTypes[i];
 								break done;
 							}
 							tTypes = tTypes[i].getTypes();
 							i = 0;
 							depth++;
 							continue done;
 						}
 						i++;
 					}
 				}
 
 				if(type != null && !type.exists()) {
 					type = null;
 				}
 			}
 		}catch (JavaModelException e) {
 			// type is null
 		}
 	}
 
 	if(type == null) {
 			(packageName == null || packageName.length == 0) ? . : new String(packageName),
 			false);
 		// iterate type lookup in each package fragment
 		for (int i = 0, length = pkgs == null ? 0 : pkgs.lengthi < lengthi++) {
 			typethis..findType(new String(typeName), pkgs[i], falseacceptFlagstrue/*consider secondary types*/);
 			if (type != nullbreak;
 		}
		if (type == null) {
			if (packageName != null) {
				pName = new String(packageName);
			if (this. != null && this..getParent().getElementName().equals(pName)) {
				// look inside the type in which we are resolving in
				String tNamenew String(typeName);
				tName = tName.replace('.','$');
				IType[] allTypesnull;
				try {
					allTypes = new IType[list.size()];
					list.toArray(allTypes);
catch (JavaModelException e) {
					return null;
				for (int i= 0; i < allTypes.lengthi++) {
					if (allTypes[i].getTypeQualifiedName().equals(tName)) {
						return allTypes[i];
	return type;