Add regexp/no-useless-non-capturing-group rule (#43)

Author: ota-meshi

README.md

@@ -92,6 +92,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-backreference](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-backreference.html) | disallow useless backreferences in regular expressions |  |
 | [regexp/no-useless-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-character-class.html) | disallow character class with one character | :wrench: |
 | [regexp/no-useless-exactly-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-exactly-quantifier.html) | disallow unnecessary exactly quantifier | :star: |
+| [regexp/no-useless-non-capturing-group](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-capturing-group.html) | disallow unnecessary Non-capturing group | :wrench: |
 | [regexp/no-useless-non-greedy](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-greedy.html) | disallow unnecessary quantifier non-greedy (`?`) | :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: |

docs/rules/README.md

@@ -24,6 +24,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-backreference](./no-useless-backreference.md) | disallow useless backreferences in regular expressions |  |
 | [regexp/no-useless-character-class](./no-useless-character-class.md) | disallow character class with one character | :wrench: |
 | [regexp/no-useless-exactly-quantifier](./no-useless-exactly-quantifier.md) | disallow unnecessary exactly quantifier | :star: |
+| [regexp/no-useless-non-capturing-group](./no-useless-non-capturing-group.md) | disallow unnecessary Non-capturing group | :wrench: |
 | [regexp/no-useless-non-greedy](./no-useless-non-greedy.md) | disallow unnecessary quantifier non-greedy (`?`) | :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: |

docs/rules/no-useless-non-capturing-group.md

@@ -0,0 +1,41 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-useless-non-capturing-group"
+description: "disallow unnecessary Non-capturing group"
+---
+# regexp/no-useless-non-capturing-group
+
+> disallow unnecessary Non-capturing group
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the problems reported by this rule.
+
+## :book: Rule Details
+
+This rule reports unnecessary Non-capturing group
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/no-useless-non-capturing-group: "error" */
+
+/* ✓ GOOD */
+var foo = /(?:abcd)?/
+var foo = /(?:ab|cd)/
+
+/* ✗ BAD */
+var foo = /(?:abcd)/
+var foo = /(?:[a-d])/
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-useless-non-capturing-group.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-useless-non-capturing-group.ts)

lib/rules/no-useless-non-capturing-group.ts

@@ -0,0 +1,91 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import {
+    canUnwrapped,
+    createRule,
+    defineRegexpVisitor,
+    getRegexpLocation,
+    getRegexpRange,
+} from "../utils"
+
+export default createRule("no-useless-non-capturing-group", {
+    meta: {
+        docs: {
+            description: "disallow unnecessary Non-capturing group",
+            // TODO In the major version
+            // recommended: true,
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            unexpected: "Unexpected quantifier Non-capturing group.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(node: Expression): RegExpVisitor.Handlers {
+            return {
+                onGroupEnter(gNode) {
+                    if (gNode.alternatives.length !== 1) {
+                        // Useful when using disjunctions.
+                        // e.g. /(?:a|b)/
+                        return
+                    }
+                    const alt = gNode.alternatives[0]
+                    if (alt.elements.length === 0) {
+                        // Ignore empty groups. You can check with another rule.
+                        // e.g. /(?:)/
+                        return
+                    }
+                    const parent = gNode.parent
+                    if (
+                        parent.type === "Quantifier" &&
+                        alt.elements.length > 1
+                    ) {
+                        // e.g. /(?:ab)?/
+                        return
+                    }
+                    if (!canUnwrapped(gNode, alt.raw)) {
+                        return
+                    }
+
+                    context.report({
+                        node,
+                        loc: getRegexpLocation(sourceCode, node, gNode),
+                        messageId: "unexpected",
+                        fix(fixer) {
+                            const groupRange = getRegexpRange(
+                                sourceCode,
+                                node,
+                                gNode,
+                            )
+                            const altRange = getRegexpRange(
+                                sourceCode,
+                                node,
+                                alt,
+                            )
+                            if (!groupRange || !altRange) {
+                                return null
+                            }
+                            return [
+                                fixer.removeRange([groupRange[0], altRange[0]]),
+                                fixer.removeRange([altRange[1], groupRange[1]]),
+                            ]
+                        },
+                    })
+                },
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})

lib/utils/rules.ts

@@ -12,6 +12,7 @@ import noOctal from "../rules/no-octal"
 import noUselessBackreference from "../rules/no-useless-backreference"
 import noUselessCharacterClass from "../rules/no-useless-character-class"
 import noUselessExactlyQuantifier from "../rules/no-useless-exactly-quantifier"
+import noUselessNonCapturingGroup from "../rules/no-useless-non-capturing-group"
 import noUselessNonGreedy from "../rules/no-useless-non-greedy"
 import noUselessRange from "../rules/no-useless-range"
 import noUselessTwoNumsQuantifier from "../rules/no-useless-two-nums-quantifier"
@@ -42,6 +43,7 @@ export const rules = [
     noUselessBackreference,
     noUselessCharacterClass,
     noUselessExactlyQuantifier,
+    noUselessNonCapturingGroup,
     noUselessNonGreedy,
     noUselessRange,
     noUselessTwoNumsQuantifier,

package.json

@@ -16,7 +16,7 @@
         "test:base": "mocha --require ts-node/register \"tests/**/*.ts\" --reporter dot --timeout 60000",
         "test": "npm run test:nyc",
         "test:nyc": "nyc --reporter=lcov npm run test:base",
-        "test:debug": "mocha --require ts-node/register/transpile-only \"tests/**/*.ts\" --reporter dot",
+        "test:debug": "mocha --require ts-node/register/transpile-only \"tests/**/*.ts\" --reporter dot --timeout 60000",
         "test:watch": "npm run test:base -- --watch",
         "update": "ts-node --transpile-only ./tools/update.ts && npm run eslint-fix && npm run test:nyc",
         "new": "ts-node ./tools/new-rule.ts",

tests/lib/rules/no-useless-non-capturing-group.ts

@@ -0,0 +1,88 @@
+import { RuleTester } from "eslint"
+import rule from "../../../lib/rules/no-useless-non-capturing-group"
+
+const tester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+})
+
+tester.run("no-useless-non-capturing-group", rule as any, {
+    valid: [
+        `/(?:abcd)?/`,
+        `/(?:ab|cd)/`,
+        `/(?:a|b)/`,
+        `/(?:)/`,
+        String.raw`/()\1(?:0)/`,
+        String.raw`/\1(?:0)/`,
+        String.raw`/\0(?:1)/`,
+    ],
+    invalid: [
+        {
+            code: `/(?:abcd)/`,
+            output: `/abcd/`,
+            errors: [
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 2,
+                    endLine: 1,
+                    endColumn: 10,
+                },
+            ],
+        },
+        {
+            code: `/(?:[abcd])/`,
+            output: `/[abcd]/`,
+            errors: [
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 2,
+                    endLine: 1,
+                    endColumn: 12,
+                },
+            ],
+        },
+        {
+            code: `/(?:[abcd]+?)/`,
+            output: `/[abcd]+?/`,
+            errors: [
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 2,
+                },
+            ],
+        },
+        {
+            code: String.raw`/(?:0)/; /\1(?:0)/; /(?:1)/; /\1(?:1)/`,
+            output: String.raw`/0/; /\1(?:0)/; /1/; /\1(?:1)/`,
+            errors: [
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 2,
+                },
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 22,
+                },
+            ],
+        },
+        {
+            code: String.raw`/(?:a\n)/`,
+            output: String.raw`/a\n/`,
+            errors: ["Unexpected quantifier Non-capturing group."],
+        },
+        {
+            code: String.raw`
+            const s = "(?:a\\n)"
+            new RegExp(s)`,
+            output: null,
+            errors: ["Unexpected quantifier Non-capturing group."],
+        },
+    ],
+})