Class AvoidNestedBlocksCheck

  • All Implemented Interfaces:
    Configurable, Contextualizable

    public class AvoidNestedBlocksCheck
    extends AbstractCheck

    Finds nested blocks (blocks that are used freely in the code).

    Rationale: Nested blocks are often leftovers from the debugging process, they confuse the reader.

    For example, this check finds the obsolete braces in

     public void guessTheOutput()
     {
       int whichIsWhich = 0;
       {
         whichIsWhich = 2;
       }
       System.out.println("value = " + whichIsWhich);
     }
     

    and debugging / refactoring leftovers such as

     // if (conditionThatIsNotUsedAnyLonger)
     {
       System.out.println("unconditional");
     }
     

    A case in a switch statement does not implicitly form a block. Thus to be able to introduce local variables that have case scope it is necessary to open a nested block. This is supported, set the allowInSwitchCase property to true and include all statements of the case in the block.

    • Property allowInSwitchCase - Allow nested blocks if they are the only child of a switch case. Type is boolean. Default value is false.

    To configure the check:

     <module name="AvoidNestedBlocks"/>
     

    Example:

     public void foo() {
       int myInteger = 0;
       {                      // violation
         myInteger = 2;
       }
       System.out.println("myInteger = " + myInteger);
    
       switch (a) {
         case 1:
           {                    // violation
             System.out.println("Case 1");
             break;
           }
         case 2:
           System.out.println("Case 2");     // OK
           break;
       }
     }
     

    To configure the check to allow nested blocks in switch case:

     <module name="AvoidNestedBlocks">
       <property name="allowInSwitchCase" value="true"/>
     </module>
     

    Example:

     public void foo() {
       int myInteger = 0;
       {                      // violation
         myInteger = 2;
       }
       System.out.println("myInteger = " + myInteger);
    
       switch (a)
       {
         case 1:
           {                    // OK
             System.out.println("Case 1");
             break;
           }
         case 2:
           System.out.println("Case 2");     // OK
           break;
       }
     }
     

    Parent is com.puppycrawl.tools.checkstyle.TreeWalker

    Violation Message Keys:

    • block.nested
    Since:
    3.1
    • 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
      • hasSiblings

        private static boolean hasSiblings​(DetailAST ast)
        Checks whether the AST node has any siblings or not.
        Parameters:
        ast - node to examine
        Returns:
        true if the node has one or more siblings
      • setAllowInSwitchCase

        public void setAllowInSwitchCase​(boolean allowInSwitchCase)
        Setter to allow nested blocks if they are the only child of a switch case.
        Parameters:
        allowInSwitchCase - whether nested blocks are allowed if they are the only child of a switch case.