Copyright (c) 2000, 2017 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
/*******************************************************************************
 * Copyright (c) 2000, 2017 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.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 Also:
getBindingResolver.getBindingResolver/**
 * 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.
 * <p>
 * The default implementation serves as the default binding resolver
 * that does no resolving whatsoever. Internal subclasses do all the real work.
 * </p>
 *
 * @see AST#getBindingResolver
 */
class BindingResolver {

	
Creates a binding resolver.
/**
	 * Creates a binding resolver.
	 */
	BindingResolver() {
		// default implementation: do nothing
	}

	
Finds the corresponding AST node from which the given binding originated.
Returns null 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:


package - a PackageDeclaration
class or interface - a TypeDeclaration or a
   ClassInstanceCreation (for anonymous classes) 
primitive type - none
array type - none
field - a VariableDeclarationFragment in a
   FieldDeclaration 
local variable - a SingleVariableDeclaration, or
   a VariableDeclarationFragment in a
   VariableDeclarationStatement or
   VariableDeclarationExpression
method - a MethodDeclaration 
constructor - a MethodDeclaration 
annotation type - an AnnotationTypeDeclaration
annotation type member - an AnnotationTypeMemberDeclaration



The implementation of CompilationUnit.findDeclaringNode
forwards to this method.


The default implementation of this method returns null.
Subclasses may reimplement.

Params:
binding – the binding
Returns:
the corresponding node where the bindings is declared,
   or null if none/**
	 * Finds the corresponding AST node from which the given binding originated.
	 * Returns <code>null</code> if the binding does not correspond to any node
	 * in the compilation unit.
	 * <p>
	 * The following table indicates the expected node type for the various
	 * different kinds of bindings:
	 * <ul>
	 * <li></li>
	 * <li>package - a <code>PackageDeclaration</code></li>
	 * <li>class or interface - a <code>TypeDeclaration</code> or a
	 *    <code>ClassInstanceCreation</code> (for anonymous classes) </li>
	 * <li>primitive type - none</li>
	 * <li>array type - none</li>
	 * <li>field - a <code>VariableDeclarationFragment</code> in a
	 *    <code>FieldDeclaration</code> </li>
	 * <li>local variable - a <code>SingleVariableDeclaration</code>, or
	 *    a <code>VariableDeclarationFragment</code> in a
	 *    <code>VariableDeclarationStatement</code> or
	 *    <code>VariableDeclarationExpression</code></li>
	 * <li>method - a <code>MethodDeclaration</code> </li>
	 * <li>constructor - a <code>MethodDeclaration</code> </li>
	 * <li>annotation type - an <code>AnnotationTypeDeclaration</code>
	 * <li>annotation type member - an <code>AnnotationTypeMemberDeclaration</code>
	 * </ul>
	 * </p>
	 * <p>
	 * The implementation of <code>CompilationUnit.findDeclaringNode</code>
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param binding the binding
	 * @return the corresponding node where the bindings is declared,
	 *    or <code>null</code> 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.

Params:
bindingKey – the binding key
Returns:
the corresponding node where the bindings is declared,
   or null if none/**
	 * Finds the corresponding AST node from which the given binding key originated.
	 *
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param bindingKey the binding key
	 * @return the corresponding node where the bindings is declared,
	 *    or <code>null</code> 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.

Params:
instance – the dom annotation
Returns:
the corresponding node where the bindings is declared,
   or null if none/**
	 * Finds the corresponding AST node from which the given annotation instance originated.
	 *
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param instance the dom annotation
	 * @return the corresponding node where the bindings is declared,
	 *    or <code>null</code> 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.

Params:
currentNode – the new node
Returns:
org.eclipse.jdt.internal.compiler.ast.ASTNode/**
	 * Allows the user to get information about the given old/new pair of
	 * AST nodes.
	 * <p>
	 * The default implementation of this method does nothing.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param currentNode the new node
	 * @return org.eclipse.jdt.internal.compiler.ast.ASTNode
	 */
	org.eclipse.jdt.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.

Params:
methodBinding – the old method binding
Returns:
the new method binding/**
	 * Returns the new method binding corresponding to the given old method binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param methodBinding the old method binding
	 * @return the new method binding
	 */
	IMethodBinding getMethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding) {
		return null;
	}

	
Returns the new member value pair binding corresponding to the given old value pair binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
valuePair – the old value pair binding
Returns:
the new member value pair binding/**
	 * Returns the new member value pair binding corresponding to the given old value pair binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param valuePair the old value pair binding
	 * @return the new member value pair binding
	 */
	IMemberValuePairBinding getMemberValuePairBinding(ElementValuePair valuePair) {
		return null;
	}

	
Returns the new module binding corresponding to the given old module binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
moduleBinding – the old module binding
Returns:
the new module binding/**
	 * Returns the new module binding corresponding to the given old module binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param moduleBinding the old module binding
	 * @return the new module binding
	 *
	 */
	IModuleBinding getModuleBinding(org.eclipse.jdt.internal.compiler.lookup.ModuleBinding moduleBinding) {
		return null;
	}

	
Returns the new package binding corresponding to the given old package binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
packageBinding – the old package binding
Returns:
the new package binding/**
	 * Returns the new package binding corresponding to the given old package binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param packageBinding the old package binding
	 * @return the new package binding
	 */
	IPackageBinding getPackageBinding(org.eclipse.jdt.internal.compiler.lookup.PackageBinding packageBinding) {
		return null;
	}

	
Returns the new type binding corresponding to the given old type binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
referenceBinding – the old type binding
Returns:
the new type binding/**
	 * Returns the new type binding corresponding to the given old type binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param referenceBinding the old type binding
	 * @return the new type binding
	 */
	ITypeBinding getTypeBinding(org.eclipse.jdt.internal.compiler.lookup.TypeBinding referenceBinding) {
		return null;
	}


	
Returns the new type binding corresponding to the given variableDeclaration.
This is used for recovered binding only.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
variableDeclaration – the given variable declaration
Returns:
the new type binding/**
	 * Returns the new type binding corresponding to the given variableDeclaration.
	 * This is used for recovered binding only.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param variableDeclaration the given variable declaration
	 * @return the new type binding
	 */
	ITypeBinding getTypeBinding(VariableDeclaration variableDeclaration) {
		return null;
	}

	
Returns the new type binding corresponding to the given type. This is used for recovered binding
only.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
type – the given type
Returns:
the new type binding/**
	 * Returns the new type binding corresponding to the given type. This is used for recovered binding
	 * only.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the given type
	 * @return the new type binding
	 */
	ITypeBinding getTypeBinding(Type type) {
		return null;
	}

	
Returns the new type binding corresponding to the given recovered type binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
recoveredTypeBinding – the recovered type binding
dimensions – the dimensions to add the to given type binding dimensions
Returns:
the new type binding/**
	 * Returns the new type binding corresponding to the given recovered type binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param recoveredTypeBinding the recovered type binding
	 * @param dimensions the dimensions to add the to given type binding dimensions
	 * @return the new type binding
	 */
	ITypeBinding getTypeBinding(RecoveredTypeBinding recoveredTypeBinding, int dimensions) {
		return null;
	}

	
Returns the new variable binding corresponding to the given old variable binding.

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
binding – the old variable binding
Returns:
the new variable binding/**
	 * Returns the new variable binding corresponding to the given old variable binding.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param binding the old variable binding
	 * @return the new variable binding
	 */
	IVariableBinding getVariableBinding(org.eclipse.jdt.internal.compiler.lookup.VariableBinding binding) {
		return null;
	}

	
Return the working copy owner for the receiver.

The default implementation of this method returns null.
Subclasses may reimplement.

Returns:
the working copy owner for the receiver/**
	 * Return the working copy owner for the receiver.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 * @return the working copy owner for the receiver
	 */
	public WorkingCopyOwner getWorkingCopyOwner() {
		return null;
	}

	
Return the new annotation corresponding to the given old annotation

The default implementation of this method returns null
Subclasses may reimplement.

Params:
instance – the old annotation
Returns:
the new DOM annotation/**
	 * Return the new annotation corresponding to the given old annotation
	 * <p>
	 * The default implementation of this method returns <code>null</code>
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param instance the old annotation
	 * @return the new DOM annotation
	 */
	IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding instance) {
		return null;
	}

	boolean isResolvedTypeInferredFromExpectedType(MethodInvocation methodInvocation) {
		return false;
	}

	boolean isResolvedTypeInferredFromExpectedType(SuperMethodInvocation methodInvocation) {
		return false;
	}

	boolean isResolvedTypeInferredFromExpectedType(ClassInstanceCreation classInstanceCreation) {
		return false;
	}
	
	
Returns the compiler lookup environment used by this binding resolver.
Returns null if none.
Returns:
the lookup environment used by this resolver, or null if none./**
	 * Returns the compiler lookup environment used by this binding resolver.
	 * Returns <code>null</code> if none.
	 *
	 * @return the lookup environment used by this resolver, or <code>null</code> 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.

Params:
astNode – /**
	 * This method is used to record the scope and its corresponding node.
	 * <p>
	 * The default implementation of this method does nothing.
	 * Subclasses may reimplement.
	 * </p>
	 * @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.
Returns:
true 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/**
	 * 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.
	 *
	 * @return <code>true</code> if this expression is the site of a
	 * boxing conversion, or <code>false</code> 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.
Returns:
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/**
	 * 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 <code>true</code> if this expression is the site of an
	 * unboxing conversion, or <code>false</code> 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 NullLiteral nodes are not constant expressions. The result is null for these nonetheless.

Returns:
the constant expression value, or null if this
expression has no constant expression value or if bindings were not
requested when the AST was created
Since:
3.1/**
	 * 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 <code>Integer</code>);
	 * if the type of the value is <code>String</code>, the result is the string
	 * itself. If the expression does not have a compile-time constant expression
	 * value, the result is <code>null</code>.
	 * <p>
	 * Resolving constant expressions takes into account the value of simple
	 * and qualified names that refer to constant variables (JLS2 4.12.4).
	 * </p>
	 * <p>
	 * Note 1: enum constants are not considered constant expressions either.
	 * The result is always <code>null</code> for these.
	 * </p>
	 * <p>
	 * Note 2: Compile-time constant expressions cannot denote <code>null</code>.
	 * So technically {@link NullLiteral} nodes are not constant expressions.
	 * The result is <code>null</code> for these nonetheless.
	 * </p>
	 *
	 * @return the constant expression value, or <code>null</code> 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.

Params:
expression – the expression of interest
Returns:
the binding for the constructor being invoked, or
   null if no binding is available/**
	 * Resolves and returns the binding for the constructor being invoked.
	 * <p>
	 * The implementation of
	 * <code>ClassInstanceCreation.resolveConstructor</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param expression the expression of interest
	 * @return the binding for the constructor being invoked, or
	 *    <code>null</code> 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.

Params:
expression – the expression of interest
Returns:
the binding for the constructor being invoked, or
   null if no binding is available/**
	 * Resolves and returns the binding for the constructor being invoked.
	 * <p>
	 * The implementation of
	 * <code>ConstructorInvocation.resolveConstructor</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param expression the expression of interest
	 * @return the binding for the constructor being invoked, or
	 *    <code>null</code> 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.

Params:
enumConstantDeclaration – the enum constant declaration of interest
Returns:
the binding for the constructor being invoked, or
   null if no binding is available/**
	 * Resolves and returns the binding for the constructor being invoked.
	 * <p>
	 * The implementation of
	 * <code>ConstructorInvocation.resolveConstructor</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param enumConstantDeclaration the enum constant declaration of interest
	 * @return the binding for the constructor being invoked, or
	 *    <code>null</code> 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.

Params:
expression – the expression of interest
Returns:
the binding for the constructor being invoked, or
   null if no binding is available/**
	 * Resolves and returns the binding for the constructor being invoked.
	 * <p>
	 * The implementation of
	 * <code>SuperConstructorInvocation.resolveConstructor</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param expression the expression of interest
	 * @return the binding for the constructor being invoked, or
	 *    <code>null</code> 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.

Params:
expression – the expression whose type is of interest
Returns:
the binding for the type of the given expression, or
   null if no binding is available/**
	 * Resolves the type of the given expression and returns the type binding
	 * for it.
	 * <p>
	 * The implementation of <code>Expression.resolveTypeBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param expression the expression whose type is of interest
	 * @return the binding for the type of the given expression, or
	 *    <code>null</code> 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.

Params:
fieldAccess – the field access of interest
Returns:
the binding for the given field access, or
   null if no binding is available/**
	 * Resolves the given field access and returns the binding for it.
	 * <p>
	 * The implementation of <code>FieldAccess.resolveFieldBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param fieldAccess the field access of interest
	 * @return the binding for the given field access, or
	 *    <code>null</code> 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.

Params:
fieldAccess – the super field access of interest
Returns:
the binding for the given field access, or
   null if no binding is available/**
	 * Resolves the given super field access and returns the binding for it.
	 * <p>
	 * The implementation of <code>SuperFieldAccess.resolveFieldBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param fieldAccess the super field access of interest
	 * @return the binding for the given field access, or
	 *    <code>null</code> 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.

Params:
importDeclaration – the import declaration of interest
Returns:
the binding for the given package declaration, or
        the package binding (for on-demand imports) or type binding
        (for single-type imports), or null if no binding is
        available/**
	 * Resolves the given import declaration and returns the binding for it.
	 * <p>
	 * The implementation of <code>ImportDeclaration.resolveBinding</code>
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param importDeclaration the import declaration of interest
	 * @return the binding for the given package declaration, or
	 *         the package binding (for on-demand imports) or type binding
	 *         (for single-type imports), or <code>null</code> 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.

Params:
member – the annotation type member declaration of interest
Returns:
the binding for the given annotation type member declaration, or null
   if no binding is available
Since:
3.0/**
	 * Resolves the given annotation type declaration and returns the binding
	 * for it.
	 * <p>
	 * The implementation of <code>AnnotationTypeMemberDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param member the annotation type member declaration of interest
	 * @return the binding for the given annotation type member declaration, or <code>null</code>
	 *    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.

Params:
method – the method or constructor declaration of interest
Returns:
the binding for the given method declaration, or
   null if no binding is available/**
	 * Resolves the given method declaration and returns the binding for it.
	 * <p>
	 * The implementation of <code>MethodDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param method the method or constructor declaration of interest
	 * @return the binding for the given method declaration, or
	 *    <code>null</code> if no binding is available
	 */
	IMethodBinding resolveMethod(MethodDeclaration method) {
		return null;
	}

	
Resolves the given  method reference and returns the binding for it.

The implementation of MethodReference.resolveMethodBinding
forwards to this method. How the method resolves is often a function of
the context in which the method reference node is embedded as well as
the method reference subtree itself.


The default implementation of this method returns null.
Subclasses may reimplement.

Params:
methodReference – the  method reference of interest
Returns:
the binding for the given  method reference, or
   null if no binding is available
Since:
3.10/**
	 * Resolves the given  method reference and returns the binding for it.
	 * <p>
	 * The implementation of <code>MethodReference.resolveMethodBinding</code>
	 * forwards to this method. How the method resolves is often a function of
	 * the context in which the method reference node is embedded as well as
	 * the method reference subtree itself.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param methodReference the  method reference of interest
	 * @return the binding for the given  method reference, or
	 *    <code>null</code> if no binding is available
	 * @since 3.10
	 */
	IMethodBinding resolveMethod(MethodReference methodReference) {
		return null;
	}

	
Resolves the given Lambda Expression and returns the binding for it.

The implementation of LambdaExpression.resolveMethodBinding
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 re-implement.

Params:
lambda – LambdaExpression of interest
Returns:
the binding for the given lambda expression, or
   null if no binding is available/**
	 * Resolves the given Lambda Expression and returns the binding for it.
	 * <p>
	 * The implementation of <code>LambdaExpression.resolveMethodBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may re-implement.
	 * </p>
	 *
	 * @param lambda LambdaExpression of interest
	 * @return the binding for the given lambda expression, or
	 *    <code>null</code> if no binding is available
	 */
	IMethodBinding resolveMethod(LambdaExpression lambda) {
		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.

Params:
method – the method invocation of interest
Returns:
the binding for the given method invocation, or
   null if no binding is available/**
	 * Resolves the given method invocation and returns the binding for it.
	 * <p>
	 * The implementation of <code>MethodInvocation.resolveMethodBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param method the method invocation of interest
	 * @return the binding for the given method invocation, or
	 *    <code>null</code> 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.

Params:
method – the method invocation of interest
Returns:
the binding for the given method invocation, or
   null if no binding is available/**
	 * Resolves the given method invocation and returns the binding for it.
	 * <p>
	 * The implementation of <code>MethodInvocation.resolveMethodBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param method the method invocation of interest
	 * @return the binding for the given method invocation, or
	 *    <code>null</code> if no binding is available
	 */
	IMethodBinding resolveMethod(SuperMethodInvocation method) {
		return null;
	}

	
Resolves the given module declaration and returns the binding for it.

The implementation of ModuleDeclaration.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.

Params:
module – declaration of interest
Returns:
the binding for the given module declaration, or
   null if no binding is available
Since:
3.14/**
	 * Resolves the given module declaration and returns the binding for it.
	 * <p>
	 * The implementation of <code>ModuleDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param module declaration of interest
	 * @return the binding for the given module declaration, or
	 *    <code>null</code> if no binding is available
	 *    
	 * @since 3.14
	 */
	IModuleBinding resolveModule(ModuleDeclaration module) {
		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.

Params:
name – the name of interest
Returns:
the binding for the name, or null if no binding is
   available/**
	 * Resolves the given name and returns the type binding for it.
	 * <p>
	 * The implementation of <code>Name.resolveBinding</code> 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param name the name of interest
	 * @return the binding for the name, or <code>null</code> 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.

Params:
pkg – the package declaration of interest
Returns:
the binding for the given package declaration, or
   null if no binding is available/**
	 * Resolves the given package declaration and returns the binding for it.
	 * <p>
	 * The implementation of <code>PackageDeclaration.resolveBinding</code>
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param pkg the package declaration of interest
	 * @return the binding for the given package declaration, or
	 *    <code>null</code> 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.

Params:
ref – the reference of interest
Returns:
the binding for the reference, or null if no binding is
   available
Since:
3.0/**
	 * Resolves the given reference and returns the binding for it.
	 * <p>
	 * The implementation of <code>MemberRef.resolveBinding</code> 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param ref the reference of interest
	 * @return the binding for the reference, or <code>null</code> 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.

Params:
memberValuePair – the member value pair of interest
Returns:
the binding for the member value pair, or null if no binding is
   available
Since:
3.2/**
	 * Resolves the given member value pair and returns the binding for it.
	 * <p>
	 * The implementation of <code>MemberValuePair.resolveMemberValuePairBinding</code> 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param memberValuePair the member value pair of interest
	 * @return the binding for the member value pair, or <code>null</code> 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.

Params:
ref – the reference of interest
Returns:
the binding for the reference, or null if no binding is
   available
Since:
3.0/**
	 * Resolves the given reference and returns the binding for it.
	 * <p>
	 * The implementation of <code>MethodRef.resolveBinding</code> 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param ref the reference of interest
	 * @return the binding for the reference, or <code>null</code> 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.

Params:
type – the annotation type declaration of interest
Returns:
the binding for the given annotation type declaration, or null
   if no binding is available
Since:
3.0/**
	 * Resolves the given annotation type declaration and returns the binding
	 * for it.
	 * <p>
	 * The implementation of <code>AnnotationTypeDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the annotation type declaration of interest
	 * @return the binding for the given annotation type declaration, or <code>null</code>
	 *    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.

Params:
type – the anonymous class declaration of interest
Returns:
the binding for the given class declaration, or null
   if no binding is available/**
	 * Resolves the given anonymous class declaration and returns the binding
	 * for it.
	 * <p>
	 * The implementation of <code>AnonymousClassDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the anonymous class declaration of interest
	 * @return the binding for the given class declaration, or <code>null</code>
	 *    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.

Params:
type – the enum declaration of interest
Returns:
the binding for the given enum declaration, or null
   if no binding is available
Since:
3.0/**
	 * Resolves the given enum declaration and returns the binding
	 * for it.
	 * <p>
	 * The implementation of <code>EnumDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the enum declaration of interest
	 * @return the binding for the given enum declaration, or <code>null</code>
	 *    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.

Params:
type – the type of interest
Returns:
the binding for the given type, or null
   if no binding is available/**
	 * Resolves the given type and returns the type binding for it.
	 * <p>
	 * The implementation of <code>Type.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the type of interest
	 * @return the binding for the given type, or <code>null</code>
	 *    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.

Params:
type – the class or interface declaration of interest
Returns:
the binding for the given type declaration, or null
   if no binding is available/**
	 * Resolves the given class or interface declaration and returns the binding
	 * for it.
	 * <p>
	 * The implementation of <code>TypeDeclaration.resolveBinding</code>
	 * (and <code>TypeDeclarationStatement.resolveBinding</code>) 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param type the class or interface declaration of interest
	 * @return the binding for the given type declaration, or <code>null</code>
	 *    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.

Params:
typeParameter – the type paramter of interest
Returns:
the binding for the given type parameter, or null
   if no binding is available
Since:
3.1/**
	 * Resolves the given type parameter and returns the type binding for the
	 * type parameter.
	 * <p>
	 * The implementation of <code>TypeParameter.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param typeParameter the type paramter of interest
	 * @return the binding for the given type parameter, or <code>null</code>
	 *    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.

Params:
enumConstant – the enum constant declaration of interest
Returns:
the field binding for the given enum constant declaration, or
   null if no binding is available
Since:
3.0/**
	 * Resolves the given enum constant declaration and returns the binding for
	 * the field.
	 * <p>
	 * The implementation of <code>EnumConstantDeclaration.resolveVariable</code>
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param enumConstant the enum constant declaration of interest
	 * @return the field binding for the given enum constant declaration, or
	 *    <code>null</code> 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.

Params:
variable – the variable declaration of interest
Returns:
the binding for the given variable declaration, or
   null if no binding is available/**
	 * Resolves the given variable declaration and returns the binding for it.
	 * <p>
	 * The implementation of <code>VariableDeclaration.resolveBinding</code>
	 * 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.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param variable the variable declaration of interest
	 * @return the binding for the given variable declaration, or
	 *    <code>null</code> 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.

Params:
name – the name of a well known type
Returns:
the corresponding type binding, or null if the
  named type is not considered well known or if no binding can be found
  for it/**
	 * Resolves the given well known type by name and returns the type binding
	 * for it.
	 * <p>
	 * The implementation of <code>AST.resolveWellKnownType</code>
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param name the name of a well known type
	 * @return the corresponding type binding, or <code>null<code> 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 Annotation.resolveAnnotationBinding() forwards to this method. 

The default implementation of this method returns null.
Subclasses may reimplement.

Params:
annotation – the annotation ast node of interest
Returns:
the DOM annotation representation for the given ast node, or
   null if none is available/**
	 * Resolves the given annotation instance and returns the DOM representation for it.
	 * <p>
	 * The implementation of {@link Annotation#resolveAnnotationBinding()}
	 * forwards to this method.
	 * </p>
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param annotation the annotation ast node of interest
	 * @return the DOM annotation representation for the given ast node, or
	 *    <code>null</code> 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.

Params:
typeBinding – the given type binding
dimensions – the given dimensions
Throws:
IllegalArgumentException – if the type binding represents the void type binding
Returns:
an array type binding with the given type binding and the given
dimensions/**
	 * Answer an array type binding with the given type binding and the given
	 * dimensions.
	 *
	 * <p>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.</p>
	 *
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @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 <code>void</code> type binding
	 */
	ITypeBinding resolveArrayType(ITypeBinding typeBinding, int dimensions) {
		return null;
	}

	
Returns the compilation unit scope used by this binding resolver.
Returns null if none.
Returns:
the compilation unit scope by this resolver, or null if none./**
	 * Returns the compilation unit scope used by this binding resolver.
	 * Returns <code>null</code> if none.
	 *
	 * @return the compilation unit scope by this resolver, or <code>null</code> 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.

Params:
newNode – the new AST node
oldASTNode – the old AST node/**
	 * Allows the user to store information about the given old/new pair of
	 * AST nodes.
	 * <p>
	 * The default implementation of this method does nothing.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @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.

Params:
node – the old AST node
newNode – the new AST node/**
	 * Allows the user to update information about the given old/new pair of
	 * AST nodes.
	 * <p>
	 * The default implementation of this method does nothing.
	 * Subclasses may reimplement.
	 * </p>
	 *
	 * @param node the old AST node
	 * @param newNode the new AST node
	 */
	void updateKey(ASTNode node, ASTNode newNode) {
		// default implementation: do nothing
	}
}