eslint 9.22.0 → 9.24.0

package/lib/rules/no-octal-escape.js

@@ -9,48 +9,45 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow octal escape sequences in string literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-octal-escape"
-        },
-
-        schema: [],
-
-        messages: {
-            octalEscapeSequence: "Don't use octal: '\\{{sequence}}'. Use '\\u....' instead."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            Literal(node) {
-                if (typeof node.value !== "string") {
-                    return;
-                }
-
-                // \0 represents a valid NULL character if it isn't followed by a digit.
-                const match = node.raw.match(
-                    /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su
-                );
-
-                if (match) {
-                    context.report({
-                        node,
-                        messageId: "octalEscapeSequence",
-                        data: { sequence: match[1] }
-                    });
-                }
-            }
-
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow octal escape sequences in string literals",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-octal-escape",
+		},
+
+		schema: [],
+
+		messages: {
+			octalEscapeSequence:
+				"Don't use octal: '\\{{sequence}}'. Use '\\u....' instead.",
+		},
+	},
+
+	create(context) {
+		return {
+			Literal(node) {
+				if (typeof node.value !== "string") {
+					return;
+				}
+
+				// \0 represents a valid NULL character if it isn't followed by a digit.
+				const match = node.raw.match(
+					/^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su,
+				);
+
+				if (match) {
+					context.report({
+						node,
+						messageId: "octalEscapeSequence",
+						data: { sequence: match[1] },
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-octal.js

@@ -9,37 +9,37 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow octal literals",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-octal"
-        },
-
-        schema: [],
-
-        messages: {
-            noOctal: "Octal literals should not be used."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            Literal(node) {
-                if (typeof node.value === "number" && /^0[0-9]/u.test(node.raw)) {
-                    context.report({
-                        node,
-                        messageId: "noOctal"
-                    });
-                }
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow octal literals",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-octal",
+		},
+
+		schema: [],
+
+		messages: {
+			noOctal: "Octal literals should not be used.",
+		},
+	},
+
+	create(context) {
+		return {
+			Literal(node) {
+				if (
+					typeof node.value === "number" &&
+					/^0[0-9]/u.test(node.raw)
+				) {
+					context.report({
+						node,
+						messageId: "noOctal",
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-param-reassign.js

@@ -8,223 +8,241 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const stopNodePattern = /(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;
+const stopNodePattern =
+	/(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow reassigning function parameters",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-param-reassign"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "object",
-                        properties: {
-                            props: {
-                                enum: [false]
-                            }
-                        },
-                        additionalProperties: false
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            props: {
-                                enum: [true]
-                            },
-                            ignorePropertyModificationsFor: {
-                                type: "array",
-                                items: {
-                                    type: "string"
-                                },
-                                uniqueItems: true
-                            },
-                            ignorePropertyModificationsForRegex: {
-                                type: "array",
-                                items: {
-                                    type: "string"
-                                },
-                                uniqueItems: true
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            assignmentToFunctionParam: "Assignment to function parameter '{{name}}'.",
-            assignmentToFunctionParamProp: "Assignment to property of function parameter '{{name}}'."
-        }
-    },
-
-    create(context) {
-        const props = context.options[0] && context.options[0].props;
-        const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];
-        const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks whether or not the reference modifies properties of its variable.
-         * @param {Reference} reference A reference to check.
-         * @returns {boolean} Whether or not the reference modifies properties of its variable.
-         */
-        function isModifyingProp(reference) {
-            let node = reference.identifier;
-            let parent = node.parent;
-
-            while (parent && (!stopNodePattern.test(parent.type) ||
-                    parent.type === "ForInStatement" || parent.type === "ForOfStatement")) {
-                switch (parent.type) {
-
-                    // e.g. foo.a = 0;
-                    case "AssignmentExpression":
-                        return parent.left === node;
-
-                    // e.g. ++foo.a;
-                    case "UpdateExpression":
-                        return true;
-
-                    // e.g. delete foo.a;
-                    case "UnaryExpression":
-                        if (parent.operator === "delete") {
-                            return true;
-                        }
-                        break;
-
-                    // e.g. for (foo.a in b) {}
-                    case "ForInStatement":
-                    case "ForOfStatement":
-                        if (parent.left === node) {
-                            return true;
-                        }
-
-                        // this is a stop node for parent.right and parent.body
-                        return false;
-
-                    // EXCLUDES: e.g. cache.get(foo.a).b = 0;
-                    case "CallExpression":
-                        if (parent.callee !== node) {
-                            return false;
-                        }
-                        break;
-
-                    // EXCLUDES: e.g. cache[foo.a] = 0;
-                    case "MemberExpression":
-                        if (parent.property === node) {
-                            return false;
-                        }
-                        break;
-
-                    // EXCLUDES: e.g. ({ [foo]: a }) = bar;
-                    case "Property":
-                        if (parent.key === node) {
-                            return false;
-                        }
-
-                        break;
-
-                    // EXCLUDES: e.g. (foo ? a : b).c = bar;
-                    case "ConditionalExpression":
-                        if (parent.test === node) {
-                            return false;
-                        }
-
-                        break;
-
-                    // no default
-                }
-
-                node = parent;
-                parent = node.parent;
-            }
-
-            return false;
-        }
-
-        /**
-         * Tests that an identifier name matches any of the ignored property assignments.
-         * First we test strings in ignoredPropertyAssignmentsFor.
-         * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
-         * @param {string} identifierName A string that describes the name of an identifier to
-         * ignore property assignments for.
-         * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
-         */
-        function isIgnoredPropertyAssignment(identifierName) {
-            return ignoredPropertyAssignmentsFor.includes(identifierName) ||
-                ignoredPropertyAssignmentsForRegex.some(ignored => new RegExp(ignored, "u").test(identifierName));
-        }
-
-        /**
-         * Reports a reference if is non initializer and writable.
-         * @param {Reference} reference A reference to check.
-         * @param {int} index The index of the reference in the references.
-         * @param {Reference[]} references The array that the reference belongs to.
-         * @returns {void}
-         */
-        function checkReference(reference, index, references) {
-            const identifier = reference.identifier;
-
-            if (identifier &&
-                !reference.init &&
-
-                /*
-                 * Destructuring assignments can have multiple default value,
-                 * so possibly there are multiple writeable references for the same identifier.
-                 */
-                (index === 0 || references[index - 1].identifier !== identifier)
-            ) {
-                if (reference.isWrite()) {
-                    context.report({
-                        node: identifier,
-                        messageId: "assignmentToFunctionParam",
-                        data: { name: identifier.name }
-                    });
-                } else if (props && isModifyingProp(reference) && !isIgnoredPropertyAssignment(identifier.name)) {
-                    context.report({
-                        node: identifier,
-                        messageId: "assignmentToFunctionParamProp",
-                        data: { name: identifier.name }
-                    });
-                }
-            }
-        }
-
-        /**
-         * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable A variable to check.
-         * @returns {void}
-         */
-        function checkVariable(variable) {
-            if (variable.defs[0].type === "Parameter") {
-                variable.references.forEach(checkReference);
-            }
-        }
-
-        /**
-         * Checks parameters of a given function node.
-         * @param {ASTNode} node A function node to check.
-         * @returns {void}
-         */
-        function checkForFunction(node) {
-            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-        }
-
-        return {
-
-            // `:exit` is needed for the `node.parent` property of identifier nodes.
-            "FunctionDeclaration:exit": checkForFunction,
-            "FunctionExpression:exit": checkForFunction,
-            "ArrowFunctionExpression:exit": checkForFunction
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow reassigning function parameters",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-param-reassign",
+		},
+
+		schema: [
+			{
+				oneOf: [
+					{
+						type: "object",
+						properties: {
+							props: {
+								enum: [false],
+							},
+						},
+						additionalProperties: false,
+					},
+					{
+						type: "object",
+						properties: {
+							props: {
+								enum: [true],
+							},
+							ignorePropertyModificationsFor: {
+								type: "array",
+								items: {
+									type: "string",
+								},
+								uniqueItems: true,
+							},
+							ignorePropertyModificationsForRegex: {
+								type: "array",
+								items: {
+									type: "string",
+								},
+								uniqueItems: true,
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+		],
+
+		messages: {
+			assignmentToFunctionParam:
+				"Assignment to function parameter '{{name}}'.",
+			assignmentToFunctionParamProp:
+				"Assignment to property of function parameter '{{name}}'.",
+		},
+	},
+
+	create(context) {
+		const props = context.options[0] && context.options[0].props;
+		const ignoredPropertyAssignmentsFor =
+			(context.options[0] &&
+				context.options[0].ignorePropertyModificationsFor) ||
+			[];
+		const ignoredPropertyAssignmentsForRegex =
+			(context.options[0] &&
+				context.options[0].ignorePropertyModificationsForRegex) ||
+			[];
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Checks whether or not the reference modifies properties of its variable.
+		 * @param {Reference} reference A reference to check.
+		 * @returns {boolean} Whether or not the reference modifies properties of its variable.
+		 */
+		function isModifyingProp(reference) {
+			let node = reference.identifier;
+			let parent = node.parent;
+
+			while (
+				parent &&
+				(!stopNodePattern.test(parent.type) ||
+					parent.type === "ForInStatement" ||
+					parent.type === "ForOfStatement")
+			) {
+				switch (parent.type) {
+					// e.g. foo.a = 0;
+					case "AssignmentExpression":
+						return parent.left === node;
+
+					// e.g. ++foo.a;
+					case "UpdateExpression":
+						return true;
+
+					// e.g. delete foo.a;
+					case "UnaryExpression":
+						if (parent.operator === "delete") {
+							return true;
+						}
+						break;
+
+					// e.g. for (foo.a in b) {}
+					case "ForInStatement":
+					case "ForOfStatement":
+						if (parent.left === node) {
+							return true;
+						}
+
+						// this is a stop node for parent.right and parent.body
+						return false;
+
+					// EXCLUDES: e.g. cache.get(foo.a).b = 0;
+					case "CallExpression":
+						if (parent.callee !== node) {
+							return false;
+						}
+						break;
+
+					// EXCLUDES: e.g. cache[foo.a] = 0;
+					case "MemberExpression":
+						if (parent.property === node) {
+							return false;
+						}
+						break;
+
+					// EXCLUDES: e.g. ({ [foo]: a }) = bar;
+					case "Property":
+						if (parent.key === node) {
+							return false;
+						}
+
+						break;
+
+					// EXCLUDES: e.g. (foo ? a : b).c = bar;
+					case "ConditionalExpression":
+						if (parent.test === node) {
+							return false;
+						}
+
+						break;
+
+					// no default
+				}
+
+				node = parent;
+				parent = node.parent;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Tests that an identifier name matches any of the ignored property assignments.
+		 * First we test strings in ignoredPropertyAssignmentsFor.
+		 * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
+		 * @param {string} identifierName A string that describes the name of an identifier to
+		 * ignore property assignments for.
+		 * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
+		 */
+		function isIgnoredPropertyAssignment(identifierName) {
+			return (
+				ignoredPropertyAssignmentsFor.includes(identifierName) ||
+				ignoredPropertyAssignmentsForRegex.some(ignored =>
+					new RegExp(ignored, "u").test(identifierName),
+				)
+			);
+		}
+
+		/**
+		 * Reports a reference if is non initializer and writable.
+		 * @param {Reference} reference A reference to check.
+		 * @param {int} index The index of the reference in the references.
+		 * @param {Reference[]} references The array that the reference belongs to.
+		 * @returns {void}
+		 */
+		function checkReference(reference, index, references) {
+			const identifier = reference.identifier;
+
+			if (
+				identifier &&
+				!reference.init &&
+				/*
+				 * Destructuring assignments can have multiple default value,
+				 * so possibly there are multiple writeable references for the same identifier.
+				 */
+				(index === 0 || references[index - 1].identifier !== identifier)
+			) {
+				if (reference.isWrite()) {
+					context.report({
+						node: identifier,
+						messageId: "assignmentToFunctionParam",
+						data: { name: identifier.name },
+					});
+				} else if (
+					props &&
+					isModifyingProp(reference) &&
+					!isIgnoredPropertyAssignment(identifier.name)
+				) {
+					context.report({
+						node: identifier,
+						messageId: "assignmentToFunctionParamProp",
+						data: { name: identifier.name },
+					});
+				}
+			}
+		}
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {Variable} variable A variable to check.
+		 * @returns {void}
+		 */
+		function checkVariable(variable) {
+			if (variable.defs[0].type === "Parameter") {
+				variable.references.forEach(checkReference);
+			}
+		}
+
+		/**
+		 * Checks parameters of a given function node.
+		 * @param {ASTNode} node A function node to check.
+		 * @returns {void}
+		 */
+		function checkForFunction(node) {
+			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+		}
+
+		return {
+			// `:exit` is needed for the `node.parent` property of identifier nodes.
+			"FunctionDeclaration:exit": checkForFunction,
+			"FunctionExpression:exit": checkForFunction,
+			"ArrowFunctionExpression:exit": checkForFunction,
+		};
+	},
 };