Add no-zero-quantifier rule (#200)

RunDevelopment · web-flow · commit 1ae6e2b18a38 · 2021-05-08T07:34:09.000+09:00
* Add `no-zero-quantifier` rule

* Fixed code example

* Shorter message
diff --git a/README.md b/README.md
@@ -135,6 +135,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-quantifier.html) | disallow quantifiers that can be removed | :wrench: |
 | [regexp/no-useless-range](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-range.html) | disallow unnecessary range of characters by using a hyphen | :wrench: |
 | [regexp/no-useless-two-nums-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html) | disallow unnecessary `{n,m}` quantifier | :star::wrench: |
+| [regexp/no-zero-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-zero-quantifier.html) | disallow quantifiers with a maximum of zero |  |
 | [regexp/optimal-lookaround-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-lookaround-quantifier.html) | disallow the alternatives of lookarounds that end with a non-constant quantifier |  |
 | [regexp/order-in-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/order-in-character-class.html) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-character-class.html) | enforce using character class | :wrench: |
diff --git a/docs/rules/README.md b/docs/rules/README.md
@@ -49,6 +49,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-quantifier](./no-useless-quantifier.md) | disallow quantifiers that can be removed | :wrench: |
 | [regexp/no-useless-range](./no-useless-range.md) | disallow unnecessary range of characters by using a hyphen | :wrench: |
 | [regexp/no-useless-two-nums-quantifier](./no-useless-two-nums-quantifier.md) | disallow unnecessary `{n,m}` quantifier | :star::wrench: |
+| [regexp/no-zero-quantifier](./no-zero-quantifier.md) | disallow quantifiers with a maximum of zero |  |
 | [regexp/optimal-lookaround-quantifier](./optimal-lookaround-quantifier.md) | disallow the alternatives of lookarounds that end with a non-constant quantifier |  |
 | [regexp/order-in-character-class](./order-in-character-class.md) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](./prefer-character-class.md) | enforce using character class | :wrench: |
diff --git a/docs/rules/no-zero-quantifier.md b/docs/rules/no-zero-quantifier.md
@@ -0,0 +1,42 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-zero-quantifier"
+description: "disallow quantifiers with a maximum of zero"
+---
+# regexp/no-zero-quantifier
+
+> disallow quantifiers with a maximum of zero
+
+- :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
+
+This rule reports quantifiers with a maximum of zero. These quantifiers trivially do not affect the pattern is any way and can be removed.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/no-zero-quantifier: "error" */
+
+/* ✓ GOOD */
+var foo = /a?/;
+var foo = /a{0,}/;
+var foo = /a{0,1}/;
+
+/* ✗ BAD */
+var foo = /a{0}/;
+var foo = /a{0,0}?/;
+var foo = /(a){0}/;
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-zero-quantifier.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-zero-quantifier.ts)
diff --git a/lib/rules/no-zero-quantifier.ts b/lib/rules/no-zero-quantifier.ts
@@ -0,0 +1,85 @@
+import type { Rule } from "eslint"
+import { hasSomeDescendant } from "regexp-ast-analysis"
+import type { RegExpVisitor } from "regexpp/visitor"
+import type { RegExpContext } from "../utils"
+import { canUnwrapped, createRule, defineRegexpVisitor } from "../utils"
+
+export default createRule("no-zero-quantifier", {
+    meta: {
+        docs: {
+            description: "disallow quantifiers with a maximum of zero",
+            // TODO Switch to recommended in the major version.
+            // recommended: true,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected:
+                "Unexpected zero quantifier. The quantifier and its quantified element can be removed without affecting the pattern.",
+            withCapturingGroup:
+                "Unexpected zero quantifier. The quantifier and its quantified element do not affecting the pattern. Try to remove the elements but be careful because it contains at least one capturing group.",
+
+            // suggestions
+            remove: "Remove this zero quantifier.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        /**
+         * Create visitor
+         */
+        function createVisitor(
+            regexpContext: RegExpContext,
+        ): RegExpVisitor.Handlers {
+            const {
+                node,
+                getRegexpLocation,
+                fixReplaceNode,
+                patternAst,
+            } = regexpContext
+
+            return {
+                onQuantifierEnter(qNode) {
+                    if (qNode.max === 0) {
+                        const containCapturingGroup = hasSomeDescendant(
+                            qNode,
+                            (n) => n.type === "CapturingGroup",
+                        )
+
+                        if (containCapturingGroup) {
+                            context.report({
+                                node,
+                                loc: getRegexpLocation(qNode),
+                                messageId: "withCapturingGroup",
+                            })
+                        } else {
+                            const suggest: Rule.SuggestionReportDescriptor[] = []
+                            if (patternAst.raw === qNode.raw) {
+                                suggest.push({
+                                    messageId: "remove",
+                                    fix: fixReplaceNode(qNode, "(?:)"),
+                                })
+                            } else if (canUnwrapped(qNode, "")) {
+                                suggest.push({
+                                    messageId: "remove",
+                                    fix: fixReplaceNode(qNode, ""),
+                                })
+                            }
+
+                            context.report({
+                                node,
+                                loc: getRegexpLocation(qNode),
+                                messageId: "unexpected",
+                                suggest,
+                            })
+                        }
+                    }
+                },
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})
diff --git a/lib/utils/rules.ts b/lib/utils/rules.ts
@@ -37,6 +37,7 @@ import noUselessNonGreedy from "../rules/no-useless-non-greedy"
 import noUselessQuantifier from "../rules/no-useless-quantifier"
 import noUselessRange from "../rules/no-useless-range"
 import noUselessTwoNumsQuantifier from "../rules/no-useless-two-nums-quantifier"
+import noZeroQuantifier from "../rules/no-zero-quantifier"
 import optimalLookaroundQuantifier from "../rules/optimal-lookaround-quantifier"
 import orderInCharacterClass from "../rules/order-in-character-class"
 import preferCharacterClass from "../rules/prefer-character-class"
@@ -96,6 +97,7 @@ export const rules = [
     noUselessQuantifier,
     noUselessRange,
     noUselessTwoNumsQuantifier,
+    noZeroQuantifier,
     optimalLookaroundQuantifier,
     orderInCharacterClass,
     preferCharacterClass,
diff --git a/tests/lib/rules/no-zero-quantifier.ts b/tests/lib/rules/no-zero-quantifier.ts
@@ -0,0 +1,59 @@
+import { RuleTester } from "eslint"
+import rule from "../../../lib/rules/no-zero-quantifier"
+
+const tester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+})
+
+tester.run("no-zero-quantifier", rule as any, {
+    valid: [`/a{0,1}/`, `/a{0,}/`],
+    invalid: [
+        {
+            code: `/a{0}/`,
+            errors: [
+                {
+                    messageId: "unexpected",
+                    column: 2,
+                    endColumn: 6,
+                    suggestions: [{ output: `/(?:)/` }],
+                },
+            ],
+        },
+        {
+            code: `/a{0,0}/`,
+            errors: [
+                {
+                    messageId: "unexpected",
+                    column: 2,
+                    endColumn: 8,
+                    suggestions: [{ output: `/(?:)/` }],
+                },
+            ],
+        },
+        {
+            code: `/a{0,0}?b/`,
+            errors: [
+                {
+                    messageId: "unexpected",
+                    column: 2,
+                    endColumn: 9,
+                    suggestions: [{ output: `/b/` }],
+                },
+            ],
+        },
+        {
+            code: `/(a){0}/`,
+            errors: [
+                {
+                    messageId: "withCapturingGroup",
+                    column: 2,
+                    endColumn: 8,
+                    suggestions: [],
+                },
+            ],
+        },
+    ],
+})
