/**
* Collects all elements available in a type: its hierarchy and its outer scopes.
*
* @param binding The type binding
* @param flags Flags defining the elements to report
* @param requestor the requestor to which all results are reported
* @return return <code>true</code> if the requestor has reported the binding as found and no
* further results are required
*/
private boolean addTypeDeclarations(
ITypeBinding binding, int flags, IBindingRequestor requestor) {
if (hasFlag(TYPES, flags) && !binding.isAnonymous()) {
if (requestor.acceptBinding(binding)) return true;
ITypeBinding[] typeParameters = binding.getTypeParameters();
for (int i = 0; i < typeParameters.length; i++) {
if (requestor.acceptBinding(typeParameters[i])) return true;
}
}
addInherited(binding, flags, requestor); // add inherited
if (binding.isLocal()) {
addOuterDeclarationsForLocalType(binding, flags, requestor);
} else {
ITypeBinding declaringClass = binding.getDeclaringClass();
if (declaringClass != null) {
if (addTypeDeclarations(declaringClass, flags, requestor)) // Recursively add inherited
return true;
} else if (hasFlag(TYPES, flags)) {
if (fRoot.findDeclaringNode(binding) != null) {
List<AbstractTypeDeclaration> types = fRoot.types();
for (int i = 0; i < types.size(); i++) {
if (requestor.acceptBinding(types.get(i).resolveBinding())) return true;
}
}
}
}
return false;
}
@Override
public boolean visit(TypeDeclarationStatement node) {
if (hasFlag(TYPES, fFlags) && fPosition < node.getStartPosition()) {
fBreak = fRequestor.acceptBinding(node.resolveBinding());
}
return false;
}
@Override
public boolean visit(VariableDeclaration node) {
if (hasFlag(VARIABLES, fFlags) && fPosition < node.getStartPosition()) {
fBreak = fRequestor.acceptBinding(node.resolveBinding());
}
return false;
}
/*
* (non-Javadoc)
* @see org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor#visit(org.eclipse.jdt.core.dom.TypeParameter)
*/
@Override
public boolean visit(TypeParameter node) {
if (hasFlag(TYPES, fFlags) && node.getStartPosition() < fPosition) {
fBreak = fRequestor.acceptBinding(node.getName().resolveBinding());
}
return !fBreak;
}
/**
* Collects all elements available in a type and its hierarchy
*
* @param binding The type binding
* @param flags Flags defining the elements to report
* @param requestor the requestor to which all results are reported
* @return return <code>true</code> if the requestor has reported the binding as found and no
* further results are required
*/
private boolean addInherited(ITypeBinding binding, int flags, IBindingRequestor requestor) {
if (!fTypesVisited.add(binding)) {
return false;
}
if (hasFlag(VARIABLES, flags)) {
IVariableBinding[] variableBindings = binding.getDeclaredFields();
for (int i = 0; i < variableBindings.length; i++) {
if (requestor.acceptBinding(variableBindings[i])) return true;
}
}
if (hasFlag(METHODS, flags)) {
IMethodBinding[] methodBindings = binding.getDeclaredMethods();
for (int i = 0; i < methodBindings.length; i++) {
IMethodBinding curr = methodBindings[i];
if (!curr.isSynthetic() && !curr.isConstructor()) {
if (requestor.acceptBinding(curr)) return true;
}
}
}
if (hasFlag(TYPES, flags)) {
ITypeBinding[] typeBindings = binding.getDeclaredTypes();
for (int i = 0; i < typeBindings.length; i++) {
ITypeBinding curr = typeBindings[i];
if (requestor.acceptBinding(curr)) return true;
}
}
ITypeBinding superClass = binding.getSuperclass();
if (superClass != null) {
if (addInherited(superClass, flags, requestor)) // recursive
return true;
} else if (binding.isArray()) {
if (addInherited(
fRoot.getAST().resolveWellKnownType("java.lang.Object"), flags, requestor)) // $NON-NLS-1$
return true;
}
ITypeBinding[] interfaces =
binding.getInterfaces(); // includes looking for methods: abstract, unimplemented methods
for (int i = 0; i < interfaces.length; i++) {
if (addInherited(interfaces[i], flags, requestor)) // recursive
return true;
}
return false;
}
@Override
public boolean visit(TypeDeclarationStatement node) {
if (hasFlag(TYPES, fFlags) && node.getStartPosition() + node.getLength() < fPosition) {
fBreak = fRequestor.acceptBinding(node.resolveBinding());
return false;
}
return !fBreak && isInside(node);
}
@Override
public boolean visit(SwitchCase node) {
// switch on enum allows to use enum constants without qualification
if (hasFlag(VARIABLES, fFlags) && !node.isDefault() && isInside(node.getExpression())) {
SwitchStatement switchStatement = (SwitchStatement) node.getParent();
ITypeBinding binding = switchStatement.getExpression().resolveTypeBinding();
if (binding != null && binding.isEnum()) {
IVariableBinding[] declaredFields = binding.getDeclaredFields();
for (int i = 0; i < declaredFields.length; i++) {
IVariableBinding curr = declaredFields[i];
if (curr.isEnumConstant()) {
fBreak = fRequestor.acceptBinding(curr);
if (fBreak) return false;
}
}
}
}
return false;
}
