Use ANTLR to find Variable usage/reference in Java source-code?

Question

A variable usage is basically every occurrence of a variable after its declaration in the same scope, where some operation may be applied to it. Variable usage highlighting is even supported in some IDEs like IntelliJ and Eclipse .

I was wondering if there is a way to find variable usages using ANTLR ? I have already generated the Lexer , Parser , and BaseListener classes by running ANTLR on Java8.g4 . I can find variable declarations but am not able to find variable usages in a given Java source code. How can I do this ?

Example :

int i;    // Variable declaration
i++;      // Variable usage
i = 2;    // Variable usage
foo(i);   // Variable 'i' usage

I am able to capture the declaration but not usage using the Listener class. I am parsing Java source codes here.

Answer 1

I'll assume you're only considering local variables.

You'll need scopes and resolving to do this.

Scope will represent Java's variable scope. It will hold information about which variables are declared in the given scope. You'll have to create it when you enter a Java scope (start of block, method, ...) and get rid of it upon leaving the scope. You'll keep a stack of scopes to represent nested blocks / scopes (Java doesn't allow hiding a local variable in nested scope, but you still need to track when a variable goes out of scope at the end of a nested scope).

And then you'll need to resolve each name you encounter in the parsed input - determine whether the name refers to a variable or not (using scope). Basically, it refers to a local variable, whenever it is the first part of name (before any . ), is not followed by ( and matches a name of a local variable.

Parser cannot do this for you, because whether a name refers to a variable or not depends on available variables:

private static class A {
    B out = new B();
}

private static class B {
    void println(String foo) {
        System.out.println("ha");
    }
}

public static void main(String[] args) {
    {
        A System = new A();
        System.out.println("a");
    }
    System.out.println("b");
}

ha
b

---

If you're considering also instance and static fields instead of just local variables, the resolving part becomes much more complicated, because you'll need to consider all classes in the current class' hierarchy, their instance and static fields, visibilities etc. to determine whether a variable of a given name exists and is visible.