Source code: com/port80/eclipse/jdt/graph/MethodReferenceASTVisitor.java

   package com.port80.eclipse.jdt.graph;
   
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
   import java.util.Stack;
  
  import org.eclipse.jdt.core.dom.ASTNode;
  import org.eclipse.jdt.core.dom.ASTVisitor;
  import org.eclipse.jdt.core.dom.ArrayType;
  import org.eclipse.jdt.core.dom.ClassInstanceCreation;
  import org.eclipse.jdt.core.dom.Expression;
  import org.eclipse.jdt.core.dom.FieldAccess;
  import org.eclipse.jdt.core.dom.IBinding;
  import org.eclipse.jdt.core.dom.IMethodBinding;
  import org.eclipse.jdt.core.dom.ITypeBinding;
  import org.eclipse.jdt.core.dom.MethodDeclaration;
  import org.eclipse.jdt.core.dom.MethodInvocation;
  import org.eclipse.jdt.core.dom.Name;
  import org.eclipse.jdt.core.dom.PackageDeclaration;
  import org.eclipse.jdt.core.dom.QualifiedName;
  import org.eclipse.jdt.core.dom.SimpleName;
  import org.eclipse.jdt.core.dom.SimpleType;
  import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
  import org.eclipse.jdt.core.dom.SuperMethodInvocation;
  import org.eclipse.jdt.core.dom.ThisExpression;
  import org.eclipse.jdt.core.dom.TypeDeclaration;
  
  import com.port80.util.Msg;
  
  /**
   * Find method referenced in a given CompilationUnit.
   * 
   * @author chrisl
   */
  public class MethodReferenceASTVisitor extends ASTVisitor {
  
    ////////////////////////////////////////////////////////////////////////
  
    private static final String NAME = "MethodReferenceASTVisitor";
    private static final boolean DEBUG = true;
    private static final boolean TERSE = false;
  
    public static class Result {
      /** 
       * Declared types. FullyQualifiedName->ITypeBinding mapping.
       */
      public Set fDeclares;
      /**
       * Methods declared in this unit.
       */
      public Set fMethods;
      /** 
       * Super classes.  Fully qualified typename -> ITypeBinding.
       */
      public Map fSuperClasses;
      /** 
       * FullQualifiedName->ITypeBinding mapping.
       */
      public Map fSuperInterfaces;
      /** 
       * Referenced types. Source TypeWrapper ->Set(Dest. TypeWrapper )mapping.
       */
      public Map fReferences;
      /** 
       * Caller(TypeWrapper/MethodWrapper)->Set(callee(MethodWrapper)) mapping.
       */
      public Map fCalls;
  
      /** Stack of TypeWrapper for type being declared.*/
      private Stack fTypeStack;
      /** Stack of MethodWrapper for method being declared.*/
      private Stack fMethodStack;
  
      public Result() {
        fReferences = new HashMap();
        fSuperClasses = new HashMap();
        fSuperInterfaces = new HashMap();
        fDeclares = new HashSet();
        fMethods = new HashSet();
        fCalls = new HashMap();
        fTypeStack = new Stack();
        fMethodStack = new Stack();
      }
      public Set getDeclares() {
        return fDeclares;
      }
      public Map getSuperClasses() {
        return fSuperClasses;
      }
      public Map getReferences() {
        return fReferences;
      }
      public Map getSuperInterfaces() {
        return fSuperInterfaces;
      }
     public Set getMethods() {
       return fMethods;
     }
     public Map getCalls() {
       return fCalls;
     }
     public void declareTypeStart(ITypeBinding type) {
       if (type == null) {
         Msg.err(NAME + ".declareTypeStart(): type==null");
         return;
       }
       TypeWrapper wrapper = new TypeWrapper(type);
       fTypeStack.push(wrapper);
     }
     public void declareTypeEnd(ITypeBinding type) {
       if (type != null)
         fTypeStack.pop();
     }
     public void declareMethodStart(IMethodBinding method) {
       if (method == null) {
         Msg.err(NAME + ".declareMethodStart(): method==null");
         return;
       }
       MethodWrapper wrapper = new MethodWrapper(method);
       fMethodStack.push(wrapper);
       fMethods.add(wrapper);
       if (DEBUG)
         Msg.println(NAME + ".declareMethod(): " + wrapper.getNotSoSimpleSignature());
     }
     public void declareMethodEnd(IMethodBinding method) {
       if (method != null)
         fMethodStack.pop();
     }
     public TypeWrapper getCurrentType() {
       if (fTypeStack.isEmpty())
         return null;
       return (TypeWrapper) fTypeStack.peek();
     }
     public MethodWrapper getCurrentMethod() {
       if (fMethodStack.isEmpty())
         return null;
       return (MethodWrapper) fMethodStack.peek();
     }
     public void addCall(IMethodBinding method) {
       MethodWrapper callee = new MethodWrapper(method);
       MethodWrapper caller = null;
       if (!fMethodStack.isEmpty())
         caller = (MethodWrapper) fMethodStack.peek();
       if (caller != null) {
         Set callees = (Set) fCalls.get(caller);
         if (callees == null) {
           callees = new HashSet();
           fCalls.put(caller, callees);
         }
         callees.add(callee);
         if (DEBUG)
           Msg.println(
             NAME
               + ".Result.addCall(): method:\n\tcaller="
               + caller.getNotSoSimpleSignature()
               + "\n\tcallee="
               + callee.getNotSoSimpleSignature());
       } else {
         TypeWrapper type = (TypeWrapper) fTypeStack.peek();
         Set callees = (Set) fCalls.get(type);
         if (callees == null) {
           callees = new HashSet();
           fCalls.put(type, callees);
         }
         callees.add(callee);
         if (DEBUG)
           Msg.println(
             NAME
               + ".Result.addCall(): type:\n\ttype="
               + type.getFullName()
               + "\n\tcallee="
               + callee.getNotSoSimpleSignature());
       }
     }
     public void addReference(ITypeBinding type) {
       TypeWrapper referencee = new TypeWrapper(type);
       TypeWrapper referer = getCurrentType();
       if (referer == null) {
         Msg.err("No caller");
         return;
       }
       Set referencees = (Set) fReferences.get(referer);
       if (referencees == null) {
         referencees = new HashSet();
         fReferences.put(referer, referencees);
       }
       referencees.add(referencee);
       if (DEBUG)
         Msg.println(
           NAME
             + ".Result.addReference(): referer\n\treferer="
             + referer.getFullName()
             + "\n\treferencee="
             + referencee.getFullName());
     }
   }
 
   private Result fResult;
 
   ////////////////////////////////////////////////////////////////////////
 
   /**
    * @return Type references in a (String fullTypeName) -> (ITypeBinding type) hash.
    */
   public static MethodReferenceASTVisitor startAt(ASTNode root) {
     MethodReferenceASTVisitor visitor = new MethodReferenceASTVisitor();
     root.accept(visitor);
     return visitor;
   }
 
   public Result getResult() {
     return fResult;
   }
 
   public MethodReferenceASTVisitor() {
     fResult = new Result();
   }
 
   private ITypeBinding addDeclaredType(Name node) {
     ITypeBinding type = resolveType(node);
     if (type == null) {
       Msg.err(NAME + ".addDeclaredType(): type==null: node=" + node);
     } else {
       fResult.fDeclares.add(new TypeWrapper(type));
     }
     return type;
   }
 
   private IMethodBinding addCall(Name node) {
     IMethodBinding binding = resolveMethod(node);
     if (binding != null)
       fResult.addCall(binding);
     else
       Msg.err(NAME + ".addCall(): binding==null: node=" + node);
     return binding;
   }
 
   private ITypeBinding resolveType(Name node) {
     while (node != null) {
       IBinding binding = node.resolveBinding();
       if (DEBUG)
         Msg.println(NAME + ".resolveType(): " + node);
       if (binding != null && binding.getKind() == IBinding.TYPE) {
         return (ITypeBinding) binding;
       }
       if (node.isQualifiedName())
         node = ((QualifiedName) node).getQualifier();
     }
     return null;
   }
 
   /**
    * If a nested type is referenced, only the nested type is counted.
    * Its enclosing type is not counted.
    */
   private ITypeBinding typeRefFound(Name node) {
     if (DEBUG)
       System.err.println(NAME + ".typeRefFound(): " + node);
     while (node != null) {
       IBinding binding = node.resolveBinding();
       if (binding != null && binding.getKind() == IBinding.TYPE) {
         fResult.addReference((ITypeBinding) binding);
         return (ITypeBinding) binding;
       }
       if (node.isQualifiedName())
         node = ((QualifiedName) node).getQualifier();
       else
         break;
     }
     return null;
   }
 
   private void possibleTypeRefFound(Name node) {
     if (DEBUG)
       System.err.println(NAME + ".possibleTypeRefFound(): " + node);
     while (node != null) {
       IBinding binding = node.resolveBinding();
       if (binding != null && binding.getKind() == IBinding.TYPE) {
         fResult.addReference((ITypeBinding) binding);
         break;
       }
       if (node.isQualifiedName())
         node = ((QualifiedName) node).getQualifier();
       else
         break;
     }
   }
 
   ////////////////////////////////////////////////////////////////////////
 
   private IMethodBinding resolveMethod(Name node) {
     if (node == null)
       return null;
     // A more general call to resolve binding.
     // getAST().getBindingResolver().resolveConstructor(node);
     IBinding binding = node.resolveBinding();
     if (DEBUG) {
       System.err.println(NAME + ".resolveMethod(): node=" + node);
     }
     if (binding != null && binding.getKind() == IBinding.METHOD) {
       return (IMethodBinding) binding;
     } else {
       Msg.err(NAME + ".resolveMethod(): can't resolve method: node=" + node + ", binding=" + binding);
     }
     return null;
   }
 
   ////////////////////////////////////////////////////////////////////////
 
   private void visitChildren(List elements) {
     int nElements = elements.size();
     for (int i = 0; i < nElements; i++) {
       ((ASTNode) elements.get(i)).accept(this);
     }
   }
 
   ////////////////////////////////////////////////////////////////////////
 
   /*
    * @see ASTVisitor#visit(ArrayType)
    */
   public boolean visit(ArrayType node) {
     node.getElementType().accept(this);
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(SimpleType)
    */
   public boolean visit(SimpleType node) {
     typeRefFound(node.getName());
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(QualifiedName)
    */
   public boolean visit(QualifiedName node) {
     possibleTypeRefFound(node); // possible ref
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(PackageDeclaration)
    */
   public boolean visit(PackageDeclaration node) {
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(ThisExpression)
    */
   public boolean visit(ThisExpression node) {
     typeRefFound(node.getQualifier());
     return false;
   }
 
   private void evalQualifyingExpression(Expression expr) {
     if (expr != null) {
       if (expr instanceof Name) {
         possibleTypeRefFound((Name) expr);
       } else {
         expr.accept(this);
       }
     }
   }
 
   /*
    * @see ASTVisitor#visit(ClassInstanceCreation)
    */
   public boolean visit(ClassInstanceCreation node) {
     typeRefFound(node.getName());
     evalQualifyingExpression(node.getExpression());
     //
     IMethodBinding method = node.resolveConstructorBinding();
     if (method == null) {
       Msg.err(NAME + ".visit(ClassInstanceCreation): method==null: node=" + node);
     } else {
       fResult.addCall(method);
     }
     //
     if (node.getAnonymousClassDeclaration() != null) {
       node.getAnonymousClassDeclaration().accept(this);
     }
     visitChildren(node.arguments());
     return false;
   }
 
   /*
    * @see ASTVisitor#endVisit(MethodInvocation)
    */
   public boolean visit(MethodInvocation node) {
     if (DEBUG)
       System.err.println(NAME + ".visit(MethodInvocation): node=" + node);
     evalQualifyingExpression(node.getExpression());
     addCall(node.getName());
     visitChildren(node.arguments());
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(SuperConstructorInvocation)
    */
   public boolean visit(SuperConstructorInvocation node) {
     evalQualifyingExpression(node.getExpression());
     //
     IMethodBinding method = node.resolveConstructorBinding();
     if (method == null) {
       Msg.err(NAME + ".visit(SuperConstructorInvocation): method==null: node=" + node);
     } else {
       fResult.addCall(method);
     }
     //
     visitChildren(node.arguments());
     return false;
   }
 
   public boolean visit(SuperMethodInvocation node) {
     addCall(node.getName());
     //
     visitChildren(node.arguments());
     return false;
   }
   /*
    * @see ASTVisitor#visit(FieldAccess)
    */
   public boolean visit(FieldAccess node) {
     evalQualifyingExpression(node.getExpression());
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(SimpleName)
    */
   public boolean visit(SimpleName node) {
     // if the call gets here, it can only be a variable reference
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(TypeDeclaration)
    */
   public boolean visit(TypeDeclaration node) {
     ITypeBinding type = addDeclaredType(node.getName());
     fResult.declareTypeStart(type);
     visitChildren(node.bodyDeclarations());
     fResult.declareTypeEnd(type);
     return false;
   }
 
   /*
    * @see ASTVisitor#visit(MethodDeclaration)
    */
   public boolean visit(MethodDeclaration node) {
     if (!node.isConstructor()) {
       node.getReturnType().accept(this);
     }
     visitChildren(node.parameters());
     Iterator iter = node.thrownExceptions().iterator();
     while (iter.hasNext()) {
       typeRefFound((Name) iter.next());
     }
     IMethodBinding method = resolveMethod(node.getName());
     if (method == null) {
       Msg.err(NAME + ".visit(MethodDeclaration(): method==null: node=" + node);
     } else {
       fResult.declareMethodStart(method);
     }
     if (node.getBody() != null) {
       node.getBody().accept(this);
     }
     fResult.declareMethodEnd(method);
     return false;
   }
 
   /*
    * @see ASTVisitor#preVisit(ASTNode)
    */
   public void preVisit(ASTNode node) {
     if ((node.getFlags() & ASTNode.MALFORMED) != 0) {
       throw new ASTError(node);
     }
   }
 
   ////////////////////////////////////////////////////////////////////////
 
 }