How can I detect by static analysis, if a project is using Java8?

Question

I am currently using javaparser (https://github.com/javaparser/javaparser) and javasymbolsolver(https://github.com/javaparser/javasymbolsolver), to parse through the code. Will it be a holistic approach if I detect the usage of Collections#Streams, to decide that the particular project has migrated to Java8.(Assuming that Collection#Streams is the most widely used java8 feature).

Answer 1

I can see multiple approaches here, both source- and binaries-based, looking for Java 8 APIs and looking for Java 8 language features.

Look for Java 8 APIs

Look for common Java 8 APIs in source code (simple)

You can parse the code and look for the APIs that first appeared in Java 8 - as you've suggested in your answer. The most commonly known features of Java 8 API are streams and Optional class, as well as java.util.function package. I would expect almost any project that migrated to Java 8 to use these features.

Look for all Java 8 APIs in source code (advanced)

To have 100% answer if a particular project uses Java 8 API or not, you would need to look not for some, but for all APIs that were added in Java 8. There are probably many ways to find that list, but there is a tool called Sigtest created specifically to compare APIs of different versions of a product (in this case the product being Java itself).

Do the same in binaries

Probably a cheaper approach would be to use binaries rather than source files. All the external links are placed in the beginning of a .class-file, in a section called constant pool. There are tools that can help you to extract this data, e.g. ClassDep (it is distributed as a part of Apache River, but you can use it standalone).

Check language version

Check class file versions in binaries

For each language version there is a different version recorded in class files. For Java 7 that's 51.0, for Java 8 - 52.0, for Java 9 - 53.0. javap tool that comes with the JDK prints this version when launched with -v option.

Look for Java 8 language features

Since you're working with source code, I assume that your parser supports Java 8. If so, it will be able to identify Java 8 language structures, like lambdas and method references. The full (well, I assume it's full) list of Java 8 language features is here.

On accuracy of the results

The accuracy of each approach depends on what the question is. If it's "Does a project use Java 8 at all?" then no single approach will give 100% result. As Holger noted in his comments, there could be projects that partially migrated, that are only compiled for Java 8 and don't use any of its APIs, or that only use Java 8 APIs but are compiled for Java 7.

Question "Does a project use compilation with language level 8?" is best answered by class file version analysis - any class that uses lambdas will have version 52.0, but not vice versa.

Question "Does a project use Java 8 APIs?", obviously, requires analysis of references. I can only speculate on whether or not analysis of selected APIs is sufficient - a research like the one you're doing is what can give that answer.

Answer 2

You can look for Java8 features.

Your best bet is to try to compile the code [yes, this is considered static analysis!] with a Java7 compiler, and a Java8 compiler, and see which one gives you the fewest compilation errors over the code base. (You can generalize this to any of Java vN compilers easily enough).

If one compiler succeeds completely, and one the other does not, then your answer seems pretty clear.

If both compilers produce errors, you'll have to fall back on some other indicator (like, does it use Java8 features).

If the code compiles with both, you don't really know; it may be that some dark semantic corner of Java8 is critically used. At this point, the only way to tell is to run functionality regression tests, and choose the one that passes the most tests.