CODEWITHSUNDEEP
javacheckstyle
roskakori
roskakori

Reputation: 3336

Automatically fix non formatting but simple CheckStyle issues

Is there a command line tool that can automatically fix non formatting but still seemingly simple CheckStyle issues in Java source code like:

I know there are various tools to fix formatting and some IDEs have fairly advanced quick fixers but so far I could not find anything that can recursively run on a source code folder or be integrated in a commit hook.

Upvotes: 1

Views: 1330

Answers (1)

Freek de Bruijn
Freek de Bruijn

Reputation: 3622

Sounds like a nice challenge, but I was also unable to find an automatic tool that can do this. As you already described, there are plenty of options to change code formatting. For other small issues, you could perhaps run Checkstyle from the command-line and filter out fixable warnings. A library for parsing and changing Java source code could help to actually make the changes, like for example JavaParser. Perhaps you could write a custom tool in a relatively small amount of time using a Java source code manipulation tool like JavaParser.

(There are other tools like ANTLR that could be used; see for more ideas this question on Stack Overflow: Java: parse java source code, extract methods. Some libraries like Roaster and JavaPoet do not parse the body of methods, which makes them less suitable in this situation.)

As a very simple example, assume we have a small Java class for which Checkstyle generates two messages (with a minimalistic checkstyle-checks.xml Checkstyle configuration file that only checks FinalParameters and FinalLocalVariable):

// Example.java:

package q45326752;

public class Example {
    public static void main(String[] arguments) {
        System.out.println("Hello Checkstyle...");

        int perfectNumber = 1 + 2 + 3;

        System.out.println("Perfect number: " + perfectNumber);
    }
}


Checkstyle warnings:

java -jar checkstyle-8.0-all.jar -c checkstyle-checks.xml Example.java
[ERROR] Example.java:4:29: Parameter arguments should be final. [FinalParameters]
[ERROR] Example.java:7:13: Variable 'perfectNumber' should be declared final. [FinalLocalVariable]

Using JavaParser, these two warnings could be fixed automatically like this (the code tries to demonstrate the idea; some parts have been ignored for now):

// AutomaticCheckstyleFix.java:

package q45326752;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.*;
import com.github.javaparser.ast.body.*;
import com.github.javaparser.ast.expr.*;
import com.github.javaparser.ast.stmt.*;

import java.io.File;
import java.io.FileNotFoundException;

public class AutomaticCheckstyleFix {
    private MethodDeclaration bestMatchMethod;
    private int bestMatchMethodLineNumber;
    private Statement statementByLineNumber;

    public static void main(final String[] arguments) {
        final String filePath = "q45326752\\input\\Example.java";

        try {
            new AutomaticCheckstyleFix().fixSimpleCheckstyleIssues(new File(filePath));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    private void fixSimpleCheckstyleIssues(File file) throws FileNotFoundException {
        CompilationUnit javaClass = JavaParser.parse(file);
        System.out.println("Original Java class:\n\n" + javaClass);
        System.out.println();
        System.out.println();

        // Example.java:4:29: Parameter arguments should be final. [FinalParameters]
        MethodDeclaration methodIssue1 = getMethodByLineNumber(javaClass, 4);
        if (methodIssue1 != null) {
            methodIssue1.getParameterByName("arguments")
                  .ifPresent(parameter -> parameter.setModifier(Modifier.FINAL, true));
        }

        // Example.java:7:13: Variable 'perfectNumber' should be declared final.
        // [FinalLocalVariable]
        Statement statementIssue2 = getStatementByLineNumber(javaClass, 7);
        if (statementIssue2 instanceof ExpressionStmt) {
            Expression expression = ((ExpressionStmt) statementIssue2).getExpression();
            if (expression instanceof VariableDeclarationExpr) {
                ((VariableDeclarationExpr) expression).addModifier(Modifier.FINAL);
            }
        }

        System.out.println("Modified Java class:\n\n" + javaClass);
    }

    private MethodDeclaration getMethodByLineNumber(CompilationUnit javaClass,
                                                    int issueLineNumber) {
        bestMatchMethod = null;

        javaClass.getTypes().forEach(type -> type.getMembers().stream()
                .filter(declaration -> declaration instanceof MethodDeclaration)
                .forEach(method -> {
                    if (method.getTokenRange().isPresent()) {
                        int methodLineNumber = method.getTokenRange().get()
                                .getBegin().getRange().begin.line;
                        if (bestMatchMethod == null
                                || (methodLineNumber < issueLineNumber
                                && methodLineNumber > bestMatchMethodLineNumber)) {
                            bestMatchMethod = (MethodDeclaration) method;
                            bestMatchMethodLineNumber = methodLineNumber;
                        }
                    }
                })
        );

        return bestMatchMethod;
    }

    private Statement getStatementByLineNumber(CompilationUnit javaClass,
                                               int issueLineNumber) {
        statementByLineNumber = null;

        MethodDeclaration method = getMethodByLineNumber(javaClass, issueLineNumber);
        if (method != null) {
            method.getBody().ifPresent(blockStmt
                    -> blockStmt.getStatements().forEach(statement
                    -> statement.getTokenRange().ifPresent(tokenRange -> {
                if (tokenRange.getBegin().getRange().begin.line == issueLineNumber) {
                    statementByLineNumber = statement;
                }
            })));
        }

        return statementByLineNumber;
    }
}

Another approach could be to create new Checkstyle plugins based on the ones you are trying to create an automatic fix for. Perhaps you have enough information available to not only give a warning but to also generate a modified version with these issues fixed.

Personally I would hesitate to have issues fixed automatically upon commit. When there are many simple fixes to be made, automation is welcome, but I would like to check these changes before committing them. Running a tool like this and checking the changes could be a very fast way to fix a lot of simple issues.

Some checks that I think could be fixed automatically:

Upvotes: 1

Related Questions