Add regexp/no-useless-character-class rule (#28)

* Add `regexp/no-useless-character-class` rule

* fixes

* fix

* Update

Author: ota-meshi

README.md

@@ -88,6 +88,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-invisible-character](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invisible-character.html) | disallow invisible raw character | :star::wrench: |
 | [regexp/no-octal](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-octal.html) | disallow octal escape sequence | :star: |
 | [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-two-nums-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html) | disallow unnecessary `{n,m}` quantifier | :star: |
 | [regexp/prefer-d](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html) | enforce using `\d` | :star::wrench: |

docs/rules/README.md

@@ -20,6 +20,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-invisible-character](./no-invisible-character.md) | disallow invisible raw character | :star::wrench: |
 | [regexp/no-octal](./no-octal.md) | disallow octal escape sequence | :star: |
 | [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-two-nums-quantifier](./no-useless-two-nums-quantifier.md) | disallow unnecessary `{n,m}` quantifier | :star: |
 | [regexp/prefer-d](./prefer-d.md) | enforce using `\d` | :star::wrench: |

docs/rules/no-useless-character-class.md

@@ -0,0 +1,75 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-useless-character-class"
+description: "disallow character class with one character"
+---
+# regexp/no-useless-character-class
+
+> disallow character class with one character
+
+- :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 character classes that defines only one character.
+
+Character classes that define only one character have the same effect even if you remove the brackets.
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/no-useless-character-class: "error" */
+
+/* ✓ GOOD */
+var foo = /abc/;
+
+/* ✗ BAD */
+var foo = /a[b]c/;
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+```json
+{
+  "regexp/no-useless-character-class": ["error", {
+    "ignores": ["="]
+  }]
+}
+```
+
+- `"ignores"` ... An array of characters and character classes to ignores. Default `["="]`.
+
+The default value is `"="` to prevent conflicts with the [no-div-regex] rule. Note that if you do not specify `"="`, there may be conflicts with the [no-div-regex] rule.
+
+### `"ignores": ["a"]`
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/no-useless-character-class: ["error", { "ignores": ["a"] }] */
+
+/* ✓ GOOD */
+var foo = /[a]bc/;
+
+/* ✗ BAD */
+var foo = /a[b]c/;
+```
+
+</eslint-code-block>
+
+## :couple: Related rules
+
+- [no-empty-character-class]
+- [no-div-regex]
+
+[no-empty-character-class]: https://eslint.org/docs/rules/no-empty-character-class
+[no-div-regex]: https://eslint.org/docs/rules/no-div-regex
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-useless-character-class.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-useless-character-class.ts)

lib/rules/no-escape-backspace.ts

@@ -1,6 +1,11 @@
 import type { Expression } from "estree"
 import type { RegExpVisitor } from "regexpp/visitor"
-import { createRule, defineRegexpVisitor, getRegexpLocation } from "../utils"
+import {
+    CP_BACKSPACE,
+    createRule,
+    defineRegexpVisitor,
+    getRegexpLocation,
+} from "../utils"
 
 export default createRule("no-escape-backspace", {
     meta: {
@@ -24,7 +29,7 @@ export default createRule("no-escape-backspace", {
         function createVisitor(node: Expression): RegExpVisitor.Handlers {
             return {
                 onCharacterEnter(cNode) {
-                    if (cNode.value === 8 && cNode.raw === "\\b") {
+                    if (cNode.value === CP_BACKSPACE && cNode.raw === "\\b") {
                         context.report({
                             node,
                             loc: getRegexpLocation(sourceCode, node, cNode),

lib/rules/no-useless-character-class.ts

@@ -0,0 +1,147 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import {
+    createRule,
+    defineRegexpVisitor,
+    fixerApplyEscape,
+    getRegexpLocation,
+    getRegexpRange,
+} from "../utils"
+
+export default createRule("no-useless-character-class", {
+    meta: {
+        docs: {
+            description: "disallow character class with one character",
+            // TODO In the major version
+            // recommended: true,
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    ignores: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                            minLength: 1,
+                        },
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpected:
+                "Unexpected character class with one {{type}}. Can remove brackets{{additional}}.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+        const ignores: string[] = context.options[0]?.ignores ?? ["="]
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(
+            node: Expression,
+            _pattern: string,
+            flags: string,
+        ): RegExpVisitor.Handlers {
+            return {
+                // eslint-disable-next-line complexity -- X(
+                onCharacterClassEnter(ccNode) {
+                    if (ccNode.elements.length !== 1) {
+                        return
+                    }
+                    if (ccNode.negate) {
+                        return
+                    }
+                    const element = ccNode.elements[0]
+                    if (ignores.length > 0 && ignores.includes(element.raw)) {
+                        return
+                    }
+                    if (element.type === "Character") {
+                        if (element.raw === "\\b") {
+                            // Backspace escape
+                            return
+                        }
+                        if (
+                            /^\\\d+$/.test(element.raw) &&
+                            !element.raw.startsWith("\\0")
+                        ) {
+                            // Avoid back reference
+                            return
+                        }
+                        if (
+                            ignores.length > 0 &&
+                            ignores.includes(
+                                String.fromCodePoint(element.value),
+                            )
+                        ) {
+                            return
+                        }
+                    } else if (element.type === "CharacterClassRange") {
+                        if (element.min.value !== element.max.value) {
+                            return
+                        }
+                    } else if (element.type !== "CharacterSet") {
+                        return
+                    }
+
+                    context.report({
+                        node,
+                        loc: getRegexpLocation(sourceCode, node, ccNode),
+                        messageId: "unexpected",
+                        data: {
+                            type:
+                                element.type === "Character"
+                                    ? "character"
+                                    : element.type === "CharacterClassRange"
+                                    ? "character class range"
+                                    : "character set",
+                            additional:
+                                element.type === "CharacterClassRange"
+                                    ? " and range"
+                                    : "",
+                        },
+                        fix(fixer) {
+                            const range = getRegexpRange(
+                                sourceCode,
+                                node,
+                                ccNode,
+                            )
+                            if (range == null) {
+                                return null
+                            }
+                            let text: string =
+                                element.type === "CharacterClassRange"
+                                    ? element.min.raw
+                                    : element.raw
+                            if (
+                                element.type === "Character" ||
+                                element.type === "CharacterClassRange"
+                            ) {
+                                if (
+                                    /^[.*+?${()|[/]$/u.test(text) ||
+                                    (flags.includes("u") && text === "}")
+                                ) {
+                                    text = fixerApplyEscape("\\", node) + text
+                                }
+                            }
+                            return fixer.replaceTextRange(range, text)
+                        },
+                    })
+                },
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})

lib/rules/prefer-quantifier.ts

@@ -134,7 +134,6 @@ export default createRule("prefer-quantifier", {
     meta: {
         docs: {
             description: "enforce using quantifier",
-            // TODO In the major version, it will be changed to "recommended".
             recommended: false,
         },
         fixable: "code",

lib/utils/rules.ts

@@ -8,6 +8,7 @@ import noEscapeBackspace from "../rules/no-escape-backspace"
 import noInvisibleCharacter from "../rules/no-invisible-character"
 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 noUselessTwoNumsQuantifier from "../rules/no-useless-two-nums-quantifier"
 import preferD from "../rules/prefer-d"
@@ -28,6 +29,7 @@ export const rules = [
     noInvisibleCharacter,
     noOctal,
     noUselessBackreference,
+    noUselessCharacterClass,
     noUselessExactlyQuantifier,
     noUselessTwoNumsQuantifier,
     preferD,

lib/utils/unicode.ts

@@ -1,3 +1,4 @@
+export const CP_BACKSPACE = 8
 export const CP_TAB = 9
 export const CP_LF = 10
 export const CP_VT = 11
@@ -8,9 +9,9 @@ export const CP_BAN = "!".codePointAt(0)!
 export const CP_SLASH = "/".codePointAt(0)!
 export const CP_COLON = ":".codePointAt(0)!
 export const CP_AT = "@".codePointAt(0)!
-export const CP_OPENING_BRACE = "[".codePointAt(0)!
+export const CP_OPENING_BRACKET = "[".codePointAt(0)!
 export const CP_BACKTICK = "`".codePointAt(0)!
-export const CP_OPENING_BRACKET = "{".codePointAt(0)!
+export const CP_OPENING_BRACE = "{".codePointAt(0)!
 export const CP_TILDE = "~".codePointAt(0)!
 export const CP_NEL = "\u0085".codePointAt(0)!
 export const CP_NBSP = "\u00a0".codePointAt(0)!
@@ -108,8 +109,8 @@ export function isSymbol(codePoint: number): boolean {
     return (
         isCodePointInRange(codePoint, [CP_BAN, CP_SLASH]) ||
         isCodePointInRange(codePoint, [CP_COLON, CP_AT]) ||
-        isCodePointInRange(codePoint, [CP_OPENING_BRACE, CP_BACKTICK]) ||
-        isCodePointInRange(codePoint, [CP_OPENING_BRACKET, CP_TILDE])
+        isCodePointInRange(codePoint, [CP_OPENING_BRACKET, CP_BACKTICK]) ||
+        isCodePointInRange(codePoint, [CP_OPENING_BRACE, CP_TILDE])
     )
 }