Class NoWhitespaceAfterCheck

  • All Implemented Interfaces:
    Configurable, Contextualizable

    public class NoWhitespaceAfterCheck
    extends AbstractCheck

    Checks that there is no whitespace after a token. More specifically, it checks that it is not followed by whitespace, or (if linebreaks are allowed) all characters on the line after are whitespace. To forbid linebreaks after a token, set property allowLineBreaks to false.

    The check processes ARRAY_DECLARATOR and INDEX_OP tokens specially from other tokens. Actually it is checked that there is no whitespace before these tokens, not after them. Space after the ANNOTATIONS before ARRAY_DECLARATOR and INDEX_OP will be ignored.

    If the annotation is between the type and the array, the check will skip validation for spaces

     public void foo(final char @NotNull [] param) {} // No violation
     

    To configure the check:

     <module name="NoWhitespaceAfter"/>
     

    Example:

     class Test {
    
       public void lineBreak(String x) {
         Integer.
             parseInt(x); // Ok
         Integer.parseInt(x); // Ok
       }
    
       public void dotOperator(String s) {
         Integer.parseInt(s); // Ok
         Integer. parseInt(s); // violation, '.' is followed by whitespace
       }
    
       public void arrayDec() {
         int[] arr = arr; // Ok
         int [] arr = arr; // violation, int is followed by whitespace
       }
    
       public void bitwiseNot(int a) {
         a = ~ a; // violation '~' is followed by whitespace
         a = ~a; // Ok
       }
     }
     

    To configure the check to forbid linebreaks after a DOT token:

     <module name="NoWhitespaceAfter">
       <property name="tokens" value="DOT"/>
       <property name="allowLineBreaks" value="false"/>
     </module>
     

    Example:

     class Test {
    
       public void lineBreak(String x) {
         Integer.
             parseInt(x); // violation, '.' is followed by whitespace
         Integer.parseInt(x); // Ok
       }
    
       public void dotOperator(String s) {
         Integer.parseInt(s); // Ok
         Integer. parseInt(s); // violation, '.' is followed by whitespace
       }
    
       public void arrayDec() {
         int[] arr = arr; // Ok
         int [] arr = arr; // Ok
       }
    
       public void bitwiseNot(int a) {
         a = ~ a; // Ok
         a = ~a; // Ok
       }
     }
     

    Parent is com.puppycrawl.tools.checkstyle.TreeWalker

    Violation Message Keys:

    • ws.followed
    Since:
    3.0
    • Field Detail

      • allowLineBreaks

        private boolean allowLineBreaks
        Control whether whitespace is allowed if the token is at a linebreak.
    • Method Detail

      • getAcceptableTokens

        public int[] getAcceptableTokens()
        Description copied from class: AbstractCheck
        The configurable token set. Used to protect Checks against malicious users who specify an unacceptable token set in the configuration file. The default implementation returns the check's default tokens.
        Specified by:
        getAcceptableTokens in class AbstractCheck
        Returns:
        the token set this check is designed for.
        See Also:
        TokenTypes
      • setAllowLineBreaks

        public void setAllowLineBreaks​(boolean allowLineBreaks)
        Setter to control whether whitespace is allowed if the token is at a linebreak.
        Parameters:
        allowLineBreaks - whether whitespace should be flagged at linebreaks.
      • getWhitespaceFollowedNode

        private static DetailAST getWhitespaceFollowedNode​(DetailAST ast)
        For a visited ast node returns node that should be checked for not being followed by whitespace.
        Parameters:
        ast - , visited node.
        Returns:
        node before ast.
      • shouldCheckWhitespaceAfter

        private static boolean shouldCheckWhitespaceAfter​(DetailAST ast)
        Returns whether whitespace after a visited node should be checked. For example, whitespace is not allowed between a type and an array declarator (returns true), except when there is an annotation in between the type and array declarator (returns false).
        Parameters:
        ast - the visited node
        Returns:
        true if whitespace after ast should be checked
      • getPositionAfter

        private static int getPositionAfter​(DetailAST ast)
        Gets position after token (place of possible redundant whitespace).
        Parameters:
        ast - Node representing token.
        Returns:
        position after token.
      • hasTrailingWhitespace

        private boolean hasTrailingWhitespace​(DetailAST ast,
                                              int whitespaceColumnNo,
                                              int whitespaceLineNo)
        Checks if there is unwanted whitespace after the visited node.
        Parameters:
        ast - , visited node.
        whitespaceColumnNo - , column number of a possible whitespace.
        whitespaceLineNo - , line number of a possible whitespace.
        Returns:
        true if whitespace found.
      • getPreviousElementOfMultiDimArray

        private static DetailAST getPreviousElementOfMultiDimArray​(DetailAST leftBracket)
        Gets the previous element of a second or higher dimension of an array declaration or initialization.
        Parameters:
        leftBracket - the token to get previous element of
        Returns:
        the previous element
      • getIndexOpPreviousElement

        private static DetailAST getIndexOpPreviousElement​(DetailAST ast)
        Gets previous node for INDEX_OP token for usage in getPositionAfter method, it is a simplified copy of getArrayDeclaratorPreviousElement method.
        Parameters:
        ast - , INDEX_OP node.
        Returns:
        previous node by text order.
      • getTypeLastNode

        private static DetailAST getTypeLastNode​(DetailAST ast)
        Searches parameter node for a type node. Returns it or its last node if it has an extended structure.
        Parameters:
        ast - , subject node.
        Returns:
        type node.
      • getPreviousNodeWithParentOfTypeAst

        private static DetailAST getPreviousNodeWithParentOfTypeAst​(DetailAST ast,
                                                                    DetailAST parent)
        Finds previous node by text order for an array declarator, which parent type is TYPE.
        Parameters:
        ast - , array declarator node.
        parent - , its parent node.
        Returns:
        previous node by text order.
      • getIdentLastToken

        private static DetailAST getIdentLastToken​(DetailAST ast)
        Gets leftmost token of identifier.
        Parameters:
        ast - , token possibly possessing an identifier.
        Returns:
        leftmost token of identifier.
      • getPrecedingDot

        private static DetailAST getPrecedingDot​(DetailAST leftBracket)
        Gets the dot preceding a class member array index operation or class reference.
        Parameters:
        leftBracket - the ast we are checking
        Returns:
        dot preceding the left bracket