Class OperatorWrapCheck

  • All Implemented Interfaces:
    Configurable, Contextualizable

    public class OperatorWrapCheck
    extends AbstractCheck

    Checks the policy on how to wrap lines on operators.

    To configure the check:

     <module name="OperatorWrap"/>
     

    Example:

     class Test {
         public static void main(String[] args) {
             String s = "Hello" +
             "World"; // violation, '+' should be on new line
    
             if (10 ==
                     20) { // violation, '==' should be on new line.
             // body
             }
             if (10
                     ==
                     20) { // ok
             // body
             }
    
             int c = 10 /
                     5; // violation, '/' should be on new line.
    
             int d = c
                     + 10; // ok
         }
    
     }
     

    To configure the check for assignment operators at the end of a line:

     <module name="OperatorWrap">
       <property name="tokens"
         value="ASSIGN,DIV_ASSIGN,PLUS_ASSIGN,MINUS_ASSIGN,STAR_ASSIGN,MOD_ASSIGN,
                SR_ASSIGN,BSR_ASSIGN,SL_ASSIGN,BXOR_ASSIGN,BOR_ASSIGN,BAND_ASSIGN"/>
       <property name="option" value="eol"/>
     </module>
     

    Example:

     class Test {
         public static void main(String[] args) {
                 int b
                         = 10; // violation, '=' should be on previous line
                 int c =
                         10; // ok
                 b
                         += 10; // violation, '+=' should be on previous line
                 b +=
                         10; // ok
                 c
                         *= 10; // violation, '*=' should be on previous line
                 c *=
                         10; // ok
                 c
                         -= 5; // violation, '-=' should be on previous line
                 c -=
                         5; // ok
                 c
                         /= 2; // violation, '/=' should be on previous line
                 c
                         %= 1; // violation, '%=' should be on previous line
                 c
                         >>= 1; // violation, '>>=' should be on previous line
                 c
                     >>>= 1; // violation, '>>>=' should be on previous line
             }
             public void myFunction() {
                 c
                         ^= 1; // violation, '^=' should be on previous line
                 c
                         |= 1; // violation, '|=' should be on previous line
                 c
                         &=1 ; // violation, '&=' should be on previous line
                 c
                         <<= 1; // violation, '<<=' should be on previous line
         }
     }
     

    Parent is com.puppycrawl.tools.checkstyle.TreeWalker

    Violation Message Keys:

    • line.new
    • line.previous
    Since:
    3.0
    • Method Detail

      • setOption

        public void setOption​(String optionStr)
        Setter to specify policy on how to wrap lines.
        Parameters:
        optionStr - string to decode option from
        Throws:
        IllegalArgumentException - if unable to decode
      • 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
      • isTargetNode

        private static boolean isTargetNode​(DetailAST node)
        Filters some false tokens that this check should ignore.
        Parameters:
        node - the node to check
        Returns:
        true for all nodes this check should validate
      • isNewLineModeViolation

        private static boolean isNewLineModeViolation​(DetailAST ast)
        Checks whether operator violates WrapOption.NL mode.
        Parameters:
        ast - the DetailAst of an operator
        Returns:
        true if mode does not match
      • isColonFromLabel

        private static boolean isColonFromLabel​(DetailAST node)
        Checks if a node is TokenTypes.COLON from a label, switch case of default.
        Parameters:
        node - the node to check
        Returns:
        true if node matches
      • getLeftNode

        private static DetailAST getLeftNode​(DetailAST node)
        Returns the left neighbour of a binary operator. This is the rightmost grandchild of the left child or sibling. For the assign operator the return value is the variable name.
        Parameters:
        node - the binary operator
        Returns:
        nearest node from left
      • isInPatternDefinition

        private static boolean isInPatternDefinition​(DetailAST node)
        Ascends AST to determine if given node is part of a pattern definition.
        Parameters:
        node - the node to check
        Returns:
        true if node is in pattern definition
      • getRightNode

        private static DetailAST getRightNode​(DetailAST node)
        Returns the right neighbour of a binary operator. This is the leftmost grandchild of the right child or sibling. For the ternary operator this is the node between ? and : .
        Parameters:
        node - the binary operator
        Returns:
        nearest node from right