Checkstyle rule for "@annotations must be on separate line"

Question

I am trying to create a rule for checkstyle, that will prevent writing inline annotations usage, like this: ``` @Entity MyClass someEntity; @Foo(a="B") public void bar(Baz baz) { } ``` but will not prevent thinks like that: ``` public void bar(@Param Baz baz) { } ``` Is there any way to achieve that?

Accepted Answer

Most of this answer was inspired by Checkstyle's "Writing Checks" article. Most of the work is done in `AnnotationSameLineCheck`.

AnnotationSameLineCheck.java

This Java file was inspired by the "Visitor In Action" section of the "Writing Checks" article.

`getDefaultTokens` defines which parts (a.k.a. tokens) of a Java file we're interested in. Out first one might think that we'd be interested in `TokenTypes.ANNOTATION`, but this is not the case. We're not interested in `TokenTypes.ANNOTATION` because we don't want to inspect all annotations; we actually want to disregard `TokenTypes.PARAMETER_DEF`.

What are we interested in then? We're actually interested in those parts of a Java file that can be annotated (i.e., the class definition `TokenTypes.CLASS_DEF`, method definitions `TokenTypes.METHOD_DEF`, etc.). Conveniently, Checkstyle's API has a method that can tell us if a token is annotated. That method is`AnnotationUtility.containsAnnotation`, which is used in `visitToken`.

The algorithm used to determine if an annotation is on the same line as other parts of a Java file is as follows:

- Determine if a particular token contains an annotation. If not, do nothing.

- Find the annotation token.

- Find the token before the annotation token.

- Find the token after the annotation token.

- If the annotation token is on the same line as the previous token, log an error.

- If the annotation token is on the same line as the next token, log an error.

This algorithm is found in `visitToken`.

```
package example;

import com.puppycrawl.tools.checkstyle.api.AnnotationUtility;
import com.puppycrawl.tools.checkstyle.api.Check;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;

public class AnnotationSameLineCheck extends Check {
    @Override
    public int[] getDefaultTokens() {
        // PACKAGE_DEF and PARAMETER_DEF were left out of the list
        return new int[] { TokenTypes.ANNOTATION_DEF, //
                TokenTypes.ANNOTATION_FIELD_DEF, //
                TokenTypes.CLASS_DEF, //
                TokenTypes.CTOR_DEF, //
                TokenTypes.ENUM_DEF, //
                TokenTypes.ENUM_CONSTANT_DEF, //
                TokenTypes.INTERFACE_DEF, //
                TokenTypes.METHOD_DEF, //
                TokenTypes.VARIABLE_DEF };
    }

@Override
    public void visitToken(DetailAST ast) {
        if (AnnotationUtility.containsAnnotation(ast)) {
            final DetailAST holder = AnnotationUtility.getAnnotationHolder(ast);
            final DetailAST annotation = getAnnotationAst(holder);
            final DetailAST prev = getPreviousSibling(annotation, holder, ast);
            final DetailAST next = getNextSibling(annotation, holder, ast);
            if (isPreviousSiblingOnSameLine(prev, annotation) || //
                    isNextSiblingOnSameLine(annotation, next)) {
                log(annotation.getLineNo(), //
                        annotation.getColumnNo(), //
                        "Annotations must exist on their own line");
            }
        }
    }

private static boolean isPreviousSiblingOnSameLine(DetailAST prev, DetailAST annotation) {
        if (prev == null) {
            return false;
        } else if (prev.getLastChild() == null) {
            return prev.getLineNo() == annotation.getLineNo();
        }
        return prev.getLastChild().getLineNo() == annotation.getLineNo();
    }

private static boolean isNextSiblingOnSameLine(DetailAST annotation, DetailAST next) {
        if (next == null) {
            return false;
        }
        return annotation.getLineNo() == next.getLineNo();
    }

private static DetailAST getAnnotationAst(DetailAST aHolderAst) {
        if (aHolderAst.getType() == TokenTypes.ANNOTATIONS) {
            return aHolderAst;
        } else if (aHolderAst.getType() == TokenTypes.MODIFIERS) {
            return aHolderAst.findFirstToken(TokenTypes.ANNOTATION);
        }
        throw new AssertionError("aHolder must be one of TokenTypes.ANNOTATIONS or TokenTypes.MODIFIERS but was " + aHolderAst);
    }

private static DetailAST getPreviousSibling(DetailAST annotation, DetailAST holder, DetailAST ast) {
        if (annotation.getPreviousSibling() != null) {
            return annotation.getPreviousSibling();
        } else if (holder.getPreviousSibling() != null) {
            return holder.getPreviousSibling();
        }
        return ast.getPreviousSibling();
    }

private static DetailAST getNextSibling(DetailAST annotation, DetailAST holder, DetailAST ast) {
        if (annotation.getNextSibling() != null) {
            return annotation.getNextSibling();
        } else if (holder.getNextSibling() != null) {
            return holder.getNextSibling();
        }
        return ast.getNextSibling();
    }
}
```

checks.xml

This XML file was inspired by the "Integrate Your Check" section of the "Writing Checks" article. It is used by Checkstyle to specif…

Checkstyle rule for "@annotations must be on separate line"

Solution

Problem