feat: add support for es2025 duplicate named capturing groups (#18630)

ota-meshi · web-flow · commit 7bd98398f112 · 2024-07-04T15:58:48.000+02:00
* feat: add support for es2025 to `no-useless-backreference`

* test: add test for es2025 to `no-invalid-regexp`

* update REGEXPP_LATEST_ECMA_VERSION to 2025

* change `no-useless-backreference` to handle disjunctive

* fix comment
diff --git a/lib/rules/no-useless-backreference.js b/lib/rules/no-useless-backreference.js
@@ -72,11 +72,11 @@ module.exports = {
         schema: [],
 
         messages: {
-            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' from within that group.",
-            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears later in the pattern.",
-            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears before in the same lookbehind.",
-            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in another alternative.",
-            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in a negative lookaround."
+            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
+            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
+            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
+            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
+            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround."
         }
     },
 
@@ -104,16 +104,21 @@ module.exports = {
 
             visitRegExpAST(regExpAST, {
                 onBackreferenceEnter(bref) {
-                    const group = bref.resolved,
-                        brefPath = getPathToRoot(bref),
-                        groupPath = getPathToRoot(group);
-                    let messageId = null;
+                    const groups = [bref.resolved].flat(),
+                        brefPath = getPathToRoot(bref);
 
-                    if (brefPath.includes(group)) {
+                    const problems = groups.map(group => {
+                        const groupPath = getPathToRoot(group);
+
+                        if (brefPath.includes(group)) {
+
+                            // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
+                            return {
+                                messageId: "nested",
+                                group
+                            };
+                        }
 
-                        // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
-                        messageId = "nested";
-                    } else {
 
                         // Start from the root to find the lowest common ancestor.
                         let i = brefPath.length - 1,
@@ -130,35 +135,80 @@ module.exports = {
                             lowestCommonLookaround = commonPath.find(isLookaround),
                             isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind";
 
+                        if (groupCut.at(-1).type === "Alternative") {
+
+                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
+                            return {
+                                messageId: "disjunctive",
+                                group
+                            };
+                        }
                         if (!isMatchingBackward && bref.end <= group.start) {
 
                             // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
-                            messageId = "forward";
-                        } else if (isMatchingBackward && group.end <= bref.start) {
+                            return {
+                                messageId: "forward",
+                                group
+                            };
+                        }
+                        if (isMatchingBackward && group.end <= bref.start) {
 
                             // the opposite of the previous when the regex is matching backward in a lookbehind context.
-                            messageId = "backward";
-                        } else if (groupCut.at(-1).type === "Alternative") {
-
-                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
-                            messageId = "disjunctive";
-                        } else if (groupCut.some(isNegativeLookaround)) {
+                            return {
+                                messageId: "backward",
+                                group
+                            };
+                        }
+                        if (groupCut.some(isNegativeLookaround)) {
 
                             // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
-                            messageId = "intoNegativeLookaround";
+                            return {
+                                messageId: "intoNegativeLookaround",
+                                group
+                            };
                         }
+
+                        return null;
+                    });
+
+                    if (problems.length === 0 || problems.some(problem => !problem)) {
+
+                        // If there are no problems or no problems with any group then do not report it.
+                        return;
                     }
 
-                    if (messageId) {
-                        context.report({
-                            node,
-                            messageId,
-                            data: {
-                                bref: bref.raw,
-                                group: group.raw
-                            }
-                        });
+                    let problemsToReport;
+
+                    // Gets problems that appear in the same disjunction.
+                    const problemsInSameDisjunction = problems.filter(problem => problem.messageId !== "disjunctive");
+
+                    if (problemsInSameDisjunction.length) {
+
+                        // Only report problems that appear in the same disjunction.
+                        problemsToReport = problemsInSameDisjunction;
+                    } else {
+
+                        // If all groups appear in different disjunctions, report it.
+                        problemsToReport = problems;
                     }
+
+                    const [{ messageId, group }, ...other] = problemsToReport;
+                    let otherGroups = "";
+
+                    if (other.length === 1) {
+                        otherGroups = " and another group";
+                    } else if (other.length > 1) {
+                        otherGroups = ` and other ${other.length} groups`;
+                    }
+                    context.report({
+                        node,
+                        messageId,
+                        data: {
+                            bref: bref.raw,
+                            group: group.raw,
+                            otherGroups
+                        }
+                    });
                 }
             });
         }
diff --git a/lib/rules/utils/regular-expressions.js b/lib/rules/utils/regular-expressions.js
@@ -8,7 +8,7 @@
 
 const { RegExpValidator } = require("@eslint-community/regexpp");
 
-const REGEXPP_LATEST_ECMA_VERSION = 2024;
+const REGEXPP_LATEST_ECMA_VERSION = 2025;
 
 /**
  * Checks if the given regular expression pattern would be valid with the `u` flag.
diff --git a/package.json b/package.json
@@ -67,7 +67,7 @@
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
-    "@eslint-community/regexpp": "^4.6.1",
+    "@eslint-community/regexpp": "^4.11.0",
     "@eslint/config-array": "^0.17.0",
     "@eslint/eslintrc": "^3.1.0",
     "@eslint/js": "9.6.0",
diff --git a/tests/lib/rules/no-invalid-regexp.js b/tests/lib/rules/no-invalid-regexp.js
@@ -89,6 +89,9 @@ ruleTester.run("no-invalid-regexp", rule, {
         "new RegExp('[A--B]', flags)", // valid only with `v` flag
         "new RegExp('[[]\\\\u{0}*', flags)", // valid only with `u` flag
 
+        // ES2025
+        "new RegExp('((?<k>a)|(?<k>b))')",
+
         // allowConstructorFlags
         {
             code: "new RegExp('.', 'g')",
@@ -356,6 +359,16 @@ ruleTester.run("no-invalid-regexp", rule, {
                 data: { message: "Invalid regular expression: /[[]\\u{0}*/v: Unterminated character class" },
                 type: "NewExpression"
             }]
+        },
+
+        // ES2025
+        {
+            code: "new RegExp('(?<k>a)(?<k>b)')",
+            errors: [{
+                messageId: "regexMessage",
+                data: { message: "Invalid regular expression: /(?<k>a)(?<k>b)/: Duplicate capture group name" },
+                type: "NewExpression"
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-useless-backreference.js b/tests/lib/rules/no-useless-backreference.js
