eslint 9.22.0 → 9.23.0

package/lib/rules/no-implicit-globals.js

@@ -11,138 +11,161 @@
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        defaultOptions: [{
-            lexicalBindings: false
-        }],
-
-        docs: {
-            description: "Disallow declarations in the global scope",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-implicit-globals"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                lexicalBindings: {
-                    type: "boolean"
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
-            globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
-            globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
-            assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
-            redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
-        }
-    },
-
-    create(context) {
-        const [{ lexicalBindings: checkLexicalBindings }] = context.options;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports the node.
-         * @param {ASTNode} node Node to report.
-         * @param {string} messageId Id of the message to report.
-         * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
-         * @returns {void}
-         */
-        function report(node, messageId, kind) {
-            context.report({
-                node,
-                messageId,
-                data: {
-                    kind
-                }
-            });
-        }
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-
-                scope.variables.forEach(variable => {
-
-                    // Only ESLint global variables have the `writable` key.
-                    const isReadonlyEslintGlobalVariable = variable.writeable === false;
-                    const isWritableEslintGlobalVariable = variable.writeable === true;
-
-                    if (isWritableEslintGlobalVariable) {
-
-                        // Everything is allowed with writable ESLint global variables.
-                        return;
-                    }
-
-                    // Variables exported by "exported" block comments
-                    if (variable.eslintExported) {
-                        return;
-                    }
-
-                    variable.defs.forEach(def => {
-                        const defNode = def.node;
-
-                        if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
-                            if (isReadonlyEslintGlobalVariable) {
-                                report(defNode, "redeclarationOfReadonlyGlobal");
-                            } else {
-                                report(
-                                    defNode,
-                                    "globalNonLexicalBinding",
-                                    def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`
-                                );
-                            }
-                        }
-
-                        if (checkLexicalBindings) {
-                            if (def.type === "ClassName" ||
-                                    (def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const"))) {
-                                if (isReadonlyEslintGlobalVariable) {
-                                    report(defNode, "redeclarationOfReadonlyGlobal");
-                                } else {
-                                    report(
-                                        defNode,
-                                        "globalLexicalBinding",
-                                        def.type === "ClassName" ? "class" : `'${def.parent.kind}'`
-                                    );
-                                }
-                            }
-                        }
-                    });
-                });
-
-                // Undeclared assigned variables.
-                scope.implicit.variables.forEach(variable => {
-                    const scopeVariable = scope.set.get(variable.name);
-                    let messageId;
-
-                    if (scopeVariable) {
-
-                        // ESLint global variable
-                        if (scopeVariable.writeable) {
-                            return;
-                        }
-                        messageId = "assignmentToReadonlyGlobal";
-
-                    } else {
-
-                        // Reference to an unknown variable, possible global leak.
-                        messageId = "globalVariableLeak";
-                    }
-
-                    // def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
-                    variable.defs.forEach(def => {
-                        report(def.node, messageId);
-                    });
-                });
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				lexicalBindings: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow declarations in the global scope",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-implicit-globals",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					lexicalBindings: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			globalNonLexicalBinding:
+				"Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
+			globalLexicalBinding:
+				"Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
+			globalVariableLeak:
+				"Global variable leak, declare the variable if it is intended to be local.",
+			assignmentToReadonlyGlobal:
+				"Unexpected assignment to read-only global variable.",
+			redeclarationOfReadonlyGlobal:
+				"Unexpected redeclaration of read-only global variable.",
+		},
+	},
+
+	create(context) {
+		const [{ lexicalBindings: checkLexicalBindings }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports the node.
+		 * @param {ASTNode} node Node to report.
+		 * @param {string} messageId Id of the message to report.
+		 * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
+		 * @returns {void}
+		 */
+		function report(node, messageId, kind) {
+			context.report({
+				node,
+				messageId,
+				data: {
+					kind,
+				},
+			});
+		}
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+
+				scope.variables.forEach(variable => {
+					// Only ESLint global variables have the `writable` key.
+					const isReadonlyEslintGlobalVariable =
+						variable.writeable === false;
+					const isWritableEslintGlobalVariable =
+						variable.writeable === true;
+
+					if (isWritableEslintGlobalVariable) {
+						// Everything is allowed with writable ESLint global variables.
+						return;
+					}
+
+					// Variables exported by "exported" block comments
+					if (variable.eslintExported) {
+						return;
+					}
+
+					variable.defs.forEach(def => {
+						const defNode = def.node;
+
+						if (
+							def.type === "FunctionName" ||
+							(def.type === "Variable" &&
+								def.parent.kind === "var")
+						) {
+							if (isReadonlyEslintGlobalVariable) {
+								report(
+									defNode,
+									"redeclarationOfReadonlyGlobal",
+								);
+							} else {
+								report(
+									defNode,
+									"globalNonLexicalBinding",
+									def.type === "FunctionName"
+										? "function"
+										: `'${def.parent.kind}'`,
+								);
+							}
+						}
+
+						if (checkLexicalBindings) {
+							if (
+								def.type === "ClassName" ||
+								(def.type === "Variable" &&
+									(def.parent.kind === "let" ||
+										def.parent.kind === "const"))
+							) {
+								if (isReadonlyEslintGlobalVariable) {
+									report(
+										defNode,
+										"redeclarationOfReadonlyGlobal",
+									);
+								} else {
+									report(
+										defNode,
+										"globalLexicalBinding",
+										def.type === "ClassName"
+											? "class"
+											: `'${def.parent.kind}'`,
+									);
+								}
+							}
+						}
+					});
+				});
+
+				// Undeclared assigned variables.
+				scope.implicit.variables.forEach(variable => {
+					const scopeVariable = scope.set.get(variable.name);
+					let messageId;
+
+					if (scopeVariable) {
+						// ESLint global variable
+						if (scopeVariable.writeable) {
+							return;
+						}
+						messageId = "assignmentToReadonlyGlobal";
+					} else {
+						// Reference to an unknown variable, possible global leak.
+						messageId = "globalVariableLeak";
+					}
+
+					// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
+					variable.defs.forEach(def => {
+						report(def.node, messageId);
+					});
+				});
+			},
+		};
+	},
 };

package/lib/rules/no-implied-eval.js

@@ -18,115 +18,143 @@ const { getStaticValue } = require("@eslint-community/eslint-utils");
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of `eval()`-like methods",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-implied-eval"
-        },
-
-        schema: [],
-
-        messages: {
-            impliedEval: "Implied eval. Consider passing a function instead of a string."
-        }
-    },
-
-    create(context) {
-        const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
-        const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks whether a node is evaluated as a string or not.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} True if the node is evaluated as a string.
-         */
-        function isEvaluatedString(node) {
-            if (
-                (node.type === "Literal" && typeof node.value === "string") ||
-                node.type === "TemplateLiteral"
-            ) {
-                return true;
-            }
-            if (node.type === "BinaryExpression" && node.operator === "+") {
-                return isEvaluatedString(node.left) || isEvaluatedString(node.right);
-            }
-            return false;
-        }
-
-        /**
-         * Reports if the `CallExpression` node has evaluated argument.
-         * @param {ASTNode} node A CallExpression to check.
-         * @returns {void}
-         */
-        function reportImpliedEvalCallExpression(node) {
-            const [firstArgument] = node.arguments;
-
-            if (firstArgument) {
-
-                const staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
-                const isStaticString = staticValue && typeof staticValue.value === "string";
-                const isString = isStaticString || isEvaluatedString(firstArgument);
-
-                if (isString) {
-                    context.report({
-                        node,
-                        messageId: "impliedEval"
-                    });
-                }
-            }
-
-        }
-
-        /**
-         * Reports calls of `implied eval` via the global references.
-         * @param {Variable} globalVar A global variable to check.
-         * @returns {void}
-         */
-        function reportImpliedEvalViaGlobal(globalVar) {
-            const { references, name } = globalVar;
-
-            references.forEach(ref => {
-                const identifier = ref.identifier;
-                let node = identifier.parent;
-
-                while (astUtils.isSpecificMemberAccess(node, null, name)) {
-                    node = node.parent;
-                }
-
-                if (astUtils.isSpecificMemberAccess(node, null, EVAL_LIKE_FUNC_PATTERN)) {
-                    const calleeNode = node.parent.type === "ChainExpression" ? node.parent : node;
-                    const parent = calleeNode.parent;
-
-                    if (parent.type === "CallExpression" && parent.callee === calleeNode) {
-                        reportImpliedEvalCallExpression(parent);
-                    }
-                }
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            CallExpression(node) {
-                if (astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)) {
-                    reportImpliedEvalCallExpression(node);
-                }
-            },
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-
-                GLOBAL_CANDIDATES
-                    .map(candidate => astUtils.getVariableByName(globalScope, candidate))
-                    .filter(globalVar => !!globalVar && globalVar.defs.length === 0)
-                    .forEach(reportImpliedEvalViaGlobal);
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow the use of `eval()`-like methods",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-implied-eval",
+		},
+
+		schema: [],
+
+		messages: {
+			impliedEval:
+				"Implied eval. Consider passing a function instead of a string.",
+		},
+	},
+
+	create(context) {
+		const GLOBAL_CANDIDATES = Object.freeze([
+			"global",
+			"window",
+			"globalThis",
+		]);
+		const EVAL_LIKE_FUNC_PATTERN =
+			/^(?:set(?:Interval|Timeout)|execScript)$/u;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Checks whether a node is evaluated as a string or not.
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} True if the node is evaluated as a string.
+		 */
+		function isEvaluatedString(node) {
+			if (
+				(node.type === "Literal" && typeof node.value === "string") ||
+				node.type === "TemplateLiteral"
+			) {
+				return true;
+			}
+			if (node.type === "BinaryExpression" && node.operator === "+") {
+				return (
+					isEvaluatedString(node.left) ||
+					isEvaluatedString(node.right)
+				);
+			}
+			return false;
+		}
+
+		/**
+		 * Reports if the `CallExpression` node has evaluated argument.
+		 * @param {ASTNode} node A CallExpression to check.
+		 * @returns {void}
+		 */
+		function reportImpliedEvalCallExpression(node) {
+			const [firstArgument] = node.arguments;
+
+			if (firstArgument) {
+				const staticValue = getStaticValue(
+					firstArgument,
+					sourceCode.getScope(node),
+				);
+				const isStaticString =
+					staticValue && typeof staticValue.value === "string";
+				const isString =
+					isStaticString || isEvaluatedString(firstArgument);
+
+				if (isString) {
+					context.report({
+						node,
+						messageId: "impliedEval",
+					});
+				}
+			}
+		}
+
+		/**
+		 * Reports calls of `implied eval` via the global references.
+		 * @param {Variable} globalVar A global variable to check.
+		 * @returns {void}
+		 */
+		function reportImpliedEvalViaGlobal(globalVar) {
+			const { references, name } = globalVar;
+
+			references.forEach(ref => {
+				const identifier = ref.identifier;
+				let node = identifier.parent;
+
+				while (astUtils.isSpecificMemberAccess(node, null, name)) {
+					node = node.parent;
+				}
+
+				if (
+					astUtils.isSpecificMemberAccess(
+						node,
+						null,
+						EVAL_LIKE_FUNC_PATTERN,
+					)
+				) {
+					const calleeNode =
+						node.parent.type === "ChainExpression"
+							? node.parent
+							: node;
+					const parent = calleeNode.parent;
+
+					if (
+						parent.type === "CallExpression" &&
+						parent.callee === calleeNode
+					) {
+						reportImpliedEvalCallExpression(parent);
+					}
+				}
+			});
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			CallExpression(node) {
+				if (
+					astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)
+				) {
+					reportImpliedEvalCallExpression(node);
+				}
+			},
+			"Program:exit"(node) {
+				const globalScope = sourceCode.getScope(node);
+
+				GLOBAL_CANDIDATES.map(candidate =>
+					astUtils.getVariableByName(globalScope, candidate),
+				)
+					.filter(
+						globalVar => !!globalVar && globalVar.defs.length === 0,
+					)
+					.forEach(reportImpliedEvalViaGlobal);
+			},
+		};
+	},
 };