/******************************************************************************* * Copyright (c) 2000, 2008 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 net.sourceforge.phpdt.core.dom; import net.sourceforge.phpdt.core.WorkingCopyOwner; import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope; import net.sourceforge.phpdt.internal.compiler.lookup.CompilationUnitScope; import net.sourceforge.phpdt.internal.compiler.lookup.ElementValuePair; import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment; /** * A binding resolver is an internal mechanism for figuring out the binding * for a major declaration, type, or name reference. This also handles * the creation and mapping between annotations and the ast nodes that define them. *
* The default implementation serves as the default binding resolver * that does no resolving whatsoever. Internal subclasses do all the real work. *
* * @see AST#getBindingResolver */ class BindingResolver { /** * Creates a binding resolver. */ BindingResolver() { // default implementation: do nothing } /** * Finds the corresponding AST node from which the given binding originated. * Returnsnull
if the binding does not correspond to any node
* in the compilation unit.
* * The following table indicates the expected node type for the various * different kinds of bindings: *
PackageDeclaration
TypeDeclaration
or a
* ClassInstanceCreation
(for anonymous classes) VariableDeclarationFragment
in a
* FieldDeclaration
SingleVariableDeclaration
, or
* a VariableDeclarationFragment
in a
* VariableDeclarationStatement
or
* VariableDeclarationExpression
MethodDeclaration
MethodDeclaration
AnnotationTypeDeclaration
* AnnotationTypeMemberDeclaration
*
* The implementation of CompilationUnit.findDeclaringNode
* forwards to this method.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if none
*/
ASTNode findDeclaringNode(IBinding binding) {
return null;
}
/**
* Finds the corresponding AST node from which the given binding key originated.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
*
* @param bindingKey the binding key
* @return the corresponding node where the bindings is declared,
* or null
if none
*/
ASTNode findDeclaringNode(String bindingKey) {
return null;
}
/**
* Finds the corresponding AST node from which the given annotation instance originated.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
*
* @param instance the dom annotation
* @return the corresponding node where the bindings is declared,
* or null
if none
*/
ASTNode findDeclaringNode(IAnnotationBinding instance) {
return null;
}
/**
* Allows the user to get information about the given old/new pair of
* AST nodes.
* * The default implementation of this method does nothing. * Subclasses may reimplement. *
* * @param currentNode the new node * @return org.eclipse.jdt.internal.compiler.ast.ASTNode */ net.sourceforge.phpdt.internal.compiler.ast.ASTNode getCorrespondingNode(ASTNode currentNode) { return null; } /** * Returns the new method binding corresponding to the given old method binding. *
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
* The default implementation of this method returns null
* Subclasses may reimplement.
*
null
if none.
*
* @return the lookup environment used by this resolver, or null
if none.
*/
LookupEnvironment lookupEnvironment() {
return null;
}
/**
* This method is used to record the scope and its corresponding node.
* * The default implementation of this method does nothing. * Subclasses may reimplement. *
* @param astNode */ void recordScope(ASTNode astNode, BlockScope blockScope) { // default implementation: do nothing } /** * Returns whether this expression node is the site of a boxing * conversion (JLS3 5.1.7). This information is available only * when bindings are requested when the AST is being built. * * @returntrue
if this expression is the site of a
* boxing conversion, or false
if either no boxing conversion
* is involved or if bindings were not requested when the AST was created
* @since 3.1
*/
boolean resolveBoxing(Expression expression) {
return false;
}
/**
* Returns whether this expression node is the site of an unboxing
* conversion (JLS3 5.1.8). This information is available only
* when bindings are requested when the AST is being built.
*
* @return true
if this expression is the site of an
* unboxing conversion, or false
if either no unboxing
* conversion is involved or if bindings were not requested when the
* AST was created
* @since 3.1
*/
boolean resolveUnboxing(Expression expression) {
return false;
}
/**
* Resolves and returns the compile-time constant expression value as
* specified in JLS2 15.28, if this expression has one. Constant expression
* values are unavailable unless bindings are requested when the AST is
* being built. If the type of the value is a primitive type, the result
* is the boxed equivalent (i.e., int returned as an Integer
);
* if the type of the value is String
, the result is the string
* itself. If the expression does not have a compile-time constant expression
* value, the result is null
.
* * Resolving constant expressions takes into account the value of simple * and qualified names that refer to constant variables (JLS2 4.12.4). *
*
* Note 1: enum constants are not considered constant expressions either.
* The result is always null
for these.
*
* Note 2: Compile-time constant expressions cannot denote null
.
* So technically {@link NullLiteral} nodes are not constant expressions.
* The result is null
for these nonetheless.
*
null
if this
* expression has no constant expression value or if bindings were not
* requested when the AST was created
* @since 3.1
*/
Object resolveConstantExpressionValue(Expression expression) {
return null;
}
/**
* Resolves and returns the binding for the constructor being invoked.
*
* The implementation of
* ClassInstanceCreation.resolveConstructor
* forwards to this method. Which constructor is invoked is often a function
* of the context in which the expression node is embedded as well as
* the expression subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveConstructor(ClassInstanceCreation expression) {
return null;
}
/**
* Resolves and returns the binding for the constructor being invoked.
*
* The implementation of
* ConstructorInvocation.resolveConstructor
* forwards to this method. Which constructor is invoked is often a function
* of the context in which the expression node is embedded as well as
* the expression subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveConstructor(ConstructorInvocation expression) {
return null;
}
/**
* Resolves and returns the binding for the constructor being invoked.
*
* The implementation of
* ConstructorInvocation.resolveConstructor
* forwards to this method. Which constructor is invoked is often a function
* of the context in which the expression node is embedded as well as
* the expression subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveConstructor(EnumConstantDeclaration enumConstantDeclaration) {
return null;
}
/**
* Resolves and returns the binding for the constructor being invoked.
*
* The implementation of
* SuperConstructorInvocation.resolveConstructor
* forwards to this method. Which constructor is invoked is often a function
* of the context in which the expression node is embedded as well as
* the expression subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveConstructor(SuperConstructorInvocation expression) {
return null;
}
/**
* Resolves the type of the given expression and returns the type binding
* for it.
*
* The implementation of Expression.resolveTypeBinding
* forwards to this method. The result is often a function of the context
* in which the expression node is embedded as well as the expression
* subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
ITypeBinding resolveExpressionType(Expression expression) {
return null;
}
/**
* Resolves the given field access and returns the binding for it.
*
* The implementation of FieldAccess.resolveFieldBinding
* forwards to this method. How the field resolves is often a function of
* the context in which the field access node is embedded as well as
* the field access subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IVariableBinding resolveField(FieldAccess fieldAccess) {
return null;
}
/**
* Resolves the given super field access and returns the binding for it.
*
* The implementation of SuperFieldAccess.resolveFieldBinding
* forwards to this method. How the field resolves is often a function of
* the context in which the super field access node is embedded as well as
* the super field access subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IVariableBinding resolveField(SuperFieldAccess fieldAccess) {
return null;
}
/**
* Resolves the given import declaration and returns the binding for it.
*
* The implementation of ImportDeclaration.resolveBinding
* forwards to this method.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is
* available
*/
IBinding resolveImport(ImportDeclaration importDeclaration) {
return null;
}
/**
* Resolves the given annotation type declaration and returns the binding
* for it.
*
* The implementation of AnnotationTypeMemberDeclaration.resolveBinding
* forwards to this method. How the declaration resolves is often a
* function of the context in which the declaration node is embedded as well
* as the declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
* @since 3.0
*/
IMethodBinding resolveMember(AnnotationTypeMemberDeclaration member) {
return null;
}
/**
* Resolves the given method declaration and returns the binding for it.
*
* The implementation of MethodDeclaration.resolveBinding
* forwards to this method. How the method resolves is often a function of
* the context in which the method declaration node is embedded as well as
* the method declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveMethod(MethodDeclaration method) {
return null;
}
/**
* Resolves the given method invocation and returns the binding for it.
*
* The implementation of MethodInvocation.resolveMethodBinding
* forwards to this method. How the method resolves is often a function of
* the context in which the method invocation node is embedded as well as
* the method invocation subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveMethod(MethodInvocation method) {
return null;
}
/**
* Resolves the given method invocation and returns the binding for it.
*
* The implementation of MethodInvocation.resolveMethodBinding
* forwards to this method. How the method resolves is often a function of
* the context in which the method invocation node is embedded as well as
* the method invocation subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IMethodBinding resolveMethod(SuperMethodInvocation method) {
return null;
}
/**
* Resolves the given name and returns the type binding for it.
*
* The implementation of Name.resolveBinding
forwards to
* this method. How the name resolves is often a function of the context
* in which the name node is embedded as well as the name itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is
* available
*/
IBinding resolveName(Name name) {
return null;
}
/**
* Resolves the given package declaration and returns the binding for it.
*
* The implementation of PackageDeclaration.resolveBinding
* forwards to this method.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IPackageBinding resolvePackage(PackageDeclaration pkg) {
return null;
}
/**
* Resolves the given reference and returns the binding for it.
*
* The implementation of MemberRef.resolveBinding
forwards to
* this method. How the name resolves is often a function of the context
* in which the name node is embedded as well as the name itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is
* available
* @since 3.0
*/
IBinding resolveReference(MemberRef ref) {
return null;
}
/**
* Resolves the given member value pair and returns the binding for it.
*
* The implementation of MemberValuePair.resolveMemberValuePairBinding
forwards to
* this method. How the name resolves is often a function of the context
* in which the name node is embedded as well as the name itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is
* available
* @since 3.2
*/
IMemberValuePairBinding resolveMemberValuePair(MemberValuePair memberValuePair) {
return null;
}
/**
* Resolves the given reference and returns the binding for it.
*
* The implementation of MethodRef.resolveBinding
forwards to
* this method. How the name resolves is often a function of the context
* in which the name node is embedded as well as the name itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is
* available
* @since 3.0
*/
IBinding resolveReference(MethodRef ref) {
return null;
}
/**
* Resolves the given annotation type declaration and returns the binding
* for it.
*
* The implementation of AnnotationTypeDeclaration.resolveBinding
* forwards to this method. How the declaration resolves is often a
* function of the context in which the declaration node is embedded as well
* as the declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
* @since 3.0
*/
ITypeBinding resolveType(AnnotationTypeDeclaration type) {
return null;
}
/**
* Resolves the given anonymous class declaration and returns the binding
* for it.
*
* The implementation of AnonymousClassDeclaration.resolveBinding
* forwards to this method. How the declaration resolves is often a
* function of the context in which the declaration node is embedded as well
* as the declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
*/
ITypeBinding resolveType(AnonymousClassDeclaration type) {
return null;
}
/**
* Resolves the given enum declaration and returns the binding
* for it.
*
* The implementation of EnumDeclaration.resolveBinding
* forwards to this method. How the enum declaration resolves is often
* a function of the context in which the declaration node is embedded
* as well as the enum declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
* @since 3.0
*/
ITypeBinding resolveType(EnumDeclaration type) {
return null;
}
/**
* Resolves the given type and returns the type binding for it.
*
* The implementation of Type.resolveBinding
* forwards to this method. How the type resolves is often a function
* of the context in which the type node is embedded as well as the type
* subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
*/
ITypeBinding resolveType(Type type) {
return null;
}
/**
* Resolves the given class or interface declaration and returns the binding
* for it.
*
* The implementation of TypeDeclaration.resolveBinding
* (and TypeDeclarationStatement.resolveBinding
) forwards
* to this method. How the type declaration resolves is often a function of
* the context in which the type declaration node is embedded as well as the
* type declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
*/
ITypeBinding resolveType(TypeDeclaration type) {
return null;
}
/**
* Resolves the given type parameter and returns the type binding for the
* type parameter.
*
* The implementation of TypeParameter.resolveBinding
* forwards to this method. How the declaration resolves is often a
* function of the context in which the declaration node is embedded as well
* as the declaration subtree itself.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
* if no binding is available
* @since 3.1
*/
ITypeBinding resolveTypeParameter(TypeParameter typeParameter) {
return null;
}
/**
* Resolves the given enum constant declaration and returns the binding for
* the field.
*
* The implementation of EnumConstantDeclaration.resolveVariable
* forwards to this method.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
* @since 3.0
*/
IVariableBinding resolveVariable(EnumConstantDeclaration enumConstant) {
return null;
}
/**
* Resolves the given variable declaration and returns the binding for it.
*
* The implementation of VariableDeclaration.resolveBinding
* forwards to this method. How the variable declaration resolves is often
* a function of the context in which the variable declaration node is
* embedded as well as the variable declaration subtree itself. VariableDeclaration
* declarations used as local variable, formal parameter and exception
* variables resolve to local variable bindings; variable declarations
* used to declare fields resolve to field bindings.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null
if no binding is available
*/
IVariableBinding resolveVariable(VariableDeclaration variable) {
return null;
}
/**
* Resolves the given well known type by name and returns the type binding
* for it.
*
* The implementation of AST.resolveWellKnownType
* forwards to this method.
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
null if the
* named type is not considered well known or if no binding can be found
* for it
*/
ITypeBinding resolveWellKnownType(String name) {
return null;
}
/**
* Resolves the given annotation instance and returns the DOM representation for it.
*
* The implementation of {@link Annotation#resolveAnnotationBinding()}
* forwards to this method.
*
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
*
* @param annotation the annotation ast node of interest
* @return the DOM annotation representation for the given ast node, or
* null
if none is available
*/
IAnnotationBinding resolveAnnotation(Annotation annotation) {
return null;
}
/**
* Answer an array type binding with the given type binding and the given
* dimensions.
*
* If the given type binding is an array binding, then the resulting dimensions is the given dimensions
* plus the existing dimensions of the array binding. Otherwise the resulting dimensions is the given
* dimensions.
*
*
* The default implementation of this method returns null
.
* Subclasses may reimplement.
*
*
* @param typeBinding the given type binding
* @param dimensions the given dimensions
* @return an array type binding with the given type binding and the given
* dimensions
* @throws IllegalArgumentException if the type binding represents the void
type binding
*/
ITypeBinding resolveArrayType(ITypeBinding typeBinding, int dimensions) {
return null;
}
/**
* Returns the compilation unit scope used by this binding resolver.
* Returns null
if none.
*
* @return the compilation unit scope by this resolver, or null
if none.
*/
public CompilationUnitScope scope() {
return null;
}
/**
* Allows the user to store information about the given old/new pair of
* AST nodes.
*
* The default implementation of this method does nothing.
* Subclasses may reimplement.
*
*
* @param newNode the new AST node
* @param oldASTNode the old AST node
*/
void store(ASTNode newNode, org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode) {
// default implementation: do nothing
}
/**
* Allows the user to update information about the given old/new pair of
* AST nodes.
*
* The default implementation of this method does nothing.
* Subclasses may reimplement.
*
*
* @param node the old AST node
* @param newNode the new AST node
*/
void updateKey(ASTNode node, ASTNode newNode) {
// default implementation: do nothing
}
}