Add regexp/prefer-unicode-codepoint-escapes rule (#33)

Author: ota-meshi

README.md

@@ -100,6 +100,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/prefer-regexp-test](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-test.html) | enforce that `RegExp#test` is used instead of `String#match` and `RegExp#exec` | :wrench: |
 | [regexp/prefer-star-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-star-quantifier.html) | enforce using `*` quantifier | :star::wrench: |
 | [regexp/prefer-t](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-t.html) | enforce using `\t` | :star::wrench: |
+| [regexp/prefer-unicode-codepoint-escapes](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-unicode-codepoint-escapes.html) | enforce use of unicode codepoint escapes | :wrench: |
 | [regexp/prefer-w](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-w.html) | enforce using `\w` | :star::wrench: |
 
 <!--RULES_TABLE_END-->

docs/rules/README.md

@@ -32,4 +32,5 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/prefer-regexp-test](./prefer-regexp-test.md) | enforce that `RegExp#test` is used instead of `String#match` and `RegExp#exec` | :wrench: |
 | [regexp/prefer-star-quantifier](./prefer-star-quantifier.md) | enforce using `*` quantifier | :star::wrench: |
 | [regexp/prefer-t](./prefer-t.md) | enforce using `\t` | :star::wrench: |
+| [regexp/prefer-unicode-codepoint-escapes](./prefer-unicode-codepoint-escapes.md) | enforce use of unicode codepoint escapes | :wrench: |
 | [regexp/prefer-w](./prefer-w.md) | enforce using `\w` | :star::wrench: |

docs/rules/prefer-unicode-codepoint-escapes.md

@@ -0,0 +1,40 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/prefer-unicode-codepoint-escapes"
+description: "enforce use of unicode codepoint escapes"
+---
+# regexp/prefer-unicode-codepoint-escapes
+
+> enforce use of unicode codepoint escapes
+
+- :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 enforces the use of Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/prefer-unicode-codepoint-escapes: "error" */
+
+/* ✓ GOOD */
+var foo = /\u{1f600}/u
+var foo = /😀/u
+
+/* ✗ BAD */
+var foo = /\ud83d\ude00/u
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/prefer-unicode-codepoint-escapes.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/prefer-unicode-codepoint-escapes.ts)

lib/rules/prefer-unicode-codepoint-escapes.ts

@@ -0,0 +1,79 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import {
+    createRule,
+    defineRegexpVisitor,
+    getRegexpLocation,
+    getRegexpRange,
+} from "../utils"
+
+export default createRule("prefer-unicode-codepoint-escapes", {
+    meta: {
+        docs: {
+            description: "enforce use of unicode codepoint escapes",
+            // TODO In the major version, it will be changed to "recommended".
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            disallowSurrogatePair:
+                "Use Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(
+            node: Expression,
+            _pattern: string,
+            flags: string,
+        ): RegExpVisitor.Handlers {
+            if (!flags.includes("u")) {
+                return {}
+            }
+            return {
+                onCharacterEnter(cNode) {
+                    if (cNode.value >= 0x10000) {
+                        if (/^(?:\\u[\da-fA-F]{4}){2}$/.test(cNode.raw)) {
+                            context.report({
+                                node,
+                                loc: getRegexpLocation(sourceCode, node, cNode),
+                                messageId: "disallowSurrogatePair",
+                                fix(fixer) {
+                                    const range = getRegexpRange(
+                                        sourceCode,
+                                        node,
+                                        cNode,
+                                    )
+                                    if (range == null) {
+                                        return null
+                                    }
+                                    let text = String.fromCodePoint(cNode.value)
+                                        .codePointAt(0)!
+                                        .toString(16)
+                                    if (/[A-F]/.test(cNode.raw)) {
+                                        text = text.toUpperCase()
+                                    }
+                                    return fixer.replaceTextRange(
+                                        range,
+                                        `\\u{${text}}`,
+                                    )
+                                },
+                            })
+                        }
+                    }
+                },
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})

lib/utils/rules.ts

@@ -20,6 +20,7 @@ import preferRegexpExec from "../rules/prefer-regexp-exec"
 import preferRegexpTest from "../rules/prefer-regexp-test"
 import preferStarQuantifier from "../rules/prefer-star-quantifier"
 import preferT from "../rules/prefer-t"
+import preferUnicodeCodepointEscapes from "../rules/prefer-unicode-codepoint-escapes"
 import preferW from "../rules/prefer-w"
 
 export const rules = [
@@ -44,5 +45,6 @@ export const rules = [
     preferRegexpTest,
     preferStarQuantifier,
     preferT,
+    preferUnicodeCodepointEscapes,
     preferW,
 ] as RuleModule[]

tests/lib/rules/prefer-unicode-codepoint-escapes.ts

@@ -0,0 +1,66 @@
+import { RuleTester } from "eslint"
+import rule from "../../../lib/rules/prefer-unicode-codepoint-escapes"
+
+const tester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+})
+
+tester.run("prefer-unicode-codepoint-escapes", rule as any, {
+    valid: [
+        `/regexp/u`,
+        String.raw`/\ud83d\ude00/`,
+        String.raw`/[\ud83d\ude00]/`,
+        String.raw`/\u{1f600}/u`,
+        String.raw`/😀/u`,
+    ],
+    invalid: [
+        {
+            code: String.raw`/\ud83d\ude00/u`,
+            output: String.raw`/\u{1f600}/u`,
+            errors: [
+                {
+                    message:
+                        "Use Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.",
+                    line: 1,
+                    column: 2,
+                    endLine: 1,
+                    endColumn: 14,
+                },
+            ],
+        },
+        {
+            code: String.raw`/[\ud83d\ude00]/u`,
+            output: String.raw`/[\u{1f600}]/u`,
+            errors: [
+                {
+                    message:
+                        "Use Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.",
+                    line: 1,
+                    column: 3,
+                    endLine: 1,
+                    endColumn: 15,
+                },
+            ],
+        },
+        {
+            code: String.raw`/\uD83D\uDE00/u`,
+            output: String.raw`/\u{1F600}/u`,
+            errors: [
+                "Use Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.",
+            ],
+        },
+        {
+            code: String.raw`
+            const s = "\\ud83d\\ude00"
+            new RegExp(s, 'u')
+            `,
+            output: null,
+            errors: [
+                "Use Unicode codepoint escapes instead of Unicode escapes using surrogate pairs.",
+            ],
+        },
+    ],
+})