eslint 9.21.0 → 9.23.0

package/lib/rules/no-nonoctal-decimal-escape.js

@@ -17,7 +17,7 @@ const QUICK_TEST_REGEX = /\\[89]/u;
  * @returns {string} "\uXXXX" sequence.
  */
 function getUnicodeEscape(character) {
-    return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
+	return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
 }
 
 //------------------------------------------------------------------------------
@@ -26,123 +26,143 @@ function getUnicodeEscape(character) {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `\\8` and `\\9` escape sequences in string literals",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
-
-            // suggestions
-            refactor: "Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
-            escapeBackslash: "Replace '{{original}}' with '{{replacement}}' to include the actual backslash character."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Creates a new Suggestion object.
-         * @param {string} messageId "refactor" or "escapeBackslash".
-         * @param {int[]} range The range to replace.
-         * @param {string} replacement New text for the range.
-         * @returns {Object} Suggestion
-         */
-        function createSuggestion(messageId, range, replacement) {
-            return {
-                messageId,
-                data: {
-                    original: sourceCode.getText().slice(...range),
-                    replacement
-                },
-                fix(fixer) {
-                    return fixer.replaceTextRange(range, replacement);
-                }
-            };
-        }
-
-        return {
-            Literal(node) {
-                if (typeof node.value !== "string") {
-                    return;
-                }
-
-                if (!QUICK_TEST_REGEX.test(node.raw)) {
-                    return;
-                }
-
-                const regex = /(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy;
-                let match;
-
-                while ((match = regex.exec(node.raw))) {
-                    const { previousEscape, decimalEscape } = match.groups;
-                    const decimalEscapeRangeEnd = node.range[0] + match.index + match[0].length;
-                    const decimalEscapeRangeStart = decimalEscapeRangeEnd - decimalEscape.length;
-                    const decimalEscapeRange = [decimalEscapeRangeStart, decimalEscapeRangeEnd];
-                    const suggest = [];
-
-                    // When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape`
-                    if (previousEscape === "\\0") {
-
-                        /*
-                         * Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8".
-                         * Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing
-                         * an octal escape while fixing a decimal escape, we provide different suggestions.
-                         */
-                        suggest.push(
-                            createSuggestion( // "\0\8" -> "\u00008"
-                                "refactor",
-                                [decimalEscapeRangeStart - previousEscape.length, decimalEscapeRangeEnd],
-                                `${getUnicodeEscape("\0")}${decimalEscape[1]}`
-                            ),
-                            createSuggestion( // "\8" -> "\u0038"
-                                "refactor",
-                                decimalEscapeRange,
-                                getUnicodeEscape(decimalEscape[1])
-                            )
-                        );
-                    } else {
-                        suggest.push(
-                            createSuggestion( // "\8" -> "8"
-                                "refactor",
-                                decimalEscapeRange,
-                                decimalEscape[1]
-                            )
-                        );
-                    }
-
-                    suggest.push(
-                        createSuggestion( // "\8" -> "\\8"
-                            "escapeBackslash",
-                            decimalEscapeRange,
-                            `\\${decimalEscape}`
-                        )
-                    );
-
-                    context.report({
-                        node,
-                        loc: {
-                            start: sourceCode.getLocFromIndex(decimalEscapeRangeStart),
-                            end: sourceCode.getLocFromIndex(decimalEscapeRangeEnd)
-                        },
-                        messageId: "decimalEscape",
-                        data: {
-                            decimalEscape
-                        },
-                        suggest
-                    });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `\\8` and `\\9` escape sequences in string literals",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape",
+		},
+
+		hasSuggestions: true,
+
+		schema: [],
+
+		messages: {
+			decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
+
+			// suggestions
+			refactor:
+				"Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
+			escapeBackslash:
+				"Replace '{{original}}' with '{{replacement}}' to include the actual backslash character.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Creates a new Suggestion object.
+		 * @param {string} messageId "refactor" or "escapeBackslash".
+		 * @param {int[]} range The range to replace.
+		 * @param {string} replacement New text for the range.
+		 * @returns {Object} Suggestion
+		 */
+		function createSuggestion(messageId, range, replacement) {
+			return {
+				messageId,
+				data: {
+					original: sourceCode.getText().slice(...range),
+					replacement,
+				},
+				fix(fixer) {
+					return fixer.replaceTextRange(range, replacement);
+				},
+			};
+		}
+
+		return {
+			Literal(node) {
+				if (typeof node.value !== "string") {
+					return;
+				}
+
+				if (!QUICK_TEST_REGEX.test(node.raw)) {
+					return;
+				}
+
+				const regex =
+					/(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy;
+				let match;
+
+				while ((match = regex.exec(node.raw))) {
+					const { previousEscape, decimalEscape } = match.groups;
+					const decimalEscapeRangeEnd =
+						node.range[0] + match.index + match[0].length;
+					const decimalEscapeRangeStart =
+						decimalEscapeRangeEnd - decimalEscape.length;
+					const decimalEscapeRange = [
+						decimalEscapeRangeStart,
+						decimalEscapeRangeEnd,
+					];
+					const suggest = [];
+
+					// When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape`
+					if (previousEscape === "\\0") {
+						/*
+						 * Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8".
+						 * Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing
+						 * an octal escape while fixing a decimal escape, we provide different suggestions.
+						 */
+						suggest.push(
+							createSuggestion(
+								// "\0\8" -> "\u00008"
+								"refactor",
+								[
+									decimalEscapeRangeStart -
+										previousEscape.length,
+									decimalEscapeRangeEnd,
+								],
+								`${getUnicodeEscape("\0")}${decimalEscape[1]}`,
+							),
+							createSuggestion(
+								// "\8" -> "\u0038"
+								"refactor",
+								decimalEscapeRange,
+								getUnicodeEscape(decimalEscape[1]),
+							),
+						);
+					} else {
+						suggest.push(
+							createSuggestion(
+								// "\8" -> "8"
+								"refactor",
+								decimalEscapeRange,
+								decimalEscape[1],
+							),
+						);
+					}
+
+					suggest.push(
+						createSuggestion(
+							// "\8" -> "\\8"
+							"escapeBackslash",
+							decimalEscapeRange,
+							`\\${decimalEscape}`,
+						),
+					);
+
+					context.report({
+						node,
+						loc: {
+							start: sourceCode.getLocFromIndex(
+								decimalEscapeRangeStart,
+							),
+							end: sourceCode.getLocFromIndex(
+								decimalEscapeRangeEnd,
+							),
+						},
+						messageId: "decimalEscape",
+						data: {
+							decimalEscape,
+						},
+						suggest,
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-obj-calls.js

@@ -9,7 +9,11 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CALL, CONSTRUCT, ReferenceTracker } = require("@eslint-community/eslint-utils");
+const {
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+} = require("@eslint-community/eslint-utils");
 const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 
 //------------------------------------------------------------------------------
@@ -24,13 +28,13 @@ const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
  * @returns {string} name to report
  */
 function getReportNodeName(node) {
-    if (node.type === "ChainExpression") {
-        return getReportNodeName(node.expression);
-    }
-    if (node.type === "MemberExpression") {
-        return getPropertyName(node);
-    }
-    return node.name;
+	if (node.type === "ChainExpression") {
+		return getReportNodeName(node.expression);
+	}
+	if (node.type === "MemberExpression") {
+		return getPropertyName(node);
+	}
+	return node.name;
 }
 
 //------------------------------------------------------------------------------
@@ -39,48 +43,57 @@ function getReportNodeName(node) {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow calling global object properties as functions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-obj-calls"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedCall: "'{{name}}' is not a function.",
-            unexpectedRefCall: "'{{name}}' is reference to '{{ref}}', which is not a function."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-                const traceMap = {};
-
-                for (const g of nonCallableGlobals) {
-                    traceMap[g] = {
-                        [CALL]: true,
-                        [CONSTRUCT]: true
-                    };
-                }
-
-                for (const { node: refNode, path } of tracker.iterateGlobalReferences(traceMap)) {
-                    const name = getReportNodeName(refNode.callee);
-                    const ref = path[0];
-                    const messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
-
-                    context.report({ node: refNode, messageId, data: { name, ref } });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow calling global object properties as functions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-obj-calls",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpectedCall: "'{{name}}' is not a function.",
+			unexpectedRefCall:
+				"'{{name}}' is reference to '{{ref}}', which is not a function.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+				const traceMap = {};
+
+				for (const g of nonCallableGlobals) {
+					traceMap[g] = {
+						[CALL]: true,
+						[CONSTRUCT]: true,
+					};
+				}
+
+				for (const {
+					node: refNode,
+					path,
+				} of tracker.iterateGlobalReferences(traceMap)) {
+					const name = getReportNodeName(refNode.callee);
+					const ref = path[0];
+					const messageId =
+						name === ref ? "unexpectedCall" : "unexpectedRefCall";
+
+					context.report({
+						node: refNode,
+						messageId,
+						data: { name, ref },
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-object-constructor.js

@@ -10,10 +10,10 @@
 //------------------------------------------------------------------------------
 
 const {
-    getVariableByName,
-    isArrowToken,
-    isStartOfExpressionStatement,
-    needsPrecedingSemicolon
+	getVariableByName,
+	isArrowToken,
+	isStartOfExpressionStatement,
+	needsPrecedingSemicolon,
 } = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -22,96 +22,103 @@ const {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow calls to the `Object` constructor without an argument",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-object-constructor"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            preferLiteral: "The object literal notation {} is preferable.",
-            useLiteral: "Replace with '{{replacement}}'.",
-            useLiteralAfterSemicolon: "Replace with '{{replacement}}', add preceding semicolon."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether or not an object literal that replaces a specified node needs to be enclosed in parentheses.
-         * @param {ASTNode} node The node to be replaced.
-         * @returns {boolean} Whether or not parentheses around the object literal are required.
-         */
-        function needsParentheses(node) {
-            if (isStartOfExpressionStatement(node)) {
-                return true;
-            }
-
-            const prevToken = sourceCode.getTokenBefore(node);
-
-            if (prevToken && isArrowToken(prevToken)) {
-                return true;
-            }
-
-            return false;
-        }
-
-        /**
-         * Reports on nodes where the `Object` constructor is called without arguments.
-         * @param {ASTNode} node The node to evaluate.
-         * @returns {void}
-         */
-        function check(node) {
-            if (node.callee.type !== "Identifier" || node.callee.name !== "Object" || node.arguments.length) {
-                return;
-            }
-
-            const variable = getVariableByName(sourceCode.getScope(node), "Object");
-
-            if (variable && variable.identifiers.length === 0) {
-                let replacement;
-                let fixText;
-                let messageId = "useLiteral";
-
-                if (needsParentheses(node)) {
-                    replacement = "({})";
-                    if (needsPrecedingSemicolon(sourceCode, node)) {
-                        fixText = ";({})";
-                        messageId = "useLiteralAfterSemicolon";
-                    } else {
-                        fixText = "({})";
-                    }
-                } else {
-                    replacement = fixText = "{}";
-                }
-
-                context.report({
-                    node,
-                    messageId: "preferLiteral",
-                    suggest: [
-                        {
-                            messageId,
-                            data: { replacement },
-                            fix: fixer => fixer.replaceText(node, fixText)
-                        }
-                    ]
-                });
-            }
-        }
-
-        return {
-            CallExpression: check,
-            NewExpression: check
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow calls to the `Object` constructor without an argument",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-object-constructor",
+		},
+
+		hasSuggestions: true,
+
+		schema: [],
+
+		messages: {
+			preferLiteral: "The object literal notation {} is preferable.",
+			useLiteral: "Replace with '{{replacement}}'.",
+			useLiteralAfterSemicolon:
+				"Replace with '{{replacement}}', add preceding semicolon.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether or not an object literal that replaces a specified node needs to be enclosed in parentheses.
+		 * @param {ASTNode} node The node to be replaced.
+		 * @returns {boolean} Whether or not parentheses around the object literal are required.
+		 */
+		function needsParentheses(node) {
+			if (isStartOfExpressionStatement(node)) {
+				return true;
+			}
+
+			const prevToken = sourceCode.getTokenBefore(node);
+
+			if (prevToken && isArrowToken(prevToken)) {
+				return true;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Reports on nodes where the `Object` constructor is called without arguments.
+		 * @param {ASTNode} node The node to evaluate.
+		 * @returns {void}
+		 */
+		function check(node) {
+			if (
+				node.callee.type !== "Identifier" ||
+				node.callee.name !== "Object" ||
+				node.arguments.length
+			) {
+				return;
+			}
+
+			const variable = getVariableByName(
+				sourceCode.getScope(node),
+				"Object",
+			);
+
+			if (variable && variable.identifiers.length === 0) {
+				let replacement;
+				let fixText;
+				let messageId = "useLiteral";
+
+				if (needsParentheses(node)) {
+					replacement = "({})";
+					if (needsPrecedingSemicolon(sourceCode, node)) {
+						fixText = ";({})";
+						messageId = "useLiteralAfterSemicolon";
+					} else {
+						fixText = "({})";
+					}
+				} else {
+					replacement = fixText = "{}";
+				}
+
+				context.report({
+					node,
+					messageId: "preferLiteral",
+					suggest: [
+						{
+							messageId,
+							data: { replacement },
+							fix: fixer => fixer.replaceText(node, fixText),
+						},
+					],
+				});
+			}
+		}
+
+		return {
+			CallExpression: check,
+			NewExpression: check,
+		};
+	},
 };