Marking of this project

You need to present your work in person to me. We will run similarity check between all the submissions, including the ones in the past and the solution from professionals. There will be zero tolerance for plagiarism. There will not be any partial marks for this project.

Due date

This assignment is worth 5 points. You need to submit your report before November 29, 11:00 AM, then present your work to me in person before 4pm the same day. In your presentation you need to explain the details and run a live demo. Submissions without presentation will receive zero mark.

This assignment is meant to be a complicated one. You need to spend long hours to get familiar with JDT, Eclipse, and Eclipse plug-in.

There are different ways to count the methods and classes. For instance, we see that polymophic methods are treated as either equally or differently. Both implementations will be considered acceptable, although our prefeered solution is to treat polymorphic methods as different ones.

The numbers can be also slightly different depending on your way to visit these AST nodes. Using SimpleName and MethodInvocation can cause slight difference. Either way is considered correct.

The problem

Your task is to analyse Java source code so that you can count all the method calls in JDK (src.zip) (Java Development Kit). This zip file contains 7471 java files, 371k lines of code. Among all these java files,

for each class, count the method calls it received;
for each method, count the number of times this method is called;

For instance, when you see the following statement,

 aString.toUpperCase();

The String class receives one more method call, and the toUpperCase() method is used one more time. The object 'aString' can be of any name, and you should not count the occurrence of variable names. You need to utilize the parsing result to infer that it is of type String. To avoid name conflict, you should use the complete package path in your program and in your report. For example, String should be written as "java.lang.String", toUpperCase should be "java.lang.String.toUpperCase()".

Method

You need to parse the source code so that you can extract the relevant information. You can choose one of the existing Java parsers. One choice is Eclipse JDT that can generate an AST (abstract syntax tree). It won't suffice to manipilate the source code directly using tools such as regular expression. One reason is that there are comments, which can be very complex and can contain code snippets. In addition, there are a few other cases you need to consider:

```
  String[] toppings = {"cheese", "pepperoni", "black olives"};
    int arrayLength = toppings.length; 
```
In the above example, length is an atrtibute instead of a method. So we will not count that as a method call.
```
  String toppings = "cheese, pepperoni, black olives";
        String[] tokens= toppings.toUpperCase().split(","); 
```
In the above example, toppings, i.e., the String class, received one method call, toppings.toUpperCase(), which is also a String, received another method call. Thus, in this line, String received two method calls.
```
 System.out.println(".out is not a method call"); 
```
In the above example, out is not a method call. But println is a method call.

 Class A {  int fac(int x) { return (x>0)?x*fac(x-1):1; }};

In the above example, fac is a method call that is invoked once.

```
 public static void  main (String[] args){}
```
has a reference for String, but there is no method call. So String class should not have one more count.

What to submit

Submit one zipped file that contains the following files:

Your source code. You can use a programming language of your choice, but the source code to be analysed is JDK, which is in Java.

One pdf file of one page length, describing briefly the method you used, the challenges you encounter, and a table that lists the top 20 classes and top 20 methods. Use the following format to list these classes and methods.

 
  class1 classcount1;  method1 methodcount1
  class2 classcount2;  method2 methodcount2
  ... 
  class20 classcount20; method20 methodcount20

To partially verify your result, note that the most frequently used class is the String class. One thing you need to take care of is polymorphic methods. Please treat each polymorhic method as a distinct one (our preferred solution). For instance, there are many append methods, the counting of each append method in StringBuffer are given below.

java.lang.StringBuffer.append(String)	<>	1480
java.lang.StringBuffer.append(char)	<>	705
java.lang.StringBuffer.append(int)	<>	112
java.lang.StringBuffer.append(Object)	<>	38
java.lang.StringBuffer.append(char[]intint)	<>	32
java.lang.StringBuffer.append(StringBuffer)	<>	8
java.lang.StringBuffer.append(long)	<>	3
java.lang.StringBuffer.append(char[])	<>	3
java.lang.StringBuffer.append(float)	<>	3
java.lang.StringBuffer.append(CharSequenceintint)	<>	3
java.lang.StringBuffer.append(CharSequence)	<>	2
java.lang.StringBuffer.append(double)	<>	1
java.lang.StringBuffer.append(boolean)	<>	1

Hints on using JDT

Create the AST (abstract syntax tree) using the following:

  ASTParser parser = ASTParser.newParser(AST.JLS3);
                parser.setKind(ASTParser.K_COMPILATION_UNIT);
                parser.setSource(unit);
                parser.setResolveBindings(true);

where the unit has to be an ICompilationUnit.

To obtain an ICompilation object, you need to use the JDT Java Model, which is only available in Eclipse plug-in. You can follow this tutorial on plug-in. You can use a sample Eclipse plugin (say the hello world sample). Once it is ready, use the the following example (from Vogel's tutorial) to process (analyse) a project. Import all the jdk source files into the project so that you can analyse it.

public class SampleHandler extends AbstractHandler {

  public Object execute(ExecutionEvent event) throws ExecutionException {
    // Get the root of the workspace
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    IWorkspaceRoot root = workspace.getRoot();
    // Get all projects in the workspace
    IProject[] projects = root.getProjects();
    // Loop over all projects
    for (IProject project : projects) {
      try {
        printProjectInfo(project);
      } catch (CoreException e) {
        e.printStackTrace();
      }
    }
    return null;
  }
  ...
}

Once you have the AST, you can use the ASTVisitor to access various nodes and their bindings as below. The following code is from Martin's slides.

STNode root= parser.createAST(null);
root.accept(new ASTVisitor() {

  public boolean visit(CastExpression node) {
    fCastCount++;
    return true;
  }

  public boolean visit(SimpleName node) {
    IBinding binding= node.resolveBinding();
    if (binding instanceof IVariableBinding) {
      IVariableBinding varBinding= (IVariableBinding) binding;
      ITypeBinding declaringType= varBinding.getDeclaringClass();
      if (varBinding.isField() &&
               "java.lang.System".equals(declaringType.getQualifiedName())) {
         fAccessesToSystemFields++;
      }
    }
    return true;
  }
})

Method Call Counter