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)

    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.

    Parent is

    Violation Message Keys:

    • block.nested
    • 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
        the token set this check is designed for.
        See Also:
      • hasSiblings

        private static boolean hasSiblings​(DetailAST ast)
        Checks whether the AST node has any siblings or not.
        ast - node to examine
        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.
        allowInSwitchCase - whether nested blocks are allowed if they are the only child of a switch case.