Add no-regexp-unicode-property-escapes-2020 rule

Author: ota-meshi

.github/workflows/cron.yml

@@ -0,0 +1,24 @@
+name: cron
+on:
+  schedule:
+    - cron: 0 0 * * 0
+
+jobs:
+  check-resource-update:
+    name: check-resource-update
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 14
+      - name: Install Packages
+        run: npm install
+      - name: Update
+        run: npm run resource-update:unicode-properties
+      - name: Check changes
+        run: |
+            git add --all && \
+            git diff-index --cached HEAD --stat --exit-code

docs/rules/index.md

@@ -55,6 +55,7 @@ There are multiple configs that enable all rules in this category: `plugin:es-x/
 | [es-x/no-nullish-coalescing-operators](./no-nullish-coalescing-operators.md) | disallow nullish coalescing operators. |  |
 | [es-x/no-optional-chaining](./no-optional-chaining.md) | disallow optional chaining. |  |
 | [es-x/no-promise-all-settled](./no-promise-all-settled.md) | disallow `Promise.allSettled` function. |  |
+| [es-x/no-regexp-unicode-property-escapes-2020](./no-regexp-unicode-property-escapes-2020.md) | disallow the new values of RegExp Unicode property escape sequences in ES2020. |  |
 | [es-x/no-string-prototype-matchall](./no-string-prototype-matchall.md) | disallow the `String.prototype.matchAll` method. |  |
 
 ## ES2019

docs/rules/no-regexp-unicode-property-escapes-2020.md

@@ -0,0 +1,42 @@
+---
+title: "es-x/no-regexp-unicode-property-escapes-2020"
+description: "disallow the new values of RegExp Unicode property escape sequences in ES2020"
+---
+
+# es-x/no-regexp-unicode-property-escapes-2020
+> disallow the new values of RegExp Unicode property escape sequences in ES2020
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: `plugin:es-x/no-new-in-es2020`, `plugin:es-x/restrict-to-es3`, `plugin:es-x/restrict-to-es5`, `plugin:es-x/restrict-to-es2015`, `plugin:es-x/restrict-to-es2016`, `plugin:es-x/restrict-to-es2017`, `plugin:es-x/restrict-to-es2018`, and `plugin:es-x/restrict-to-es2019`
+
+This rule reports the new values of ES2018 [RegExp Unicode property escape sequences](https://github.com/tc39/proposal-regexp-unicode-property-escapes#readme) which were added in ES2020.
+
+For example, the following patterns are valid in ES2020, but syntax error in ES2019 environments:
+
+- `\p{Script=Elym}`
+- `\p{Script=Elymaic}`
+- `\p{Script=Hmnp}`
+- `\p{Script=Nand}`
+- `\p{Script=Nandinagari}`
+- `\p{Script=Nyiakeng_Puachue_Hmong}`
+- `\p{Script=Wancho}`
+- `\p{Script=Wcho}`
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-regexp-unicode-property-escapes-2020: error */
+const r1 = /\p{Script=Elym}/u
+const r2 = /\p{Script=Elymaic}/u
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-es-x/blob/master/lib/rules/no-regexp-unicode-property-escapes-2020.js)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-es-x/blob/master/tests/lib/rules/no-regexp-unicode-property-escapes-2020.js)

lib/configs/no-new-in-es2020.js

@@ -15,6 +15,7 @@ module.exports = {
         "es-x/no-nullish-coalescing-operators": "error",
         "es-x/no-optional-chaining": "error",
         "es-x/no-promise-all-settled": "error",
+        "es-x/no-regexp-unicode-property-escapes-2020": "error",
         "es-x/no-string-prototype-matchall": "error",
     },
 }

lib/index.js

@@ -189,6 +189,7 @@ module.exports = {
         "no-regexp-u-flag": require("./rules/no-regexp-u-flag"),
         "no-regexp-unicode-property-escapes": require("./rules/no-regexp-unicode-property-escapes"),
         "no-regexp-unicode-property-escapes-2019": require("./rules/no-regexp-unicode-property-escapes-2019"),
+        "no-regexp-unicode-property-escapes-2020": require("./rules/no-regexp-unicode-property-escapes-2020"),
         "no-regexp-y-flag": require("./rules/no-regexp-y-flag"),
         "no-rest-parameters": require("./rules/no-rest-parameters"),
         "no-rest-spread-properties": require("./rules/no-rest-spread-properties"),

lib/rules/no-regexp-lookbehind-assertions.js

@@ -4,41 +4,7 @@
  */
 "use strict"
 
-const { RegExpValidator } = require("@eslint-community/regexpp")
-const { getRegExpCalls } = require("../utils")
-
-/**
- * Verify a given regular expression.
- * @param {RuleContext} context The rule context to report.
- * @param {Node} node The AST node to report.
- * @param {string} pattern The pattern part of a RegExp.
- * @param {string} flags The flags part of a RegExp.
- * @returns {void}
- */
-function verify(context, node, pattern, flags) {
-    try {
-        let found = false
-
-        new RegExpValidator({
-            onLookaroundAssertionEnter(_start, kind) {
-                if (kind === "lookbehind") {
-                    found = true
-                }
-            },
-        }).validatePattern(pattern, 0, pattern.length, flags.includes("u"))
-
-        if (found) {
-            context.report({ node, messageId: "forbidden" })
-        }
-    } catch (error) {
-        //istanbul ignore else
-        if (error.message.startsWith("Invalid regular expression:")) {
-            return
-        }
-        //istanbul ignore next
-        throw error
-    }
-}
+const { defineRegExpHandler } = require("../util/define-regexp-handler")
 
 module.exports = {
     meta: {
@@ -56,18 +22,20 @@ module.exports = {
         type: "problem",
     },
     create(context) {
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex
-                verify(context, node, pattern || "", flags || "")
-            },
-
-            "Program:exit"() {
-                const scope = context.getScope()
-                for (const { node, pattern, flags } of getRegExpCalls(scope)) {
-                    verify(context, node, pattern || "", flags || "")
-                }
-            },
-        }
+        return defineRegExpHandler(context, (node) => {
+            let found = false
+            return {
+                onLookaroundAssertionEnter(_start, kind) {
+                    if (kind === "lookbehind") {
+                        found = true
+                    }
+                },
+                onExit() {
+                    if (found) {
+                        context.report({ node, messageId: "forbidden" })
+                    }
+                },
+            }
+        })
     },
 }

lib/rules/no-regexp-named-capture-groups.js

@@ -4,46 +4,7 @@
  */
 "use strict"
 
-const { RegExpValidator } = require("@eslint-community/regexpp")
-const { getRegExpCalls } = require("../utils")
-
-/**
- * Verify a given regular expression.
- * @param {RuleContext} context The rule context to report.
- * @param {Node} node The AST node to report.
- * @param {string} pattern The pattern part of a RegExp.
- * @param {string} flags The flags part of a RegExp.
- * @returns {void}
- */
-function verify(context, node, pattern, flags) {
-    try {
-        let found = false
-
-        new RegExpValidator({
-            onCapturingGroupEnter(_start, name) {
-                if (name) {
-                    found = true
-                }
-            },
-            onBackreference(_start, _end, ref) {
-                if (typeof ref === "string") {
-                    found = true
-                }
-            },
-        }).validatePattern(pattern, 0, pattern.length, flags.includes("u"))
-
-        if (found) {
-            context.report({ node, messageId: "forbidden" })
-        }
-    } catch (error) {
-        //istanbul ignore else
-        if (error.message.startsWith("Invalid regular expression:")) {
-            return
-        }
-        //istanbul ignore next
-        throw error
-    }
-}
+const { defineRegExpHandler } = require("../util/define-regexp-handler")
 
 module.exports = {
     meta: {
@@ -61,18 +22,25 @@ module.exports = {
         type: "problem",
     },
     create(context) {
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex
-                verify(context, node, pattern || "", flags || "")
-            },
-
-            "Program:exit"() {
-                const scope = context.getScope()
-                for (const { node, pattern, flags } of getRegExpCalls(scope)) {
-                    verify(context, node, pattern || "", flags || "")
-                }
-            },
-        }
+        return defineRegExpHandler(context, (node) => {
+            let found = false
+            return {
+                onCapturingGroupEnter(_start, name) {
+                    if (name) {
+                        found = true
+                    }
+                },
+                onBackreference(_start, _end, ref) {
+                    if (typeof ref === "string") {
+                        found = true
+                    }
+                },
+                onExit() {
+                    if (found) {
+                        context.report({ node, messageId: "forbidden" })
+                    }
+                },
+            }
+        })
     },
 }

lib/rules/no-regexp-unicode-property-escapes-2019.js

@@ -4,63 +4,19 @@
  */
 "use strict"
 
-const { RegExpValidator } = require("@eslint-community/regexpp")
-const { getRegExpCalls } = require("../utils")
-
-const scNamePattern = /^(?:Script(?:_Extensions)?|scx?)$/u
-const scValuePattern =
-    /^(?:Dogr|Dogra|Gong|Gunjala_Gondi|Hanifi_Rohingya|Maka|Makasar|Medefaidrin|Medf|Old_Sogdian|Rohg|Sogd|Sogdian|Sogo)$/u
+const { defineRegExpHandler } = require("../util/define-regexp-handler")
+const {
+    scNameSet,
+    scValueSets,
+    binPropertySets,
+} = require("../util/unicode-properties")
 
 function isNewUnicodePropertyKeyValuePair(key, value) {
-    return scNamePattern.test(key) && scValuePattern.test(value)
+    return scNameSet.has(key) && scValueSets.es2019.has(value)
 }
 
 function isNewBinaryUnicodeProperty(key) {
-    return key === "Extended_Pictographic"
-}
-
-/**
- * Verify a given regular expression.
- * @param {RuleContext} context The rule context to report.
- * @param {Node} node The AST node to report.
- * @param {string} pattern The pattern part of a RegExp.
- * @param {string} flags The flags part of a RegExp.
- * @returns {void}
- */
-function verify(context, node, pattern, flags) {
-    try {
-        let foundValue = ""
-
-        new RegExpValidator({
-            onUnicodePropertyCharacterSet(start, end, _kind, key, value) {
-                if (foundValue) {
-                    return
-                }
-                if (
-                    value
-                        ? isNewUnicodePropertyKeyValuePair(key, value)
-                        : isNewBinaryUnicodeProperty(key)
-                ) {
-                    foundValue = pattern.slice(start, end)
-                }
-            },
-        }).validatePattern(pattern, 0, pattern.length, flags.includes("u"))
-
-        if (foundValue) {
-            context.report({
-                node,
-                messageId: "forbidden",
-                data: { value: foundValue },
-            })
-        }
-    } catch (error) {
-        //istanbul ignore else
-        if (error.message.startsWith("Invalid regular expression:")) {
-            return
-        }
-        //istanbul ignore next
-        throw error
-    }
+    return binPropertySets.es2019.has(key)
 }
 
 module.exports = {
@@ -80,18 +36,31 @@ module.exports = {
         type: "problem",
     },
     create(context) {
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex
-                verify(context, node, pattern || "", flags || "")
-            },
-
-            "Program:exit"() {
-                const scope = context.getScope()
-                for (const { node, pattern, flags } of getRegExpCalls(scope)) {
-                    verify(context, node, pattern || "", flags || "")
-                }
-            },
-        }
+        return defineRegExpHandler(context, (node, { pattern }) => {
+            let foundValue = ""
+            return {
+                onUnicodePropertyCharacterSet(start, end, _kind, key, value) {
+                    if (foundValue) {
+                        return
+                    }
+                    if (
+                        value
+                            ? isNewUnicodePropertyKeyValuePair(key, value)
+                            : isNewBinaryUnicodeProperty(key)
+                    ) {
+                        foundValue = pattern.slice(start, end)
+                    }
+                },
+                onExit() {
+                    if (foundValue) {
+                        context.report({
+                            node,
+                            messageId: "forbidden",
+                            data: { value: foundValue },
+                        })
+                    }
+                },
+            }
+        })
     },
 }