eslint 9.21.0 → 9.23.0

package/lib/rules/no-useless-backreference.js

@@ -9,7 +9,12 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
+const {
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+	getStringIfConstant,
+} = require("@eslint-community/eslint-utils");
 const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
 
 //------------------------------------------------------------------------------
@@ -24,15 +29,15 @@ const parser = new RegExpParser();
  * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
  */
 function getPathToRoot(node) {
-    const path = [];
-    let current = node;
+	const path = [];
+	let current = node;
 
-    do {
-        path.push(current);
-        current = current.parent;
-    } while (current);
+	do {
+		path.push(current);
+		current = current.parent;
+	} while (current);
 
-    return path;
+	return path;
 }
 
 /**
@@ -41,8 +46,10 @@ function getPathToRoot(node) {
  * @returns {boolean} `true` if it is a lookaround node.
  */
 function isLookaround(node) {
-    return node.type === "Assertion" &&
-        (node.kind === "lookahead" || node.kind === "lookbehind");
+	return (
+		node.type === "Assertion" &&
+		(node.kind === "lookahead" || node.kind === "lookbehind")
+	);
 }
 
 /**
@@ -51,7 +58,7 @@ function isLookaround(node) {
  * @returns {boolean} `true` if it is a negative lookaround node.
  */
 function isNegativeLookaround(node) {
-    return isLookaround(node) && node.negate;
+	return isLookaround(node) && node.negate;
 }
 
 //------------------------------------------------------------------------------
@@ -60,185 +67,197 @@ function isNegativeLookaround(node) {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow useless backreferences in regular expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-backreference"
-        },
-
-        schema: [],
-
-        messages: {
-            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."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks and reports useless backreferences in the given regular expression.
-         * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
-         * @param {string} pattern Regular expression pattern.
-         * @param {string} flags Regular expression flags.
-         * @returns {void}
-         */
-        function checkRegex(node, pattern, flags) {
-            let regExpAST;
-
-            try {
-                regExpAST = parser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            visitRegExpAST(regExpAST, {
-                onBackreferenceEnter(bref) {
-                    const groups = [bref.resolved].flat(),
-                        brefPath = getPathToRoot(bref);
-
-                    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
-                            };
-                        }
-
-
-                        // Start from the root to find the lowest common ancestor.
-                        let i = brefPath.length - 1,
-                            j = groupPath.length - 1;
-
-                        do {
-                            i--;
-                            j--;
-                        } while (brefPath[i] === groupPath[j]);
-
-                        const indexOfLowestCommonAncestor = j + 1,
-                            groupCut = groupPath.slice(0, indexOfLowestCommonAncestor),
-                            commonPath = groupPath.slice(indexOfLowestCommonAncestor),
-                            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.
-                            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.
-                            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.
-                            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;
-                    }
-
-                    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
-                        }
-                    });
-                }
-            });
-        }
-
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex;
-
-                checkRegex(node, pattern, flags);
-            },
-            Program(node) {
-                const scope = sourceCode.getScope(node),
-                    tracker = new ReferenceTracker(scope),
-                    traceMap = {
-                        RegExp: {
-                            [CALL]: true,
-                            [CONSTRUCT]: true
-                        }
-                    };
-
-                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
-                    const [patternNode, flagsNode] = refNode.arguments,
-                        pattern = getStringIfConstant(patternNode, scope),
-                        flags = getStringIfConstant(flagsNode, scope);
-
-                    if (typeof pattern === "string") {
-                        checkRegex(refNode, pattern, flags || "");
-                    }
-                }
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow useless backreferences in regular expressions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-useless-backreference",
+		},
+
+		schema: [],
+
+		messages: {
+			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.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Checks and reports useless backreferences in the given regular expression.
+		 * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
+		 * @param {string} pattern Regular expression pattern.
+		 * @param {string} flags Regular expression flags.
+		 * @returns {void}
+		 */
+		function checkRegex(node, pattern, flags) {
+			let regExpAST;
+
+			try {
+				regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+					unicode: flags.includes("u"),
+					unicodeSets: flags.includes("v"),
+				});
+			} catch {
+				// Ignore regular expressions with syntax errors
+				return;
+			}
+
+			visitRegExpAST(regExpAST, {
+				onBackreferenceEnter(bref) {
+					const groups = [bref.resolved].flat(),
+						brefPath = getPathToRoot(bref);
+
+					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,
+							};
+						}
+
+						// Start from the root to find the lowest common ancestor.
+						let i = brefPath.length - 1,
+							j = groupPath.length - 1;
+
+						do {
+							i--;
+							j--;
+						} while (brefPath[i] === groupPath[j]);
+
+						const indexOfLowestCommonAncestor = j + 1,
+							groupCut = groupPath.slice(
+								0,
+								indexOfLowestCommonAncestor,
+							),
+							commonPath = groupPath.slice(
+								indexOfLowestCommonAncestor,
+							),
+							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.
+							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.
+							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.
+							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;
+					}
+
+					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,
+						},
+					});
+				},
+			});
+		}
+
+		return {
+			"Literal[regex]"(node) {
+				const { pattern, flags } = node.regex;
+
+				checkRegex(node, pattern, flags);
+			},
+			Program(node) {
+				const scope = sourceCode.getScope(node),
+					tracker = new ReferenceTracker(scope),
+					traceMap = {
+						RegExp: {
+							[CALL]: true,
+							[CONSTRUCT]: true,
+						},
+					};
+
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					traceMap,
+				)) {
+					const [patternNode, flagsNode] = refNode.arguments,
+						pattern = getStringIfConstant(patternNode, scope),
+						flags = getStringIfConstant(flagsNode, scope);
+
+					if (typeof pattern === "string") {
+						checkRegex(refNode, pattern, flags || "");
+					}
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-useless-call.js

@@ -17,20 +17,19 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
  */
 function isCallOrNonVariadicApply(node) {
-    const callee = astUtils.skipChainExpression(node.callee);
-
-    return (
-        callee.type === "MemberExpression" &&
-        callee.property.type === "Identifier" &&
-        callee.computed === false &&
-        (
-            (callee.property.name === "call" && node.arguments.length >= 1) ||
-            (callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
-        )
-    );
+	const callee = astUtils.skipChainExpression(node.callee);
+
+	return (
+		callee.type === "MemberExpression" &&
+		callee.property.type === "Identifier" &&
+		callee.computed === false &&
+		((callee.property.name === "call" && node.arguments.length >= 1) ||
+			(callee.property.name === "apply" &&
+				node.arguments.length === 2 &&
+				node.arguments[1].type === "ArrayExpression"))
+	);
 }
 
-
 /**
  * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
  * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
@@ -39,10 +38,10 @@ function isCallOrNonVariadicApply(node) {
  * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
  */
 function isValidThisArg(expectedThis, thisArg, sourceCode) {
-    if (!expectedThis) {
-        return astUtils.isNullOrUndefined(thisArg);
-    }
-    return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
+	if (!expectedThis) {
+		return astUtils.isNullOrUndefined(thisArg);
+	}
+	return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
 }
 
 //------------------------------------------------------------------------------
@@ -51,40 +50,46 @@ function isValidThisArg(expectedThis, thisArg, sourceCode) {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary calls to `.call()` and `.apply()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-useless-call"
-        },
-
-        schema: [],
-
-        messages: {
-            unnecessaryCall: "Unnecessary '.{{name}}()'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                if (!isCallOrNonVariadicApply(node)) {
-                    return;
-                }
-
-                const callee = astUtils.skipChainExpression(node.callee);
-                const applied = astUtils.skipChainExpression(callee.object);
-                const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
-                const thisArg = node.arguments[0];
-
-                if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-                    context.report({ node, messageId: "unnecessaryCall", data: { name: callee.property.name } });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow unnecessary calls to `.call()` and `.apply()`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-useless-call",
+		},
+
+		schema: [],
+
+		messages: {
+			unnecessaryCall: "Unnecessary '.{{name}}()'.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			CallExpression(node) {
+				if (!isCallOrNonVariadicApply(node)) {
+					return;
+				}
+
+				const callee = astUtils.skipChainExpression(node.callee);
+				const applied = astUtils.skipChainExpression(callee.object);
+				const expectedThis =
+					applied.type === "MemberExpression" ? applied.object : null;
+				const thisArg = node.arguments[0];
+
+				if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
+					context.report({
+						node,
+						messageId: "unnecessaryCall",
+						data: { name: callee.property.name },
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-useless-catch.js

@@ -11,47 +11,47 @@
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
+	meta: {
+		type: "suggestion",
 
-        docs: {
-            description: "Disallow unnecessary `catch` clauses",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-catch"
-        },
+		docs: {
+			description: "Disallow unnecessary `catch` clauses",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-useless-catch",
+		},
 
-        schema: [],
+		schema: [],
 
-        messages: {
-            unnecessaryCatchClause: "Unnecessary catch clause.",
-            unnecessaryCatch: "Unnecessary try/catch wrapper."
-        }
-    },
+		messages: {
+			unnecessaryCatchClause: "Unnecessary catch clause.",
+			unnecessaryCatch: "Unnecessary try/catch wrapper.",
+		},
+	},
 
-    create(context) {
-        return {
-            CatchClause(node) {
-                if (
-                    node.param &&
-                    node.param.type === "Identifier" &&
-                    node.body.body.length &&
-                    node.body.body[0].type === "ThrowStatement" &&
-                    node.body.body[0].argument.type === "Identifier" &&
-                    node.body.body[0].argument.name === node.param.name
-                ) {
-                    if (node.parent.finalizer) {
-                        context.report({
-                            node,
-                            messageId: "unnecessaryCatchClause"
-                        });
-                    } else {
-                        context.report({
-                            node: node.parent,
-                            messageId: "unnecessaryCatch"
-                        });
-                    }
-                }
-            }
-        };
-    }
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (
+					node.param &&
+					node.param.type === "Identifier" &&
+					node.body.body.length &&
+					node.body.body[0].type === "ThrowStatement" &&
+					node.body.body[0].argument.type === "Identifier" &&
+					node.body.body[0].argument.name === node.param.name
+				) {
+					if (node.parent.finalizer) {
+						context.report({
+							node,
+							messageId: "unnecessaryCatchClause",
+						});
+					} else {
+						context.report({
+							node: node.parent,
+							messageId: "unnecessaryCatch",
+						});
+					}
+				}
+			},
+		};
+	},
 };