CODEWITHSUNDEEP
javaeclipse-jdtstatic-code-analysis
Abaddon666
Abaddon666

Reputation: 1623

Determine all Strings (dynamically built and literals) passed to a method in Java

I am trying to build a static code analysis, that allows to collect all Strings passed to a function without running the code. I am using Eclipse JDT (3.10.0) to parse the code.

Assumptions/Precodinditions:

What i have:

At the moment i am able to identify all MethodInvocations on that particular Method and therefore am able to collect all arguments passed as StringLiterals. I am able to see all argument Types but, of course, cannot determine the value of parameters, fields, objects etc. as the value binding would only be available at runtime.

The Problem

Under the assumption, that every single passed Argument (no matter the Type) is at some time resolvable to a StringLiteral or a Concatenation of StringLiterals, i should be able to determine the distinct set of all Values which are passed to this method by the program. Is there a way, to recursively determine the String value of all method calls without following every stacktrace and manually implementing the logic for every occurence?

Imagine the following examples:

public class IAmAnalysed{
    public void analysedMethod(String argument){
        //do something useful
    }
}

//Values in a map
hashMap.put("test", "TestString");
hashMap.put("test2", "TestString2");
for (Map.Entry<String, String> e : hashMap.entrySet()) {
    iAmAnalysed.analysedMethod(e.getValue);
}

//util method
public void util(String argument){
    iAmAnalysed.analysedMethod(argument + "utilCalled");  
}
util("TestString3")

This should give me the following set of values:

TestString
TestString2
TestString3utilCalled

The only appraoch i can think of (using Eclipse JDT) is to add every argument that is no StringLiteral to a working Set and start one more iteration with the ASTParser to determine where the passed value is set, or where it comes from. Then i add this location to the workingSet and iterate once more. This at the end should lead me to all possible arguments. Unfortunately with this approach i would have to implement logic for every single possible way the value could be passed (imagine all the other possibilities next to the two above)

Upvotes: 1

Views: 86

Answers (1)

Stephan Herrmann
Stephan Herrmann

Reputation: 8178

Examining all possible data flows into a given method is not generally feasible by static analysis. The approach you outline can work for a small group of programs, until you hit, e.g., recursion, at what point the thing will blow up.

Maybe a comprehensive test suite will give better results than static analysis on this one.

Upvotes: 2

Related Questions