Add support for ES2025

Author: ota-meshi

Diff for: lib/rules/no-useless-backreference.ts

@@ -15,6 +15,14 @@ import type { RegExpContext } from "../utils"
 import { createRule, defineRegexpVisitor } from "../utils"
 import { mention } from "../utils/mention"
 
+type MessageId =
+    | "nested"
+    | "disjunctive"
+    | "intoNegativeLookaround"
+    | "forward"
+    | "backward"
+    | "empty"
+
 /**
  * Returns whether the list of ancestors from `from` to `to` contains a negated
  * lookaround.
@@ -35,16 +43,67 @@ function hasNegatedLookaroundInBetween(
     return false
 }
 
+/**
+ * Returns the problem information specifying the reason why the backreference is
+ * useless.
+ */
+function getUselessProblem(
+    backRef: Backreference,
+    flags: ReadonlyFlags,
+): { messageId: MessageId; group: CapturingGroup; otherGroups: string } | null {
+    const groups = [backRef.resolved].flat()
+
+    const problems: { messageId: MessageId; group: CapturingGroup }[] = []
+    for (const group of groups) {
+        const messageId = getUselessMessageId(backRef, group, flags)
+        if (!messageId) {
+            return null
+        }
+        problems.push({ messageId, group })
+    }
+    if (problems.length === 0) {
+        return null
+    }
+
+    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`
+    }
+    return {
+        messageId,
+        group,
+        otherGroups,
+    }
+}
+
 /**
  * Returns the message id specifying the reason why the backreference is
  * useless.
  */
 function getUselessMessageId(
     backRef: Backreference,
+    group: CapturingGroup,
     flags: ReadonlyFlags,
-): string | null {
-    const group = backRef.resolved
-
+): MessageId | null {
     const closestAncestor = getClosestAncestor(backRef, group)
 
     if (closestAncestor === group) {
@@ -93,16 +152,16 @@ export default createRule("no-useless-backreference", {
         },
         schema: [],
         messages: {
-            nested: "Backreference {{ bref }} will be ignored. It references group {{ group }} from within that group.",
+            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 }} which appears later in the pattern.",
+                "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 }} which appears before in the same lookbehind.",
+                "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 }} which is in another alternative.",
+                "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 }} which is in a negative lookaround.",
-            empty: "Backreference {{ bref }} will be ignored. It references group {{ group }} which always captures zero characters.",
+                "Backreference {{ bref }} will be ignored. It references group {{ group }}{{ otherGroups }} which is in a negative lookaround.",
+            empty: "Backreference {{ bref }} will be ignored. It references group {{ group }}{{ otherGroups }} which always captures zero characters.",
         },
         type: "suggestion", // "problem",
     },
@@ -114,16 +173,17 @@ export default createRule("no-useless-backreference", {
         }: RegExpContext): RegExpVisitor.Handlers {
             return {
                 onBackreferenceEnter(backRef) {
-                    const messageId = getUselessMessageId(backRef, flags)
+                    const problem = getUselessProblem(backRef, flags)
 
-                    if (messageId) {
+                    if (problem) {
                         context.report({
                             node,
                             loc: getRegexpLocation(backRef),
-                            messageId,
+                            messageId: problem.messageId,
                             data: {
                                 bref: mention(backRef),
-                                group: mention(backRef.resolved),
+                                group: mention(problem.group),
+                                otherGroups: problem.otherGroups,
                             },
                         })
                     }

Diff for: lib/rules/prefer-named-backreference.ts

@@ -24,7 +24,11 @@ export default createRule("prefer-named-backreference", {
         }: RegExpContext): RegExpVisitor.Handlers {
             return {
                 onBackreferenceEnter(bNode) {
-                    if (bNode.resolved.name && !bNode.raw.startsWith("\\k<")) {
+                    if (
+                        !bNode.ambiguous &&
+                        bNode.resolved.name &&
+                        !bNode.raw.startsWith("\\k<")
+                    ) {
                         context.report({
                             node,
                             loc: getRegexpLocation(bNode),

Diff for: lib/utils/regexp-ast/case-variation.ts

@@ -139,19 +139,28 @@ export function isCaseVariant(
                     // case-variant in Unicode mode
                     return unicodeLike && d.kind === "word"
 
-                case "Backreference":
+                case "Backreference": {
                     // we need to check whether the associated capturing group
                     // is case variant
-                    if (hasSomeDescendant(element, d.resolved)) {
+
+                    const outside = [d.resolved]
+                        .flat()
+                        .filter(
+                            (resolved) => !hasSomeDescendant(element, resolved),
+                        )
+                    if (outside.length === 0) {
                         // the capturing group is part of the root element, so
                         // we don't need to make an extra check
                         return false
                     }
 
                     return (
                         !isEmptyBackreference(d, flags) &&
-                        isCaseVariant(d.resolved, flags)
+                        outside.some((resolved) =>
+                            isCaseVariant(resolved, flags),
+                        )
                     )
+                }
 
                 case "Character":
                 case "CharacterClassRange":

Diff for: package-lock.json

@@ -84,7 +84,7 @@
         "assert": "^2.0.0",
         "chai": "^5.0.0",
         "env-cmd": "^10.1.0",
-        "eslint": "^9.5.0",
+        "eslint": "^9.6.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-doc-generator": "^1.7.1",
         "eslint-import-resolver-typescript": "^3.6.1",
@@ -120,7 +120,7 @@
     },
     "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.9.1",
+        "@eslint-community/regexpp": "^4.11.0",
         "comment-parser": "^1.4.0",
         "jsdoc-type-pratt-parser": "^4.0.0",
         "refa": "^0.12.1",