/*******************************************************************************
* Copyright (c) 2000, 2013 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.wst.jsdt.internal.corext.dom;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.core.dom.AST;
import org.eclipse.wst.jsdt.core.dom.ASTNode;
import org.eclipse.wst.jsdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.wst.jsdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.wst.jsdt.core.dom.Block;
import org.eclipse.wst.jsdt.core.dom.BodyDeclaration;
import org.eclipse.wst.jsdt.core.dom.CatchClause;
import org.eclipse.wst.jsdt.core.dom.ClassInstanceCreation;
import org.eclipse.wst.jsdt.core.dom.Expression;
import org.eclipse.wst.jsdt.core.dom.FieldAccess;
import org.eclipse.wst.jsdt.core.dom.ForInStatement;
import org.eclipse.wst.jsdt.core.dom.ForStatement;
import org.eclipse.wst.jsdt.core.dom.FunctionDeclaration;
import org.eclipse.wst.jsdt.core.dom.FunctionInvocation;
import org.eclipse.wst.jsdt.core.dom.IBinding;
import org.eclipse.wst.jsdt.core.dom.IFunctionBinding;
import org.eclipse.wst.jsdt.core.dom.ITypeBinding;
import org.eclipse.wst.jsdt.core.dom.IVariableBinding;
import org.eclipse.wst.jsdt.core.dom.ImportDeclaration;
import org.eclipse.wst.jsdt.core.dom.Initializer;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.core.dom.Modifier;
import org.eclipse.wst.jsdt.core.dom.QualifiedName;
import org.eclipse.wst.jsdt.core.dom.SimpleName;
import org.eclipse.wst.jsdt.core.dom.Statement;
import org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation;
import org.eclipse.wst.jsdt.core.dom.SwitchCase;
import org.eclipse.wst.jsdt.core.dom.SwitchStatement;
import org.eclipse.wst.jsdt.core.dom.Type;
import org.eclipse.wst.jsdt.core.dom.TypeDeclarationStatement;
import org.eclipse.wst.jsdt.core.dom.VariableDeclaration;
import org.eclipse.wst.jsdt.core.dom.VariableDeclarationExpression;
import org.eclipse.wst.jsdt.core.dom.VariableDeclarationStatement;
import org.eclipse.wst.jsdt.internal.core.SearchableEnvironment;
import org.eclipse.wst.jsdt.internal.ui.text.correction.ASTResolving;
/**
*
* Provisional API: This class/interface is part of an interim API that is still under development and expected to
* change significantly before reaching stability. It is being made available at this early stage to solicit feedback
* from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
* (repeatedly) as the API evolves.
*/
public class ScopeAnalyzer {
private static final IBinding[] NO_BINDING= new IBinding[0];
/**
* Flag to specify that method should be reported.
*/
public static final int METHODS= 1;
/**
* Flag to specify that variables should be reported.
*/
public static final int VARIABLES= 2;
/**
* Flag to specify that types should be reported.
*/
public static final int TYPES= 4;
/**
* Flag to specify that only visible elements should be added.
*/
public static final int CHECK_VISIBILITY= 16;
private static interface IBindingRequestor {
boolean acceptBinding(IBinding binding);
}
private static class DefaultBindingRequestor implements IBindingRequestor {
private final List fResult;
private final HashSet fNamesAdded;
private final int fFlags;
private final ITypeBinding fParentTypeBinding;
public DefaultBindingRequestor(ITypeBinding parentTypeBinding, int flags) {
fParentTypeBinding= parentTypeBinding;
fFlags= flags;
fResult= new ArrayList();
fNamesAdded= new HashSet();
}
public DefaultBindingRequestor() {
this(null, 0);
}
/**
* {@inheritDoc}
*/
public boolean acceptBinding(IBinding binding) {
if (binding == null)
return false;
String signature= getSignature(binding);
if (signature != null && fNamesAdded.add(signature)) { // avoid duplicated results from inheritance
fResult.add(binding);
}
return false;
}
public List getResult() {
if (hasFlag(CHECK_VISIBILITY, fFlags)) {
for (int i= fResult.size() - 1; i >= 0; i--) {
IBinding binding= (IBinding) fResult.get(i);
if (!isVisible(binding, fParentTypeBinding)) {
fResult.remove(i);
}
}
}
return fResult;
}
}
private HashSet fTypesVisited;
private JavaScriptUnit fRoot;
public ScopeAnalyzer(JavaScriptUnit root) {
fTypesVisited= new HashSet();
fRoot= root;
}
private void clearLists() {
fTypesVisited.clear();
}
private static String getSignature(IBinding binding) {
if (binding != null) {
switch (binding.getKind()) {
case IBinding.METHOD:
StringBuffer buf= new StringBuffer();
buf.append('M');
buf.append(binding.getName()).append('(');
ITypeBinding[] parameters= ((IFunctionBinding) binding).getParameterTypes();
for (int i= 0; i < parameters.length; i++) {
if (i > 0) {
buf.append(',');
}
ITypeBinding paramType= parameters[i].getErasure();
buf.append(paramType.getQualifiedName());
}
buf.append(')');
return buf.toString();
case IBinding.VARIABLE:
return 'V' + binding.getName();
case IBinding.TYPE:
return 'T' + binding.getName();
}
}
return null;
}
static final boolean hasFlag(int property, int flags) {
return (flags & property) != 0;
}
/**
* 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)) {
IFunctionBinding[] methodBindings= binding.getDeclaredMethods();
for (int i= 0; i < methodBindings.length; i++) {
IFunctionBinding curr= methodBindings[i];
if (!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;
}
return false;
}
/**
* 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;
}
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 types= fRoot.types();
for (int i= 0; i < types.size(); i++) {
if (requestor.acceptBinding(((AbstractTypeDeclaration) types.get(i)).resolveBinding()))
return true;
}
}
}
}
return false;
}
private boolean addOuterDeclarationsForLocalType(ITypeBinding localBinding, int flags, IBindingRequestor requestor) {
ASTNode node= fRoot.findDeclaringNode(localBinding);
if (node == null) {
return false;
}
if (node instanceof AbstractTypeDeclaration || node instanceof AnonymousClassDeclaration) {
if (addLocalDeclarations(node.getParent(), flags, requestor))
return true;
ITypeBinding parentTypeBinding= Bindings.getBindingOfParentType(node.getParent());
if (parentTypeBinding != null) {
if (addTypeDeclarations(parentTypeBinding, flags, requestor))
return true;
}
}else if (node instanceof JavaScriptUnit) {
addLocalDeclarations(node, flags, requestor);
ITypeBinding parentTypeBinding= Bindings.getBindingOfParentType(node.getParent());
if (parentTypeBinding != null) {
if (addTypeDeclarations(parentTypeBinding, flags, requestor))
return true;
}
IJavaScriptElement element = ((JavaScriptUnit) node).getJavaElement();
try {
SearchableEnvironment env = element.newSearchableNameEnvironment(new IJavaScriptUnit[]{});
if(env!=null) {
//SearchRequestor searchReq = new SearchRequestor(localBinding,);
//env.findTypes(new char[] {}, true, false,flags, );
}
} catch (JavaScriptModelException ex) {
// TODO Auto-generated catch block
ex.printStackTrace();
}
return true;
}
return false;
}
private static ITypeBinding getBinding(Expression node) {
if (node != null) {
return node.resolveTypeBinding();
}
return null;
}
private static ITypeBinding getQualifier(SimpleName selector) {
ASTNode parent= selector.getParent();
switch (parent.getNodeType()) {
case ASTNode.FUNCTION_INVOCATION:
FunctionInvocation decl= (FunctionInvocation) parent;
if (selector == decl.getName()) {
return getBinding(decl.getExpression());
}
return null;
case ASTNode.QUALIFIED_NAME:
QualifiedName qualifiedName= (QualifiedName) parent;
if (selector == qualifiedName.getName()) {
return getBinding(qualifiedName.getQualifier());
}
return null;
case ASTNode.FIELD_ACCESS:
FieldAccess fieldAccess= (FieldAccess) parent;
if (selector == fieldAccess.getName()) {
return getBinding(fieldAccess.getExpression());
}
return null;
case ASTNode.SUPER_FIELD_ACCESS: {
ITypeBinding curr= Bindings.getBindingOfParentType(parent);
return curr.getSuperclass();
}
case ASTNode.SUPER_METHOD_INVOCATION: {
SuperMethodInvocation superInv= (SuperMethodInvocation) parent;
if (selector == superInv.getName()) {
ITypeBinding curr= Bindings.getBindingOfParentType(parent);
return curr.getSuperclass();
}
return null;
}
default:
if (parent instanceof Type) {
// bug 67644: in 'a.new X()', all member types of A are visible as location of X.
ASTNode normalizedNode= ASTNodes.getNormalizedNode(parent);
if (normalizedNode.getLocationInParent() == ClassInstanceCreation.TYPE_PROPERTY) {
ClassInstanceCreation creation= (ClassInstanceCreation) normalizedNode.getParent();
return getBinding(creation.getExpression());
}
}
return null;
}
}
public IBinding[] getDeclarationsInScope(SimpleName selector, int flags) {
try {
// special case for switch on enum
if (selector.getLocationInParent() == SwitchCase.EXPRESSION_PROPERTY) {
((SwitchStatement) selector.getParent().getParent()).getExpression().resolveTypeBinding();
}
ITypeBinding parentTypeBinding= Bindings.getBindingOfParentType(selector);
if (parentTypeBinding != null) {
ITypeBinding binding= getQualifier(selector);
DefaultBindingRequestor requestor= new DefaultBindingRequestor(parentTypeBinding, flags);
if (binding == null) {
addLocalDeclarations(selector, flags, requestor);
addTypeDeclarations(parentTypeBinding, flags, requestor);
} else {
addInherited(binding, flags, requestor);
}
List result= requestor.getResult();
return (IBinding[]) result.toArray(new IBinding[result.size()]);
}
return NO_BINDING;
} finally {
clearLists();
}
}
private static class SearchRequestor implements IBindingRequestor {
private final int fFlags;
private final ITypeBinding fParentTypeBinding;
private final IBinding fToSearch;
private boolean fFound;
private boolean fIsVisible;
public SearchRequestor(IBinding toSearch, ITypeBinding parentTypeBinding, int flag) {
fFlags= flag;
fToSearch= toSearch;
fParentTypeBinding= parentTypeBinding;
fFound= false;
fIsVisible= true;
}
public boolean acceptBinding(IBinding binding) {
if (fFound)
return true;
if (binding == null)
return false;
if (fToSearch.getKind() != binding.getKind()) {
return false;
}
boolean checkVisibility= hasFlag(CHECK_VISIBILITY, fFlags);
if (binding == fToSearch) {
fFound= true;
} else {
IBinding bindingDeclaration= Bindings.getDeclaration(binding);
if (bindingDeclaration == fToSearch) {
fFound= true;
} else if (bindingDeclaration.getName().equals(fToSearch.getName())) {
String signature= getSignature(bindingDeclaration);
if (signature != null && signature.equals(getSignature(fToSearch))) {
if (checkVisibility) {
fIsVisible= false;
}
return true; // found element that hides the binding to find
}
}
}
if (fFound && checkVisibility) {
fIsVisible= ScopeAnalyzer.isVisible(binding, fParentTypeBinding);
}
return fFound;
}
public boolean found() {
return fFound;
}
public boolean isVisible() {
return fIsVisible;
}
}
public boolean isDeclaredInScope(IBinding declaration, SimpleName selector, int flags) {
try {
// special case for switch on enum
if (selector.getLocationInParent() == SwitchCase.EXPRESSION_PROPERTY) {
((SwitchStatement) selector.getParent().getParent()).getExpression().resolveTypeBinding();
}
ITypeBinding parentTypeBinding= Bindings.getBindingOfParentTypeContext(selector);
if (parentTypeBinding != null) {
ITypeBinding binding= getQualifier(selector);
SearchRequestor requestor= new SearchRequestor(declaration, parentTypeBinding, flags);
if (binding == null) {
addLocalDeclarations(selector, flags, requestor);
if (requestor.found())
return requestor.isVisible();
addTypeDeclarations(parentTypeBinding, flags, requestor);
if (requestor.found())
return requestor.isVisible();
} else {
addInherited(binding, flags, requestor);
if (requestor.found())
return requestor.isVisible();
}
}
return false;
} finally {
clearLists();
}
}
public IBinding[] getDeclarationsInScope(int offset, int flags) {
NodeFinder finder= new NodeFinder(offset, 0);
fRoot.accept(finder);
ASTNode node= finder.getCoveringNode();
if (node == null) {
return NO_BINDING;
}
if (node instanceof SimpleName) {
return getDeclarationsInScope((SimpleName) node, flags);
}
try {
ITypeBinding binding= Bindings.getBindingOfParentType(node);
DefaultBindingRequestor requestor= new DefaultBindingRequestor(binding, flags);
addLocalDeclarations(node, offset, flags, requestor);
if (binding != null) {
addTypeDeclarations(binding, flags, requestor);
}
List result= requestor.getResult();
return (IBinding[]) result.toArray(new IBinding[result.size()]);
} finally {
clearLists();
}
}
private static ITypeBinding getDeclaringType(IBinding binding) {
switch (binding.getKind()) {
case IBinding.VARIABLE:
return ((IVariableBinding) binding).getDeclaringClass();
case IBinding.METHOD:
return ((IFunctionBinding) binding).getDeclaringClass();
case IBinding.TYPE:
ITypeBinding typeBinding= (ITypeBinding) binding;
if (typeBinding.getDeclaringClass() != null) {
return typeBinding;
}
return typeBinding;
}
return null;
}
/**
* Evaluates if the declaration is visible in a certain context.
* @param binding The binding of the declaration to examine
* @param context The context to test in
* @return Returns
*/
public static boolean isVisible(IBinding binding, ITypeBinding context) {
if (binding.getKind() == IBinding.VARIABLE && !((IVariableBinding) binding).isField()) {
return true; // all local variables found are visible
}
ITypeBinding declaring= getDeclaringType(binding);
if (declaring == null) {
return false;
}
int modifiers= binding.getModifiers();
if (Modifier.isPublic(modifiers)) {
return true;
} else if (Modifier.isProtected(modifiers) || !Modifier.isPrivate(modifiers)) {
if (declaring.getPackage() == context.getPackage()) {
return true;
}
return isTypeInScope(declaring, context, Modifier.isProtected(modifiers));
}
// private visibility
return isTypeInScope(declaring, context, false);
}
private static boolean isTypeInScope(ITypeBinding declaring, ITypeBinding context, boolean includeHierarchy) {
ITypeBinding curr= context;
while (curr != null && curr != declaring) {
if (includeHierarchy && Bindings.isSuperType(declaring, curr)) {
return true;
}
curr= curr.getDeclaringClass();
}
return curr == declaring;
}
public IBinding[] getDeclarationsAfter(int offset, int flags) {
try {
NodeFinder finder= new NodeFinder(offset, 0);
fRoot.accept(finder);
ASTNode node= finder.getCoveringNode();
if (node == null) {
return NO_BINDING;
}
ASTNode declaration= ASTResolving.findParentStatement(node);
while (declaration instanceof Statement && declaration.getNodeType() != ASTNode.BLOCK) {
declaration= declaration.getParent();
}
if (declaration instanceof Block) {
DefaultBindingRequestor requestor= new DefaultBindingRequestor();
DeclarationsAfterVisitor visitor= new DeclarationsAfterVisitor(node.getStartPosition(), flags, requestor);
declaration.accept(visitor);
List result= requestor.getResult();
return (IBinding[])result.toArray(new IBinding[result.size()]);
}
return NO_BINDING;
} finally {
clearLists();
}
}
private class ScopeAnalyzerVisitor extends HierarchicalASTVisitor {
private int fPosition;
private int fFlags;
private final IBindingRequestor fRequestor;
private boolean fBreak;
public ScopeAnalyzerVisitor(int position, int flags, IBindingRequestor requestor) {
fPosition= position;
fFlags= flags;
fRequestor= requestor;
fBreak= false;
}
private boolean isInside(ASTNode node) {
int start= node.getStartPosition();
int end= start + node.getLength();
return start <= fPosition && fPosition < end;
}
public boolean visit(FunctionDeclaration node) {
if (isInside(node)) {
Block body= node.getBody();
if (body != null) {
body.accept(this);
}
visitBackwards(node.parameters());
}
return false;
}
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();
switchStatement.getExpression().resolveTypeBinding();
}
return false;
}
public boolean visit(Initializer node) {
return !fBreak && isInside(node);
}
public boolean visit(Statement node) {
return !fBreak && isInside(node);
}
public boolean visit(ASTNode node) {
return false;
}
public boolean visit(Block node) {
if (isInside(node)) {
visitBackwards(node.statements());
}
return false;
}
public boolean visit(VariableDeclaration node) {
if (hasFlag(VARIABLES, fFlags) && node.getStartPosition() < fPosition) {
fBreak= fRequestor.acceptBinding(node.resolveBinding());
}
return !fBreak;
}
public boolean visit(VariableDeclarationStatement node) {
visitBackwards(node.fragments());
return false;
}
public boolean visit(VariableDeclarationExpression node) {
visitBackwards(node.fragments());
return false;
}
public boolean visit(CatchClause node) {
if (isInside(node)) {
node.getBody().accept(this);
node.getException().accept(this);
}
return false;
}
public boolean visit(ForStatement node) {
if (isInside(node)) {
node.getBody().accept(this);
visitBackwards(node.initializers());
}
return false;
}
public boolean visit(ForInStatement node) {
if (isInside(node)) {
node.getBody().accept(this);
node.getIterationVariable().accept(this);
}
return false;
}
public boolean visit(TypeDeclarationStatement node) {
if (hasFlag(TYPES, fFlags) && node.getStartPosition() + node.getLength() < fPosition) {
if (node.getAST().apiLevel() == AST.JLS2) {
fBreak= fRequestor.acceptBinding(node.getTypeDeclaration().resolveBinding());
} else {
fBreak= fRequestor.acceptBinding(node.getDeclaration().getName().resolveBinding());
}
return false;
}
return !fBreak && isInside(node);
}
private void visitBackwards(List list) {
if (fBreak)
return;
for (int i= list.size() - 1; i >= 0; i--) {
ASTNode curr= (ASTNode) list.get(i);
if (curr.getStartPosition() < fPosition) {
curr.accept(this);
}
}
}
}
private class DeclarationsAfterVisitor extends HierarchicalASTVisitor {
private final int fPosition;
private final int fFlags;
private final IBindingRequestor fRequestor;
private boolean fBreak;
public DeclarationsAfterVisitor(int position, int flags, IBindingRequestor requestor) {
fPosition= position;
fFlags= flags;
fRequestor= requestor;
fBreak= false;
}
public boolean visit(ASTNode node) {
return !fBreak;
}
public boolean visit(VariableDeclaration node) {
if (hasFlag(VARIABLES, fFlags) && fPosition < node.getStartPosition()) {
fBreak= fRequestor.acceptBinding(node.resolveBinding());
}
return false;
}
public boolean visit(AnonymousClassDeclaration node) {
return false;
}
public boolean visit(TypeDeclarationStatement node) {
if (hasFlag(TYPES, fFlags) && fPosition < node.getStartPosition()) {
fBreak= fRequestor.acceptBinding(node.resolveBinding());
}
return false;
}
}
private boolean addLocalDeclarations(ASTNode node, int flags, IBindingRequestor requestor) {
return addLocalDeclarations(node, node.getStartPosition(), flags, requestor);
}
private boolean addLocalDeclarations(ASTNode node, int offset, int flags, IBindingRequestor requestor) {
if (hasFlag(VARIABLES, flags) || hasFlag(TYPES, flags)) {
BodyDeclaration declaration= ASTResolving.findParentBodyDeclaration(node);
if (declaration instanceof FunctionDeclaration || declaration instanceof Initializer) {
ScopeAnalyzerVisitor visitor= new ScopeAnalyzerVisitor(offset, flags, requestor);
declaration.accept(visitor);
return visitor.fBreak;
}
}
return false;
}
public Collection getUsedVariableNames(int offset, int length) {
HashSet result= new HashSet();
IBinding[] bindingsBefore= getDeclarationsInScope(offset, VARIABLES);
for (int i= 0; i < bindingsBefore.length; i++) {
result.add(bindingsBefore[i].getName());
}
IBinding[] bindingsAfter= getDeclarationsAfter(offset + length, VARIABLES);
for (int i= 0; i < bindingsAfter.length; i++) {
result.add(bindingsAfter[i].getName());
}
List imports= fRoot.imports();
for (int i= 0; i < imports.size(); i++) {
ImportDeclaration decl= (ImportDeclaration) imports.get(i);
if (decl.isStatic() && !decl.isOnDemand()) {
result.add(ASTNodes.getSimpleNameIdentifier(decl.getName()));
}
}
return result;
}
}