Package com.puppycrawl.tools.checkstyle.checks.coding

Class FallThroughCheck

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

    Checks for fall-through in switch statements. Finds locations where a case contains Java code but lacks a break, return, yield, throw or continue statement.

    The check honors special comments to suppress the warning. By default, the texts "fallthru", "fall thru", "fall-thru", "fallthrough", "fall through", "fall-through" "fallsthrough", "falls through", "falls-through" (case-sensitive). The comment containing these words must be all on one line, and must be on the last non-empty line before the case triggering the warning or on the same line before the case(ugly, but possible).

    Note: The check assumes that there is no unreachable code in the case.

    • Property checkLastCaseGroup - Control whether the last case group must be checked. Type is boolean. Default value is false.
    • Property reliefPattern - Define the RegExp to match the relief comment that suppresses the warning about a fall through. Type is java.util.regex.Pattern. Default value is "falls?[ -]?thr(u|ough)".

    To configure the check: 

     <module name="FallThrough"/>

    Example: 

     public void foo() throws Exception {
   int i = 0;
   while (i >= 0) {
     switch (i) {
       case 1:
         i++;
       case 2: // violation, previous case contains code but lacks
               // break, return, yield, throw or continue statement
         i++;
         break;
       case 3: // OK
         i++;
         return;
       case 4: // OK
         i++;
         throw new Exception();
       case 5: // OK
         i++;
         continue;
       case 6: // OK
       case 7: // Previous case: OK, case does not contain code
               // This case: OK, by default the last case might not have statement
               // that transfer control
         i++;
     }
   }
 }
 public int bar() {
   int i = 0;
   return switch (i) {
     case 1:
       i++;
     case 2: // violation, previous case contains code but lacks
             // break, return, yield, throw or continue statement
     case 3: // OK, case does not contain code
       i++;
       yield 11;
     default: // OK
       yield -1;
   };
 }

    Example how to suppress violations by comment: 

     switch (i) {
   case 1:
     i++; // fall through

   case 2: // OK
     i++;
     // fallthru
   case 3: { // OK
     i++;
   }
   /* fall-thru */
   case 4: // OK
     i++;
     // Fallthru
   case 5: // violation, "Fallthru" in case 4 should be "fallthru"
     i++;
     // fall through
     i++;
   case 6: // violation, the comment must be on the last non-empty line before 'case'
     i++;
   /* fall through */case 7: // OK, comment can appear on the same line but before 'case'
     i++;
 }

    To configure the check to enable check for last case group: 

     <module name="FallThrough">
    <property name="checkLastCaseGroup" value="true"/>
 </module>

    Example: 

     switch (i) {
   case 1:
     break;
   case 2: // Previous case: OK
           // This case: violation, last case must have statement that transfer control
     i++;
 }

    To configure the check with custom relief pattern: 

     <module name="FallThrough">
    <property name="reliefPattern" value="FALL?[ -]?THROUGH"/>
 </module>

    Example: 

     switch (i) {
   case 1:
     i++;
     // FALL-THROUGH
   case 2: // OK, "FALL-THROUGH" matches the regular expression "FALL?[ -]?THROUGH"
     i++;
     // fall-through
   case 3: // violation, "fall-through" doesn't match
     break;
 }

    Parent is com.puppycrawl.tools.checkstyle.TreeWalker

    Violation Message Keys:

    • fall.through
    • fall.through.last
    Since:
    3.4

    • Field Detail

      • checkLastCaseGroup

        private boolean checkLastCaseGroup
        Control whether the last case group must be checked.

      • reliefPattern

        private java.util.regex.Pattern reliefPattern
        Define the RegExp to match the relief comment that suppresses the warning about a fall through.

    • 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

      • setReliefPattern

        public void setReliefPattern​(java.util.regex.Pattern pattern)
        Setter to define the RegExp to match the relief comment that suppresses the warning about a fall through.
        Parameters:
        pattern - The regular expression pattern.

      • setCheckLastCaseGroup

        public void setCheckLastCaseGroup​(boolean value)
        Setter to control whether the last case group must be checked.
        Parameters:
        value - new value of the property.

      • isTerminated

        private boolean isTerminated​(DetailAST ast,
                             boolean useBreak,
                             boolean useContinue)
        Checks if a given subtree terminated by return, throw or, if allowed break, continue.
        Parameters:
        ast - root of given subtree
        useBreak - should we consider break as terminator
        useContinue - should we consider continue as terminator
        Returns:
        true if the subtree is terminated.

      • checkSlist

        private boolean checkSlist​(DetailAST slistAst,
                           boolean useBreak,
                           boolean useContinue)
        Checks if a given SLIST terminated by return, throw or, if allowed break, continue.
        Parameters:
        slistAst - SLIST to check
        useBreak - should we consider break as terminator
        useContinue - should we consider continue as terminator
        Returns:
        true if SLIST is terminated.

      • checkIf

        private boolean checkIf​(DetailAST ast,
                        boolean useBreak,
                        boolean useContinue)
        Checks if a given IF terminated by return, throw or, if allowed break, continue.
        Parameters:
        ast - IF to check
        useBreak - should we consider break as terminator
        useContinue - should we consider continue as terminator
        Returns:
        true if IF is terminated.

      • checkLoop

        private boolean checkLoop​(DetailAST ast)
        Checks if a given loop terminated by return, throw or, if allowed break, continue.
        Parameters:
        ast - loop to check
        Returns:
        true if loop is terminated.

      • checkTry

        private boolean checkTry​(DetailAST ast,
                         boolean useBreak,
                         boolean useContinue)
        Checks if a given try/catch/finally block terminated by return, throw or, if allowed break, continue.
        Parameters:
        ast - loop to check
        useBreak - should we consider break as terminator
        useContinue - should we consider continue as terminator
        Returns:
        true if try/catch/finally block is terminated

      • checkSwitch

        private boolean checkSwitch​(DetailAST literalSwitchAst,
                            boolean useContinue)
        Checks if a given switch terminated by return, throw or, if allowed break, continue.
        Parameters:
        literalSwitchAst - loop to check
        useContinue - should we consider continue as terminator
        Returns:
        true if switch is terminated

      • checkSynchronized

        private boolean checkSynchronized​(DetailAST synchronizedAst,
                                  boolean useBreak,
                                  boolean useContinue)
        Checks if a given synchronized block terminated by return, throw or, if allowed break, continue.
        Parameters:
        synchronizedAst - synchronized block to check.
        useBreak - should we consider break as terminator
        useContinue - should we consider continue as terminator
        Returns:
        true if synchronized block is terminated

      • hasFallThroughComment

        private boolean hasFallThroughComment​(DetailAST currentCase,
                                      DetailAST nextCase)
        Determines if the fall through case between currentCase and nextCase is relieved by an appropriate comment.

        Handles

         case 1:
 /* FALLTHRU */ case 2:

 switch(i) {
 default:
 /* FALLTHRU */}

 case 1:
 // FALLTHRU
 case 2:

 switch(i) {
 default:
 // FALLTHRU
        Parameters:
        currentCase - AST of the case that falls through to the next case.
        nextCase - AST of the next case.
        Returns:
        True if a relief comment was found

      • matchesComment

        private boolean matchesComment​(java.util.regex.Pattern pattern,
                               int lineNo)
        Does a regular expression match on the given line and checks that a possible match is within a comment.
        Parameters:
        pattern - The regular expression pattern to use.
        lineNo - The line number in the file.
        Returns:
        True if a match was found inside a comment.