net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/dom/BindingResolver.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2008 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11
  12 package net.sourceforge.phpdt.core.dom;
  13
  14 import net.sourceforge.phpdt.core.WorkingCopyOwner;
  15 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  16 import net.sourceforge.phpdt.internal.compiler.lookup.CompilationUnitScope;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.ElementValuePair;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
  19
  20 /**
  21  * A binding resolver is an internal mechanism for figuring out the binding
  22  * for a major declaration, type, or name reference. This also handles
  23  * the creation and mapping between annotations and the ast nodes that define them.
  24  * <p>
  25  * The default implementation serves as the default binding resolver
  26  * that does no resolving whatsoever. Internal subclasses do all the real work.
  27  * </p>
  28  *
  29  * @see AST#getBindingResolver
  30  */
  31 class BindingResolver {
  32
  33         /**
  34          * Creates a binding resolver.
  35          */
  36         BindingResolver() {
  37                 // default implementation: do nothing
  38         }
  39
  40         /**
  41          * Finds the corresponding AST node from which the given binding originated.
  42          * Returns <code>null</code> if the binding does not correspond to any node
  43          * in the compilation unit.
  44          * <p>
  45          * The following table indicates the expected node type for the various
  46          * different kinds of bindings:
  47          * <ul>
  48          * <li></li>
  49          * <li>package - a <code>PackageDeclaration</code></li>
  50          * <li>class or interface - a <code>TypeDeclaration</code> or a
  51          *    <code>ClassInstanceCreation</code> (for anonymous classes) </li>
  52          * <li>primitive type - none</li>
  53          * <li>array type - none</li>
  54          * <li>field - a <code>VariableDeclarationFragment</code> in a
  55          *    <code>FieldDeclaration</code> </li>
  56          * <li>local variable - a <code>SingleVariableDeclaration</code>, or
  57          *    a <code>VariableDeclarationFragment</code> in a
  58          *    <code>VariableDeclarationStatement</code> or
  59          *    <code>VariableDeclarationExpression</code></li>
  60          * <li>method - a <code>MethodDeclaration</code> </li>
  61          * <li>constructor - a <code>MethodDeclaration</code> </li>
  62          * <li>annotation type - an <code>AnnotationTypeDeclaration</code>
  63          * <li>annotation type member - an <code>AnnotationTypeMemberDeclaration</code>
  64          * </ul>
  65          * </p>
  66          * <p>
  67          * The implementation of <code>CompilationUnit.findDeclaringNode</code>
  68          * forwards to this method.
  69          * </p>
  70          * <p>
  71          * The default implementation of this method returns <code>null</code>.
  72          * Subclasses may reimplement.
  73          * </p>
  74          *
  75          * @param binding the binding
  76          * @return the corresponding node where the bindings is declared,
  77          *    or <code>null</code> if none
  78          */
  79         ASTNode findDeclaringNode(IBinding binding) {
  80                 return null;
  81         }
  82
  83         /**
  84          * Finds the corresponding AST node from which the given binding key originated.
  85          *
  86          * The default implementation of this method returns <code>null</code>.
  87          * Subclasses may reimplement.
  88          * </p>
  89          *
  90          * @param bindingKey the binding key
  91          * @return the corresponding node where the bindings is declared,
  92          *    or <code>null</code> if none
  93          */
  94         ASTNode findDeclaringNode(String bindingKey) {
  95                 return null;
  96         }
  97
  98         /**
  99          * Finds the corresponding AST node from which the given annotation instance originated.
 100          *
 101          * The default implementation of this method returns <code>null</code>.
 102          * Subclasses may reimplement.
 103          * </p>
 104          *
 105          * @param instance the dom annotation
 106          * @return the corresponding node where the bindings is declared,
 107          *    or <code>null</code> if none
 108          */
 109         ASTNode findDeclaringNode(IAnnotationBinding instance) {
 110                 return null;
 111         }
 112
 113         /**
 114          * Allows the user to get information about the given old/new pair of
 115          * AST nodes.
 116          * <p>
 117          * The default implementation of this method does nothing.
 118          * Subclasses may reimplement.
 119          * </p>
 120          *
 121          * @param currentNode the new node
 122          * @return org.eclipse.jdt.internal.compiler.ast.ASTNode
 123          */
 124         net.sourceforge.phpdt.internal.compiler.ast.ASTNode getCorrespondingNode(ASTNode currentNode) {
 125                 return null;
 126         }
 127
 128         /**
 129          * Returns the new method binding corresponding to the given old method binding.
 130          * <p>
 131          * The default implementation of this method returns <code>null</code>.
 132          * Subclasses may reimplement.
 133          * </p>
 134          *
 135          * @param methodBinding the old method binding
 136          * @return the new method binding
 137          */
 138         IMethodBinding getMethodBinding(net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding methodBinding) {
 139                 return null;
 140         }
 141
 142         /**
 143          * Returns the new member value pair binding corresponding to the given old value pair binding.
 144          * <p>
 145          * The default implementation of this method returns <code>null</code>.
 146          * Subclasses may reimplement.
 147          * </p>
 148          *
 149          * @param valuePair the old value pair binding
 150          * @return the new member value pair binding
 151          */
 152         IMemberValuePairBinding getMemberValuePairBinding(ElementValuePair valuePair) {
 153                 return null;
 154         }
 155
 156         /**
 157          * Returns the new package binding corresponding to the given old package binding.
 158          * <p>
 159          * The default implementation of this method returns <code>null</code>.
 160          * Subclasses may reimplement.
 161          * </p>
 162          *
 163          * @param packageBinding the old package binding
 164          * @return the new package binding
 165          */
 166         IPackageBinding getPackageBinding(net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding packageBinding) {
 167                 return null;
 168         }
 169
 170         /**
 171          * Returns the new type binding corresponding to the given old type binding.
 172          * <p>
 173          * The default implementation of this method returns <code>null</code>.
 174          * Subclasses may reimplement.
 175          * </p>
 176          *
 177          * @param referenceBinding the old type binding
 178          * @return the new type binding
 179          */
 180         ITypeBinding getTypeBinding(net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding referenceBinding) {
 181                 return null;
 182         }
 183
 184
 185         /**
 186          * Returns the new type binding corresponding to the given variableDeclaration.
 187          * This is used for recovered binding only.
 188          * <p>
 189          * The default implementation of this method returns <code>null</code>.
 190          * Subclasses may reimplement.
 191          * </p>
 192          *
 193          * @param variableDeclaration the given variable declaration
 194          * @return the new type binding
 195          */
 196         ITypeBinding getTypeBinding(VariableDeclaration variableDeclaration) {
 197                 return null;
 198         }
 199
 200         /**
 201          * Returns the new type binding corresponding to the given type. This is used for recovered binding
 202          * only.
 203          * <p>
 204          * The default implementation of this method returns <code>null</code>.
 205          * Subclasses may reimplement.
 206          * </p>
 207          *
 208          * @param type the given type
 209          * @return the new type binding
 210          */
 211         ITypeBinding getTypeBinding(Type type) {
 212                 return null;
 213         }
 214
 215         /**
 216          * Returns the new type binding corresponding to the given recovered type binding.
 217          * <p>
 218          * The default implementation of this method returns <code>null</code>.
 219          * Subclasses may reimplement.
 220          * </p>
 221          *
 222          * @param recoveredTypeBinding the recovered type binding
 223          * @param dimensions the dimensions to add the to given type binding dimensions
 224          * @return the new type binding
 225          */
 226         ITypeBinding getTypeBinding(RecoveredTypeBinding recoveredTypeBinding, int dimensions) {
 227                 return null;
 228         }
 229
 230         /**
 231          * Returns the new variable binding corresponding to the given old variable binding.
 232          * <p>
 233          * The default implementation of this method returns <code>null</code>.
 234          * Subclasses may reimplement.
 235          * </p>
 236          *
 237          * @param binding the old variable binding
 238          * @return the new variable binding
 239          */
 240         IVariableBinding getVariableBinding(net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding binding) {
 241                 return null;
 242         }
 243
 244         /**
 245          * Return the working copy owner for the receiver.
 246          * <p>
 247          * The default implementation of this method returns <code>null</code>.
 248          * Subclasses may reimplement.
 249          * </p>
 250          * @return the working copy owner for the receiver
 251          */
 252         public WorkingCopyOwner getWorkingCopyOwner() {
 253                 return null;
 254         }
 255
 256         /**
 257          * Return the new annotation corresponding to the given old annotation
 258          * <p>
 259          * The default implementation of this method returns <code>null</code>
 260          * Subclasses may reimplement.
 261          * </p>
 262          *
 263          * @param instance the old annotation
 264          * @return the new DOM annotation
 265          */
 266         IAnnotationBinding getAnnotationInstance(net.sourceforge.phpdt.internal.compiler.lookup.AnnotationBinding instance) {
 267                 return null;
 268         }
 269
 270         boolean isResolvedTypeInferredFromExpectedType(MethodInvocation methodInvocation) {
 271                 return false;
 272         }
 273
 274         boolean isResolvedTypeInferredFromExpectedType(SuperMethodInvocation methodInvocation) {
 275                 return false;
 276         }
 277
 278         /**
 279          * Returns the compiler lookup environment used by this binding resolver.
 280          * Returns <code>null</code> if none.
 281          *
 282          * @return the lookup environment used by this resolver, or <code>null</code> if none.
 283          */
 284         LookupEnvironment lookupEnvironment() {
 285                 return null;
 286         }
 287
 288         /**
 289          * This method is used to record the scope and its corresponding node.
 290          * <p>
 291          * The default implementation of this method does nothing.
 292          * Subclasses may reimplement.
 293          * </p>
 294          * @param astNode
 295          */
 296         void recordScope(ASTNode astNode, BlockScope blockScope) {
 297                 // default implementation: do nothing
 298         }
 299
 300         /**
 301          * Returns whether this expression node is the site of a boxing
 302          * conversion (JLS3 5.1.7). This information is available only
 303          * when bindings are requested when the AST is being built.
 304          *
 305          * @return <code>true</code> if this expression is the site of a
 306          * boxing conversion, or <code>false</code> if either no boxing conversion
 307          * is involved or if bindings were not requested when the AST was created
 308          * @since 3.1
 309          */
 310         boolean resolveBoxing(Expression expression) {
 311                 return false;
 312         }
 313
 314         /**
 315          * Returns whether this expression node is the site of an unboxing
 316          * conversion (JLS3 5.1.8). This information is available only
 317          * when bindings are requested when the AST is being built.
 318          *
 319          * @return <code>true</code> if this expression is the site of an
 320          * unboxing conversion, or <code>false</code> if either no unboxing
 321          * conversion is involved or if bindings were not requested when the
 322          * AST was created
 323          * @since 3.1
 324          */
 325         boolean resolveUnboxing(Expression expression) {
 326                 return false;
 327         }
 328
 329         /**
 330          * Resolves and returns the compile-time constant expression value as
 331          * specified in JLS2 15.28, if this expression has one. Constant expression
 332          * values are unavailable unless bindings are requested when the AST is
 333          * being built. If the type of the value is a primitive type, the result
 334          * is the boxed equivalent (i.e., int returned as an <code>Integer</code>);
 335          * if the type of the value is <code>String</code>, the result is the string
 336          * itself. If the expression does not have a compile-time constant expression
 337          * value, the result is <code>null</code>.
 338          * <p>
 339          * Resolving constant expressions takes into account the value of simple
 340          * and qualified names that refer to constant variables (JLS2 4.12.4).
 341          * </p>
 342          * <p>
 343          * Note 1: enum constants are not considered constant expressions either.
 344          * The result is always <code>null</code> for these.
 345          * </p>
 346          * <p>
 347          * Note 2: Compile-time constant expressions cannot denote <code>null</code>.
 348          * So technically {@link NullLiteral} nodes are not constant expressions.
 349          * The result is <code>null</code> for these nonetheless.
 350          * </p>
 351          *
 352          * @return the constant expression value, or <code>null</code> if this
 353          * expression has no constant expression value or if bindings were not
 354          * requested when the AST was created
 355          * @since 3.1
 356          */
 357         Object resolveConstantExpressionValue(Expression expression) {
 358                 return null;
 359         }
 360
 361         /**
 362          * Resolves and returns the binding for the constructor being invoked.
 363          * <p>
 364          * The implementation of
 365          * <code>ClassInstanceCreation.resolveConstructor</code>
 366          * forwards to this method. Which constructor is invoked is often a function
 367          * of the context in which the expression node is embedded as well as
 368          * the expression subtree itself.
 369          * </p>
 370          * <p>
 371          * The default implementation of this method returns <code>null</code>.
 372          * Subclasses may reimplement.
 373          * </p>
 374          *
 375          * @param expression the expression of interest
 376          * @return the binding for the constructor being invoked, or
 377          *    <code>null</code> if no binding is available
 378          */
 379         IMethodBinding resolveConstructor(ClassInstanceCreation expression) {
 380                 return null;
 381         }
 382
 383         /**
 384          * Resolves and returns the binding for the constructor being invoked.
 385          * <p>
 386          * The implementation of
 387          * <code>ConstructorInvocation.resolveConstructor</code>
 388          * forwards to this method. Which constructor is invoked is often a function
 389          * of the context in which the expression node is embedded as well as
 390          * the expression subtree itself.
 391          * </p>
 392          * <p>
 393          * The default implementation of this method returns <code>null</code>.
 394          * Subclasses may reimplement.
 395          * </p>
 396          *
 397          * @param expression the expression of interest
 398          * @return the binding for the constructor being invoked, or
 399          *    <code>null</code> if no binding is available
 400          */
 401         IMethodBinding resolveConstructor(ConstructorInvocation expression) {
 402                 return null;
 403         }
 404         /**
 405          * Resolves and returns the binding for the constructor being invoked.
 406          * <p>
 407          * The implementation of
 408          * <code>ConstructorInvocation.resolveConstructor</code>
 409          * forwards to this method. Which constructor is invoked is often a function
 410          * of the context in which the expression node is embedded as well as
 411          * the expression subtree itself.
 412          * </p>
 413          * <p>
 414          * The default implementation of this method returns <code>null</code>.
 415          * Subclasses may reimplement.
 416          * </p>
 417          *
 418          * @param enumConstantDeclaration the enum constant declaration of interest
 419          * @return the binding for the constructor being invoked, or
 420          *    <code>null</code> if no binding is available
 421          */
 422         IMethodBinding resolveConstructor(EnumConstantDeclaration enumConstantDeclaration) {
 423                 return null;
 424         }
 425         /**
 426          * Resolves and returns the binding for the constructor being invoked.
 427          * <p>
 428          * The implementation of
 429          * <code>SuperConstructorInvocation.resolveConstructor</code>
 430          * forwards to this method. Which constructor is invoked is often a function
 431          * of the context in which the expression node is embedded as well as
 432          * the expression subtree itself.
 433          * </p>
 434          * <p>
 435          * The default implementation of this method returns <code>null</code>.
 436          * Subclasses may reimplement.
 437          * </p>
 438          *
 439          * @param expression the expression of interest
 440          * @return the binding for the constructor being invoked, or
 441          *    <code>null</code> if no binding is available
 442          */
 443         IMethodBinding resolveConstructor(SuperConstructorInvocation expression) {
 444                 return null;
 445         }
 446         /**
 447          * Resolves the type of the given expression and returns the type binding
 448          * for it.
 449          * <p>
 450          * The implementation of <code>Expression.resolveTypeBinding</code>
 451          * forwards to this method. The result is often a function of the context
 452          * in which the expression node is embedded as well as the expression
 453          * subtree itself.
 454          * </p>
 455          * <p>
 456          * The default implementation of this method returns <code>null</code>.
 457          * Subclasses may reimplement.
 458          * </p>
 459          *
 460          * @param expression the expression whose type is of interest
 461          * @return the binding for the type of the given expression, or
 462          *    <code>null</code> if no binding is available
 463          */
 464         ITypeBinding resolveExpressionType(Expression expression) {
 465                 return null;
 466         }
 467
 468         /**
 469          * Resolves the given field access and returns the binding for it.
 470          * <p>
 471          * The implementation of <code>FieldAccess.resolveFieldBinding</code>
 472          * forwards to this method. How the field resolves is often a function of
 473          * the context in which the field access node is embedded as well as
 474          * the field access subtree itself.
 475          * </p>
 476          * <p>
 477          * The default implementation of this method returns <code>null</code>.
 478          * Subclasses may reimplement.
 479          * </p>
 480          *
 481          * @param fieldAccess the field access of interest
 482          * @return the binding for the given field access, or
 483          *    <code>null</code> if no binding is available
 484          */
 485         IVariableBinding resolveField(FieldAccess fieldAccess) {
 486                 return null;
 487         }
 488
 489         /**
 490          * Resolves the given super field access and returns the binding for it.
 491          * <p>
 492          * The implementation of <code>SuperFieldAccess.resolveFieldBinding</code>
 493          * forwards to this method. How the field resolves is often a function of
 494          * the context in which the super field access node is embedded as well as
 495          * the super field access subtree itself.
 496          * </p>
 497          * <p>
 498          * The default implementation of this method returns <code>null</code>.
 499          * Subclasses may reimplement.
 500          * </p>
 501          *
 502          * @param fieldAccess the super field access of interest
 503          * @return the binding for the given field access, or
 504          *    <code>null</code> if no binding is available
 505          */
 506         IVariableBinding resolveField(SuperFieldAccess fieldAccess) {
 507                 return null;
 508         }
 509
 510         /**
 511          * Resolves the given import declaration and returns the binding for it.
 512          * <p>
 513          * The implementation of <code>ImportDeclaration.resolveBinding</code>
 514          * forwards to this method.
 515          * </p>
 516          * <p>
 517          * The default implementation of this method returns <code>null</code>.
 518          * Subclasses may reimplement.
 519          * </p>
 520          *
 521          * @param importDeclaration the import declaration of interest
 522          * @return the binding for the given package declaration, or
 523          *         the package binding (for on-demand imports) or type binding
 524          *         (for single-type imports), or <code>null</code> if no binding is
 525          *         available
 526          */
 527         IBinding resolveImport(ImportDeclaration importDeclaration) {
 528                 return null;
 529         }
 530
 531         /**
 532          * Resolves the given annotation type declaration and returns the binding
 533          * for it.
 534          * <p>
 535          * The implementation of <code>AnnotationTypeMemberDeclaration.resolveBinding</code>
 536          * forwards to this method. How the declaration resolves is often a
 537          * function of the context in which the declaration node is embedded as well
 538          * as the declaration subtree itself.
 539          * </p>
 540          * <p>
 541          * The default implementation of this method returns <code>null</code>.
 542          * Subclasses may reimplement.
 543          * </p>
 544          *
 545          * @param member the annotation type member declaration of interest
 546          * @return the binding for the given annotation type member declaration, or <code>null</code>
 547          *    if no binding is available
 548          * @since 3.0
 549          */
 550         IMethodBinding resolveMember(AnnotationTypeMemberDeclaration member) {
 551                 return null;
 552         }
 553
 554         /**
 555          * Resolves the given method declaration and returns the binding for it.
 556          * <p>
 557          * The implementation of <code>MethodDeclaration.resolveBinding</code>
 558          * forwards to this method. How the method resolves is often a function of
 559          * the context in which the method declaration node is embedded as well as
 560          * the method declaration subtree itself.
 561          * </p>
 562          * <p>
 563          * The default implementation of this method returns <code>null</code>.
 564          * Subclasses may reimplement.
 565          * </p>
 566          *
 567          * @param method the method or constructor declaration of interest
 568          * @return the binding for the given method declaration, or
 569          *    <code>null</code> if no binding is available
 570          */
 571         IMethodBinding resolveMethod(MethodDeclaration method) {
 572                 return null;
 573         }
 574
 575         /**
 576          * Resolves the given method invocation and returns the binding for it.
 577          * <p>
 578          * The implementation of <code>MethodInvocation.resolveMethodBinding</code>
 579          * forwards to this method. How the method resolves is often a function of
 580          * the context in which the method invocation node is embedded as well as
 581          * the method invocation subtree itself.
 582          * </p>
 583          * <p>
 584          * The default implementation of this method returns <code>null</code>.
 585          * Subclasses may reimplement.
 586          * </p>
 587          *
 588          * @param method the method invocation of interest
 589          * @return the binding for the given method invocation, or
 590          *    <code>null</code> if no binding is available
 591          */
 592         IMethodBinding resolveMethod(MethodInvocation method) {
 593                 return null;
 594         }
 595
 596         /**
 597          * Resolves the given method invocation and returns the binding for it.
 598          * <p>
 599          * The implementation of <code>MethodInvocation.resolveMethodBinding</code>
 600          * forwards to this method. How the method resolves is often a function of
 601          * the context in which the method invocation node is embedded as well as
 602          * the method invocation subtree itself.
 603          * </p>
 604          * <p>
 605          * The default implementation of this method returns <code>null</code>.
 606          * Subclasses may reimplement.
 607          * </p>
 608          *
 609          * @param method the method invocation of interest
 610          * @return the binding for the given method invocation, or
 611          *    <code>null</code> if no binding is available
 612          */
 613         IMethodBinding resolveMethod(SuperMethodInvocation method) {
 614                 return null;
 615         }
 616
 617         /**
 618          * Resolves the given name and returns the type binding for it.
 619          * <p>
 620          * The implementation of <code>Name.resolveBinding</code> forwards to
 621          * this method. How the name resolves is often a function of the context
 622          * in which the name node is embedded as well as the name itself.
 623          * </p>
 624          * <p>
 625          * The default implementation of this method returns <code>null</code>.
 626          * Subclasses may reimplement.
 627          * </p>
 628          *
 629          * @param name the name of interest
 630          * @return the binding for the name, or <code>null</code> if no binding is
 631          *    available
 632          */
 633         IBinding resolveName(Name name) {
 634                 return null;
 635         }
 636
 637         /**
 638          * Resolves the given package declaration and returns the binding for it.
 639          * <p>
 640          * The implementation of <code>PackageDeclaration.resolveBinding</code>
 641          * forwards to this method.
 642          * </p>
 643          * <p>
 644          * The default implementation of this method returns <code>null</code>.
 645          * Subclasses may reimplement.
 646          * </p>
 647          *
 648          * @param pkg the package declaration of interest
 649          * @return the binding for the given package declaration, or
 650          *    <code>null</code> if no binding is available
 651          */
 652         IPackageBinding resolvePackage(PackageDeclaration pkg) {
 653                 return null;
 654         }
 655
 656         /**
 657          * Resolves the given reference and returns the binding for it.
 658          * <p>
 659          * The implementation of <code>MemberRef.resolveBinding</code> forwards to
 660          * this method. How the name resolves is often a function of the context
 661          * in which the name node is embedded as well as the name itself.
 662          * </p>
 663          * <p>
 664          * The default implementation of this method returns <code>null</code>.
 665          * Subclasses may reimplement.
 666          * </p>
 667          *
 668          * @param ref the reference of interest
 669          * @return the binding for the reference, or <code>null</code> if no binding is
 670          *    available
 671          * @since 3.0
 672          */
 673         IBinding resolveReference(MemberRef ref) {
 674                 return null;
 675         }
 676
 677         /**
 678          * Resolves the given member value pair and returns the binding for it.
 679          * <p>
 680          * The implementation of <code>MemberValuePair.resolveMemberValuePairBinding</code> forwards to
 681          * this method. How the name resolves is often a function of the context
 682          * in which the name node is embedded as well as the name itself.
 683          * </p>
 684          * <p>
 685          * The default implementation of this method returns <code>null</code>.
 686          * Subclasses may reimplement.
 687          * </p>
 688          *
 689          * @param memberValuePair the member value pair of interest
 690          * @return the binding for the member value pair, or <code>null</code> if no binding is
 691          *    available
 692          * @since 3.2
 693          */
 694         IMemberValuePairBinding resolveMemberValuePair(MemberValuePair memberValuePair) {
 695                 return null;
 696         }
 697
 698         /**
 699          * Resolves the given reference and returns the binding for it.
 700          * <p>
 701          * The implementation of <code>MethodRef.resolveBinding</code> forwards to
 702          * this method. How the name resolves is often a function of the context
 703          * in which the name node is embedded as well as the name itself.
 704          * </p>
 705          * <p>
 706          * The default implementation of this method returns <code>null</code>.
 707          * Subclasses may reimplement.
 708          * </p>
 709          *
 710          * @param ref the reference of interest
 711          * @return the binding for the reference, or <code>null</code> if no binding is
 712          *    available
 713          * @since 3.0
 714          */
 715         IBinding resolveReference(MethodRef ref) {
 716                 return null;
 717         }
 718
 719         /**
 720          * Resolves the given annotation type declaration and returns the binding
 721          * for it.
 722          * <p>
 723          * The implementation of <code>AnnotationTypeDeclaration.resolveBinding</code>
 724          * forwards to this method. How the declaration resolves is often a
 725          * function of the context in which the declaration node is embedded as well
 726          * as the declaration subtree itself.
 727          * </p>
 728          * <p>
 729          * The default implementation of this method returns <code>null</code>.
 730          * Subclasses may reimplement.
 731          * </p>
 732          *
 733          * @param type the annotation type declaration of interest
 734          * @return the binding for the given annotation type declaration, or <code>null</code>
 735          *    if no binding is available
 736          * @since 3.0
 737          */
 738         ITypeBinding resolveType(AnnotationTypeDeclaration type) {
 739                 return null;
 740         }
 741
 742         /**
 743          * Resolves the given anonymous class declaration and returns the binding
 744          * for it.
 745          * <p>
 746          * The implementation of <code>AnonymousClassDeclaration.resolveBinding</code>
 747          * forwards to this method. How the declaration resolves is often a
 748          * function of the context in which the declaration node is embedded as well
 749          * as the declaration subtree itself.
 750          * </p>
 751          * <p>
 752          * The default implementation of this method returns <code>null</code>.
 753          * Subclasses may reimplement.
 754          * </p>
 755          *
 756          * @param type the anonymous class declaration of interest
 757          * @return the binding for the given class declaration, or <code>null</code>
 758          *    if no binding is available
 759          */
 760         ITypeBinding resolveType(AnonymousClassDeclaration type) {
 761                 return null;
 762         }
 763
 764         /**
 765          * Resolves the given enum declaration and returns the binding
 766          * for it.
 767          * <p>
 768          * The implementation of <code>EnumDeclaration.resolveBinding</code>
 769          * forwards to this method. How the enum declaration resolves is often
 770          * a function of the context in which the declaration node is embedded
 771          * as well as the enum declaration subtree itself.
 772          * </p>
 773          * <p>
 774          * The default implementation of this method returns <code>null</code>.
 775          * Subclasses may reimplement.
 776          * </p>
 777          *
 778          * @param type the enum declaration of interest
 779          * @return the binding for the given enum declaration, or <code>null</code>
 780          *    if no binding is available
 781          * @since 3.0
 782          */
 783         ITypeBinding resolveType(EnumDeclaration type) {
 784                 return null;
 785         }
 786
 787         /**
 788          * Resolves the given type and returns the type binding for it.
 789          * <p>
 790          * The implementation of <code>Type.resolveBinding</code>
 791          * forwards to this method. How the type resolves is often a function
 792          * of the context in which the type node is embedded as well as the type
 793          * subtree itself.
 794          * </p>
 795          * <p>
 796          * The default implementation of this method returns <code>null</code>.
 797          * Subclasses may reimplement.
 798          * </p>
 799          *
 800          * @param type the type of interest
 801          * @return the binding for the given type, or <code>null</code>
 802          *    if no binding is available
 803          */
 804         ITypeBinding resolveType(Type type) {
 805                 return null;
 806         }
 807
 808         /**
 809          * Resolves the given class or interface declaration and returns the binding
 810          * for it.
 811          * <p>
 812          * The implementation of <code>TypeDeclaration.resolveBinding</code>
 813          * (and <code>TypeDeclarationStatement.resolveBinding</code>) forwards
 814          * to this method. How the type declaration resolves is often a function of
 815          * the context in which the type declaration node is embedded as well as the
 816          * type declaration subtree itself.
 817          * </p>
 818          * <p>
 819          * The default implementation of this method returns <code>null</code>.
 820          * Subclasses may reimplement.
 821          * </p>
 822          *
 823          * @param type the class or interface declaration of interest
 824          * @return the binding for the given type declaration, or <code>null</code>
 825          *    if no binding is available
 826          */
 827         ITypeBinding resolveType(TypeDeclaration type) {
 828                 return null;
 829         }
 830
 831         /**
 832          * Resolves the given type parameter and returns the type binding for the
 833          * type parameter.
 834          * <p>
 835          * The implementation of <code>TypeParameter.resolveBinding</code>
 836          * forwards to this method. How the declaration resolves is often a
 837          * function of the context in which the declaration node is embedded as well
 838          * as the declaration subtree itself.
 839          * </p>
 840          * <p>
 841          * The default implementation of this method returns <code>null</code>.
 842          * Subclasses may reimplement.
 843          * </p>
 844          *
 845          * @param typeParameter the type paramter of interest
 846          * @return the binding for the given type parameter, or <code>null</code>
 847          *    if no binding is available
 848          * @since 3.1
 849          */
 850         ITypeBinding resolveTypeParameter(TypeParameter typeParameter) {
 851                 return null;
 852         }
 853
 854         /**
 855          * Resolves the given enum constant declaration and returns the binding for
 856          * the field.
 857          * <p>
 858          * The implementation of <code>EnumConstantDeclaration.resolveVariable</code>
 859          * forwards to this method.
 860          * </p>
 861          * <p>
 862          * The default implementation of this method returns <code>null</code>.
 863          * Subclasses may reimplement.
 864          * </p>
 865          *
 866          * @param enumConstant the enum constant declaration of interest
 867          * @return the field binding for the given enum constant declaration, or
 868          *    <code>null</code> if no binding is available
 869          * @since 3.0
 870          */
 871         IVariableBinding resolveVariable(EnumConstantDeclaration enumConstant) {
 872                 return null;
 873         }
 874
 875         /**
 876          * Resolves the given variable declaration and returns the binding for it.
 877          * <p>
 878          * The implementation of <code>VariableDeclaration.resolveBinding</code>
 879          * forwards to this method. How the variable declaration resolves is often
 880          * a function of the context in which the variable declaration node is
 881          * embedded as well as the variable declaration subtree itself. VariableDeclaration
 882          * declarations used as local variable, formal parameter and exception
 883          * variables resolve to local variable bindings; variable declarations
 884          * used to declare fields resolve to field bindings.
 885          * </p>
 886          * <p>
 887          * The default implementation of this method returns <code>null</code>.
 888          * Subclasses may reimplement.
 889          * </p>
 890          *
 891          * @param variable the variable declaration of interest
 892          * @return the binding for the given variable declaration, or
 893          *    <code>null</code> if no binding is available
 894          */
 895         IVariableBinding resolveVariable(VariableDeclaration variable) {
 896                 return null;
 897         }
 898
 899         /**
 900          * Resolves the given well known type by name and returns the type binding
 901          * for it.
 902          * <p>
 903          * The implementation of <code>AST.resolveWellKnownType</code>
 904          * forwards to this method.
 905          * </p>
 906          * <p>
 907          * The default implementation of this method returns <code>null</code>.
 908          * Subclasses may reimplement.
 909          * </p>
 910          *
 911          * @param name the name of a well known type
 912          * @return the corresponding type binding, or <code>null<code> if the
 913          *   named type is not considered well known or if no binding can be found
 914          *   for it
 915          */
 916         ITypeBinding resolveWellKnownType(String name) {
 917                 return null;
 918         }
 919
 920         /**
 921          * Resolves the given annotation instance and returns the DOM representation for it.
 922          * <p>
 923          * The implementation of {@link Annotation#resolveAnnotationBinding()}
 924          * forwards to this method.
 925          * </p>
 926          * <p>
 927          * The default implementation of this method returns <code>null</code>.
 928          * Subclasses may reimplement.
 929          * </p>
 930          *
 931          * @param annotation the annotation ast node of interest
 932          * @return the DOM annotation representation for the given ast node, or
 933          *    <code>null</code> if none is available
 934          */
 935         IAnnotationBinding resolveAnnotation(Annotation annotation) {
 936                 return null;
 937         }
 938
 939         /**
 940          * Answer an array type binding with the given type binding and the given
 941          * dimensions.
 942          *
 943          * <p>If the given type binding is an array binding, then the resulting dimensions is the given dimensions
 944          * plus the existing dimensions of the array binding. Otherwise the resulting dimensions is the given
 945          * dimensions.</p>
 946          *
 947          * <p>
 948          * The default implementation of this method returns <code>null</code>.
 949          * Subclasses may reimplement.
 950          * </p>
 951          *
 952          * @param typeBinding the given type binding
 953          * @param dimensions the given dimensions
 954          * @return an array type binding with the given type binding and the given
 955          * dimensions
 956          * @throws IllegalArgumentException if the type binding represents the <code>void</code> type binding
 957          */
 958         ITypeBinding resolveArrayType(ITypeBinding typeBinding, int dimensions) {
 959                 return null;
 960         }
 961
 962         /**
 963          * Returns the compilation unit scope used by this binding resolver.
 964          * Returns <code>null</code> if none.
 965          *
 966          * @return the compilation unit scope by this resolver, or <code>null</code> if none.
 967          */
 968         public CompilationUnitScope scope() {
 969                 return null;
 970         }
 971
 972         /**
 973          * Allows the user to store information about the given old/new pair of
 974          * AST nodes.
 975          * <p>
 976          * The default implementation of this method does nothing.
 977          * Subclasses may reimplement.
 978          * </p>
 979          *
 980          * @param newNode the new AST node
 981          * @param oldASTNode the old AST node
 982          */
 983         void store(ASTNode newNode, org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode) {
 984                 // default implementation: do nothing
 985         }
 986
 987         /**
 988          * Allows the user to update information about the given old/new pair of
 989          * AST nodes.
 990          * <p>
 991          * The default implementation of this method does nothing.
 992          * Subclasses may reimplement.
 993          * </p>
 994          *
 995          * @param node the old AST node
 996          * @param newNode the new AST node
 997          */
 998         void updateKey(ASTNode node, ASTNode newNode) {
 999                 // default implementation: do nothing
1000         }
1001 }