Add regexp/no-empty-alternative rule (#95)

* Add `regexp/no-empty-alternative` rule

* update type

Author: ota-meshi

README.md

@@ -90,6 +90,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-assertion-capturing-group](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-assertion-capturing-group.html) | disallow capturing group that captures assertions. | :star: |
 | [regexp/no-dupe-characters-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-characters-character-class.html) | disallow duplicate characters in the RegExp character class | :star: |
 | [regexp/no-dupe-disjunctions](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-disjunctions.html) | disallow duplicate disjunctions |  |
+| [regexp/no-empty-alternative](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-alternative.html) | disallow alternatives without elements |  |
 | [regexp/no-empty-group](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-group.html) | disallow empty group | :star: |
 | [regexp/no-empty-lookarounds-assertion](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-lookarounds-assertion.html) | disallow empty lookahead assertion or empty lookbehind assertion | :star: |
 | [regexp/no-escape-backspace](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-escape-backspace.html) | disallow escape backspace (`[\b]`) | :star: |

docs/rules/README.md

@@ -18,6 +18,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-assertion-capturing-group](./no-assertion-capturing-group.md) | disallow capturing group that captures assertions. | :star: |
 | [regexp/no-dupe-characters-character-class](./no-dupe-characters-character-class.md) | disallow duplicate characters in the RegExp character class | :star: |
 | [regexp/no-dupe-disjunctions](./no-dupe-disjunctions.md) | disallow duplicate disjunctions |  |
+| [regexp/no-empty-alternative](./no-empty-alternative.md) | disallow alternatives without elements |  |
 | [regexp/no-empty-group](./no-empty-group.md) | disallow empty group | :star: |
 | [regexp/no-empty-lookarounds-assertion](./no-empty-lookarounds-assertion.md) | disallow empty lookahead assertion or empty lookbehind assertion | :star: |
 | [regexp/no-escape-backspace](./no-escape-backspace.md) | disallow escape backspace (`[\b]`) | :star: |

docs/rules/no-empty-alternative.md

@@ -0,0 +1,52 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-empty-alternative"
+description: "disallow alternatives without elements"
+---
+# regexp/no-empty-alternative
+
+> disallow alternatives without elements
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+
+## :book: Rule Details
+
+While (re-)writing long regular expressions, it can happen that one forgets to
+remove the `|` character of a former alternative. This rule tries to point out
+these potential mistakes by reporting all empty alternatives.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/no-empty-alternative: "error" */
+
+/* ✓ GOOD */
+var foo = /(?:)/
+var foo = /a+|b*/
+
+/* ✗ BAD */
+var foo = /a+|b+|/
+var foo = /\|\||\|||\|\|\|/
+var foo = /a(?:a|bc|def|h||ij|k)/
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :heart: Compatibility
+
+This rule was taken from [eslint-plugin-clean-regex].  
+This rule is compatible with [clean-regex/no-empty-alternative] rule.
+
+[eslint-plugin-clean-regex]: https://github.com/RunDevelopment/eslint-plugin-clean-regex
+[clean-regex/no-empty-alternative]: https://github.com/RunDevelopment/eslint-plugin-clean-regex/blob/master/docs/rules/no-empty-alternative.md
+
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-empty-alternative.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-empty-alternative.ts)

lib/rules/no-empty-alternative.ts

@@ -0,0 +1,64 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import type { CapturingGroup, Group, Pattern } from "regexpp/ast"
+import { createRule, defineRegexpVisitor, getRegexpLocation } from "../utils"
+
+export default createRule("no-empty-alternative", {
+    meta: {
+        docs: {
+            description: "disallow alternatives without elements",
+            // TODO Switch to recommended in the major version.
+            // recommended: true,
+            recommended: false,
+            default: "warn",
+        },
+        schema: [],
+        messages: {
+            empty: "No empty alternatives. Use quantifiers instead.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(node: Expression): RegExpVisitor.Handlers {
+            /**
+             * Verify alternatives
+             */
+            function verifyAlternatives(
+                regexpNode: CapturingGroup | Group | Pattern,
+            ) {
+                if (regexpNode.alternatives.length >= 2) {
+                    // We want to have at least two alternatives because the zero alternatives isn't possible because of
+                    // the parser and one alternative is already handled by other rules.
+                    for (let i = 0; i < regexpNode.alternatives.length; i++) {
+                        const alt = regexpNode.alternatives[i]
+                        if (alt.elements.length === 0) {
+                            context.report({
+                                node,
+                                loc: getRegexpLocation(sourceCode, node, alt),
+                                messageId: "empty",
+                            })
+                            // don't report the same node multiple times
+                            return
+                        }
+                    }
+                }
+            }
+
+            return {
+                onGroupEnter: verifyAlternatives,
+                onCapturingGroupEnter: verifyAlternatives,
+                onPatternEnter: verifyAlternatives,
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})

lib/utils/rules.ts

@@ -6,6 +6,7 @@ import negation from "../rules/negation"
 import noAssertionCapturingGroup from "../rules/no-assertion-capturing-group"
 import noDupeCharactersCharacterClass from "../rules/no-dupe-characters-character-class"
 import noDupeDisjunctions from "../rules/no-dupe-disjunctions"
+import noEmptyAlternative from "../rules/no-empty-alternative"
 import noEmptyGroup from "../rules/no-empty-group"
 import noEmptyLookaroundsAssertion from "../rules/no-empty-lookarounds-assertion"
 import noEscapeBackspace from "../rules/no-escape-backspace"
@@ -45,6 +46,7 @@ export const rules = [
     noAssertionCapturingGroup,
     noDupeCharactersCharacterClass,
     noDupeDisjunctions,
+    noEmptyAlternative,
     noEmptyGroup,
     noEmptyLookaroundsAssertion,
     noEscapeBackspace,

tests/lib/rules/no-empty-alternative.ts

@@ -0,0 +1,45 @@
+import { RuleTester } from "eslint"
+import rule from "../../../lib/rules/no-empty-alternative"
+
+const tester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+})
+
+tester.run("no-empty-alternative", rule as any, {
+    valid: [`/()|(?:)|(?=)/`, `/(?:)/`, `/a*|b+/`],
+    invalid: [
+        {
+            code: `/|||||/`,
+            errors: [
+                {
+                    message: "No empty alternatives. Use quantifiers instead.",
+                    line: 1,
+                    column: 2,
+                },
+            ],
+        },
+        {
+            code: `/(a+|b+|)/`,
+            errors: [
+                {
+                    message: "No empty alternatives. Use quantifiers instead.",
+                    line: 1,
+                    column: 9,
+                },
+            ],
+        },
+        {
+            code: String.raw`/(?:\|\|||\|)/`,
+            errors: [
+                {
+                    message: "No empty alternatives. Use quantifiers instead.",
+                    line: 1,
+                    column: 10,
+                },
+            ],
+        },
+    ],
+})