feat: add allowEmptyCase option to no-fallthrough rule

docs/src/rules/no-fallthrough.md

@@ -169,9 +169,11 @@ Note that the last `case` statement in these examples does not cause a warning b
 
 ## Options
 
-This rule accepts a single options argument:
+This rule has an object option:
 
-* Set the `commentPattern` option to a regular expression string to change the test for intentional fallthrough comment
+* Set the `commentPattern` option to a regular expression string to change the test for intentional fallthrough comment.
+
+* Set the `allowEmptyCase` option to `true` to allow empty cases regardless of the layout.By default, this rule does not require a fallthrough comment after an empty `case` only if the empty `case` and the next `case` are on the same line or on consecutive lines.
 
 ### commentPattern
 
@@ -201,6 +203,29 @@ switch(foo) {
 }
 ```
 
+### allowEmptyCase
+
+Examples for **correct** code for the `{ "allowEmptyCase": true }` option:
+
+```js
+/* eslint no-fallthrough: ["error", { "allowEmptyCase": true }] */
+
+switch(foo){
+    case 1:
+
+    case 2: doSomething();
+}
+
+switch(foo){
+    case 1:
+    /*
+    Put a message here 
+    */
+    case 2: doSomething();
+}
+
+```
+
 :::
 
 ## When Not To Use It

lib/rules/no-fallthrough.js

@@ -35,6 +35,19 @@ function hasFallthroughComment(caseWhichFallsThrough, subsequentCase, context, f
     return Boolean(comment && fallthroughCommentPattern.test(comment.value));
 }
 
+/**
+ * Checks whether or not a given case is empty.
+ * @param {ASTNode} caseWhichFallsThrough SwitchCase node which falls through.
+ * @returns {boolean} `true` if the case is empty.
+ */
+function isEmptyCase(caseWhichFallsThrough) {
+
+    if (caseWhichFallsThrough.consequent.length === 0) {
+        return true;
+    }
+    return false;
+}
+
 /**
  * Checks whether or not a given code path segment is reachable.
  * @param {CodePathSegment} segment A CodePathSegment to check.
@@ -76,6 +89,10 @@ module.exports = {
                     commentPattern: {
                         type: "string",
                         default: ""
+                    },
+                    allowEmptyCase: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -91,6 +108,7 @@ module.exports = {
         const options = context.options[0] || {};
         let currentCodePath = null;
         const sourceCode = context.getSourceCode();
+        const allowEmptyCase = options.allowEmptyCase || false;
 
         /*
          * We need to use leading comments of the next SwitchCase node because
@@ -104,7 +122,6 @@ module.exports = {
         } else {
             fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
         }
-
         return {
             onCodePathStart(codePath) {
                 currentCodePath = codePath;
@@ -118,12 +135,17 @@ module.exports = {
                 /*
                  * Checks whether or not there is a fallthrough comment.
                  * And reports the previous fallthrough node if that does not exist.
+                 *
+                 *
                  */
-                if (fallthroughCase && !hasFallthroughComment(fallthroughCase, node, context, fallthroughCommentPattern)) {
-                    context.report({
-                        messageId: node.test ? "case" : "default",
-                        node
-                    });
+
+                if (fallthroughCase && (!hasFallthroughComment(fallthroughCase, node, context, fallthroughCommentPattern))) {
+                    if (!(allowEmptyCase && isEmptyCase(fallthroughCase))) {
+                        context.report({
+                            messageId: node.test ? "case" : "default",
+                            node
+                        });
+                    }
                 }
                 fallthroughCase = null;
             },
@@ -137,7 +159,7 @@ module.exports = {
                  * And allows empty cases and the last case.
                  */
                 if (currentCodePath.currentSegments.some(isReachable) &&
-                    (node.consequent.length > 0 || hasBlankLinesBetween(node, nextToken)) &&
+                    (node.consequent.length > 0 || (!allowEmptyCase && hasBlankLinesBetween(node, nextToken))) &&
                     node.parent.cases[node.parent.cases.length - 1] !== node) {
                     fallthroughCase = node;
                 }

tests/lib/rules/no-fallthrough.js

@@ -92,6 +92,22 @@ ruleTester.run("no-fallthrough", rule, {
             options: [{
                 commentPattern: "break[\\s\\w]+omitted"
             }]
+        },
+        {
+            code: "switch(foo) { case 0: \n\n\n case 1: b(); }",
+            options: [{ allowEmptyCase: true }]
+        },
+        {
+            code: "switch(foo) { case 0: \n /* with comments */  \n case 1: b(); }",
+            options: [{ allowEmptyCase: true }]
+        },
+        {
+            code: "switch (a) {\n case 1: ; break; \n case 3: }",
+            options: [{ allowEmptyCase: true }]
+        },
+        {
+            code: "switch (a) {\n case 1: ; break; \n case 3: }",
+            options: [{ allowEmptyCase: false }]
         }
     ],
     invalid: [
@@ -214,6 +230,73 @@ ruleTester.run("no-fallthrough", rule, {
                     column: 1
                 }
             ]
+        },
+        {
+            code: "switch(foo) { case 0: \n /* with comments */  \ncase 1: b(); }",
+            errors: [
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 3,
+                    column: 1
+                }
+            ]
+        },
+        {
+            code: "switch(foo) { case 0:\n\ncase 1: b(); }",
+            options: [{
+                allowEmptyCase: false
+            }],
+            errors: [
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 3,
+                    column: 1
+                }
+            ]
+        },
+        {
+            code: "switch(foo) { case 0:\n\ncase 1: b(); }",
+            options: [{}],
+            errors: [
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 3,
+                    column: 1
+                }
+            ]
+        },
+        {
+            code: "switch (a) { case 1: \n ; case 2:  }",
+            options: [{ allowEmptyCase: false }],
+            errors: [
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 2,
+                    column: 4
+                }
+            ]
+        },
+        {
+            code: "switch (a) { case 1: ; case 2: ; case 3: }",
+            options: [{ allowEmptyCase: true }],
+            errors: [
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 1,
+                    column: 24
+                },
+                {
+                    messageId: "case",
+                    type: "SwitchCase",
+                    line: 1,
+                    column: 34
+                }
+            ]
         }
     ]
 });