Package com.puppycrawl.tools.checkstyle.checks.whitespace

Class WhitespaceAroundCheck

  • All Implemented Interfaces:
    Configurable, Contextualizable
    public class WhitespaceAroundCheck
extends AbstractCheck

    Checks that a token is surrounded by whitespace. Empty constructor, method, class, enum, interface, loop bodies (blocks), lambdas of the form 

     public MyClass() {}      // empty constructor
 public void func() {}    // empty method
 public interface Foo {} // empty interface
 public class Foo {} // empty class
 public enum Foo {} // empty enum
 MyClass c = new MyClass() {}; // empty anonymous class
 while (i = 1) {} // empty while loop
 for (int i = 1; i > 1; i++) {} // empty for loop
 do {} while (i = 1); // empty do-while loop
 Runnable noop = () -> {}; // empty lambda
 public @interface Beta {} // empty annotation type

    may optionally be exempted from the policy using the allowEmptyMethods, allowEmptyConstructors, allowEmptyTypes, allowEmptyLoops, allowEmptyLambdas and allowEmptyCatches properties.

    This check does not flag as violation double brace initialization like: 

     new Properties() {{
     setProperty("key", "value");
 }};

    Parameter allowEmptyCatches allows to suppress violations when token list contains SLIST to check if beginning of block is surrounded by whitespace and catch block is empty, for example: 

     try {
     k = 5 / i;
 } catch (ArithmeticException ex) {}

    With this property turned off, this raises violation because the beginning of the catch block (left curly bracket) is not separated from the end of the catch block (right curly bracket).

    To configure the check: 

     <module name="WhitespaceAround"/>

    Example: 

     class Test {
     public Test(){} // 2 violations, '{' is not followed and preceded by whitespace.
     public static void main(String[] args) {
         if (foo) { // ok
             // body
         }
         else{ // violation
             // body
         }

         for (int i = 1; i > 1; i++) {} // violation, '{' is not followed by whitespace.

         Runnable noop = () ->{}; // 2 violations,
                                     // '{' is not followed and preceded by whitespace.
         try {
             // body
         } catch (Exception e){} // 2 violations,
                                 // '{' is not followed and preceded by whitespace.

         char[] vowels = {'a', 'e', 'i', 'o', 'u'};
         for (char item: vowels) { // ok, because ignoreEnhancedForColon is true by default
             // body
         }
     }
 }

    To configure the check for whitespace only around assignment operators: 

     <module name="WhitespaceAround">
   <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"/>
 </module>

    Example: 

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

    To configure the check for whitespace only around curly braces: 

     <module name="WhitespaceAround">
   <property name="tokens" value="LCURLY,RCURLY"/>
 </module>

    Example: 

     class Test {
     public void myFunction() {} // violation
     public void myFunction() { } // ok
 }

    To configure the check to allow empty method bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyMethods" value="true"/>
 </module>

    Example: 

     class Test {
     public void muFunction() {} // ok
     int a=4; // 2 violations, '=' is not followed and preceded by whitespace.
 }

    To configure the check to allow empty constructor bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyConstructors" value="true"/>
 </module>

    Example: 

     class Test {
     public Test(){} // ok
     public void muFunction() {} // violation, '{' is not followed by whitespace.
 }

    To configure the check to allow empty type bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyTypes" value="true"/>
 </module>

    Example: 

     class Test {} // ok
 interface testInterface{} // ok
 class anotherTest {
     int a=4; // 2 violations, '=' is not followed and preceded by whitespace.
 }

    To configure the check to allow empty loop bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyLoops" value="true"/>
 </module>

    Example: 

     class Test {
     public static void main(String[] args) {
         for (int i = 100;i > 10; i--){} // ok
         do {} while (i = 1); // ok
         int a=4; // 2 violations, '=' is not followed and preceded by whitespace.
     }
 }

    To configure the check to allow empty lambda bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyLambdas" value="true"/>
 </module>

    Example: 

     class Test {
     public static void main(String[] args) {
         Runnable noop = () -> {}; // ok
         int a=4; // 2 violations, '=' is not followed and preceded by whitespace.
     }
 }

    To configure the check to allow empty catch bodies: 

     <module name="WhitespaceAround">
   <property name="allowEmptyCatches" value="true"/>
 </module>

    Example: 

     class Test {
     public static void main(String[] args) {
         int a=4; // 2 violations, '=' is not followed and preceded by whitespace.
         try {
             // body
         } catch (Exception e){} // ok
     }
 }

    Also, this check can be configured to ignore the colon in an enhanced for loop. The colon in an enhanced for loop is ignored by default.

    To configure the check to ignore the colon: 

     <module name="WhitespaceAround">
   <property name="ignoreEnhancedForColon" value="false" />
 </module>

    Example: 

     class Test {
     public static void main(String[] args) {
         int a=4; // 2 violations , '=' is not followed and preceded by whitespace.
         char[] vowels = {'a', 'e', 'i', 'o', 'u'};
         for (char item: vowels) { // violation, ':' is not preceded by whitespace.
             // body
         }
     }
 }

    Parent is com.puppycrawl.tools.checkstyle.TreeWalker

    Violation Message Keys:

    • ws.notFollowed
    • ws.notPreceded
    Since:
    3.0

    • Field Detail

      • MSG_WS_NOT_PRECEDED

        public static final java.lang.String MSG_WS_NOT_PRECEDED
        A key is pointing to the warning message text in "messages.properties" file.
        See Also:
        Constant Field Values

      • MSG_WS_NOT_FOLLOWED

        public static final java.lang.String MSG_WS_NOT_FOLLOWED
        A key is pointing to the warning message text in "messages.properties" file.
        See Also:
        Constant Field Values

    • Constructor Detail

      • WhitespaceAroundCheck

        public WhitespaceAroundCheck()

    • Method Detail

      • getDefaultTokens

        public int[] getDefaultTokens()
        Description copied from class: AbstractCheck
        Returns the default token a check is interested in. Only used if the configuration for a check does not define the tokens.
        Specified by:
        getDefaultTokens in class AbstractCheck
        Returns:
        the default tokens
        See Also:
        TokenTypes

      • 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

      • getRequiredTokens

        public int[] getRequiredTokens()
        Description copied from class: AbstractCheck
        The tokens that this check must be registered for.
        Specified by:
        getRequiredTokens in class AbstractCheck
        Returns:
        the token set this must be registered for.
        See Also:
        TokenTypes

      • setAllowEmptyMethods

        public void setAllowEmptyMethods​(boolean allow)
        Setter to allow empty method bodies.
        Parameters:
        allow - true to allow empty method bodies.

      • setAllowEmptyConstructors

        public void setAllowEmptyConstructors​(boolean allow)
        Setter to allow empty constructor bodies.
        Parameters:
        allow - true to allow empty constructor bodies.

      • setIgnoreEnhancedForColon

        public void setIgnoreEnhancedForColon​(boolean ignore)
        Setter to ignore whitespace around colon in enhanced for loop.
        Parameters:
        ignore - true to ignore enhanced for colon.

      • setAllowEmptyTypes

        public void setAllowEmptyTypes​(boolean allow)
        Setter to allow empty class, interface and enum bodies.
        Parameters:
        allow - true to allow empty type bodies.

      • setAllowEmptyLoops

        public void setAllowEmptyLoops​(boolean allow)
        Setter to allow empty loop bodies.
        Parameters:
        allow - true to allow empty loops bodies.

      • setAllowEmptyLambdas

        public void setAllowEmptyLambdas​(boolean allow)
        Setter to allow empty lambda bodies.
        Parameters:
        allow - true to allow empty lambda expressions.

      • setAllowEmptyCatches

        public void setAllowEmptyCatches​(boolean allow)
        Setter to allow empty catch bodies.
        Parameters:
        allow - true to allow empty catch blocks.