eslint 9.27.0 → 9.29.0

package/lib/rules/class-methods-use-this.js

@@ -111,6 +111,7 @@ module.exports = {
 			switch (node.type) {
 				case "MethodDefinition":
 					return !node.static && node.kind !== "constructor";
+				case "AccessorProperty":
 				case "PropertyDefinition":
 					return !node.static && enforceForClassFields;
 				default:
@@ -218,6 +219,8 @@ module.exports = {
 			/*
 			 * Class field value are implicit functions.
 			 */
+			"AccessorProperty > *.key:exit": pushContext,
+			"AccessorProperty:exit": popContext,
 			"PropertyDefinition > *.key:exit": pushContext,
 			"PropertyDefinition:exit": popContext,
 
@@ -233,6 +236,10 @@ module.exports = {
 			ThisExpression: markThisUsed,
 			Super: markThisUsed,
 			...(enforceForClassFields && {
+				"AccessorProperty > ArrowFunctionExpression.value":
+					enterFunction,
+				"AccessorProperty > ArrowFunctionExpression.value:exit":
+					exitFunction,
 				"PropertyDefinition > ArrowFunctionExpression.value":
 					enterFunction,
 				"PropertyDefinition > ArrowFunctionExpression.value:exit":

package/lib/rules/func-style.js

@@ -11,12 +11,15 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		defaultOptions: [
 			"expression",
 			{
 				allowArrowFunctions: false,
+				allowTypeAnnotation: false,
 				overrides: {},
 			},
 		],
@@ -39,6 +42,9 @@ module.exports = {
 					allowArrowFunctions: {
 						type: "boolean",
 					},
+					allowTypeAnnotation: {
+						type: "boolean",
+					},
 					overrides: {
 						type: "object",
 						properties: {
@@ -60,11 +66,49 @@ module.exports = {
 	},
 
 	create(context) {
-		const [style, { allowArrowFunctions, overrides }] = context.options;
+		const [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] =
+			context.options;
 		const enforceDeclarations = style === "declaration";
 		const { namedExports: exportFunctionStyle } = overrides;
 		const stack = [];
 
+		/**
+		 * Checks if a function declaration is part of an overloaded function
+		 * @param {ASTNode} node The function declaration node to check
+		 * @returns {boolean} True if the function is overloaded
+		 */
+		function isOverloadedFunction(node) {
+			const functionName = node.id.name;
+
+			if (node.parent.type === "ExportNamedDeclaration") {
+				return node.parent.parent.body.some(
+					member =>
+						member.type === "ExportNamedDeclaration" &&
+						member.declaration?.type === "TSDeclareFunction" &&
+						member.declaration.id.name === functionName,
+				);
+			}
+
+			if (node.parent.type === "SwitchCase") {
+				return node.parent.parent.cases.some(switchCase =>
+					switchCase.consequent.some(
+						member =>
+							member.type === "TSDeclareFunction" &&
+							member.id.name === functionName,
+					),
+				);
+			}
+
+			return (
+				Array.isArray(node.parent.body) &&
+				node.parent.body.some(
+					member =>
+						member.type === "TSDeclareFunction" &&
+						member.id.name === functionName,
+				)
+			);
+		}
+
 		const nodesToCheck = {
 			FunctionDeclaration(node) {
 				stack.push(false);
@@ -73,14 +117,16 @@ module.exports = {
 					!enforceDeclarations &&
 					node.parent.type !== "ExportDefaultDeclaration" &&
 					(typeof exportFunctionStyle === "undefined" ||
-						node.parent.type !== "ExportNamedDeclaration")
+						node.parent.type !== "ExportNamedDeclaration") &&
+					!isOverloadedFunction(node)
 				) {
 					context.report({ node, messageId: "expression" });
 				}
 
 				if (
 					node.parent.type === "ExportNamedDeclaration" &&
-					exportFunctionStyle === "expression"
+					exportFunctionStyle === "expression" &&
+					!isOverloadedFunction(node)
 				) {
 					context.report({ node, messageId: "expression" });
 				}
@@ -97,7 +143,8 @@ module.exports = {
 					node.parent.type === "VariableDeclarator" &&
 					(typeof exportFunctionStyle === "undefined" ||
 						node.parent.parent.parent.type !==
-							"ExportNamedDeclaration")
+							"ExportNamedDeclaration") &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 				) {
 					context.report({
 						node: node.parent,
@@ -109,7 +156,8 @@ module.exports = {
 					node.parent.type === "VariableDeclarator" &&
 					node.parent.parent.parent.type ===
 						"ExportNamedDeclaration" &&
-					exportFunctionStyle === "declaration"
+					exportFunctionStyle === "declaration" &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 				) {
 					context.report({
 						node: node.parent,
@@ -144,7 +192,8 @@ module.exports = {
 						enforceDeclarations &&
 						(typeof exportFunctionStyle === "undefined" ||
 							node.parent.parent.parent.type !==
-								"ExportNamedDeclaration")
+								"ExportNamedDeclaration") &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 					) {
 						context.report({
 							node: node.parent,
@@ -155,7 +204,8 @@ module.exports = {
 					if (
 						node.parent.parent.parent.type ===
 							"ExportNamedDeclaration" &&
-						exportFunctionStyle === "declaration"
+						exportFunctionStyle === "declaration" &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 					) {
 						context.report({
 							node: node.parent,

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

@@ -5,6 +5,12 @@
 
 "use strict";
 
+const ASSIGNMENT_NODES = new Set([
+	"AssignmentExpression",
+	"ForInStatement",
+	"ForOfStatement",
+]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -142,27 +148,37 @@ module.exports = {
 							}
 						}
 					});
-				});
 
-				// Undeclared assigned variables.
-				scope.implicit.variables.forEach(variable => {
-					const scopeVariable = scope.set.get(variable.name);
-					let messageId;
+					if (
+						isReadonlyEslintGlobalVariable &&
+						variable.defs.length === 0
+					) {
+						variable.references.forEach(reference => {
+							if (reference.isWrite() && !reference.isRead()) {
+								let assignmentParent =
+									reference.identifier.parent;
+
+								while (
+									assignmentParent &&
+									!ASSIGNMENT_NODES.has(assignmentParent.type)
+								) {
+									assignmentParent = assignmentParent.parent;
+								}
 
-					if (scopeVariable) {
-						// ESLint global variable
-						if (scopeVariable.writeable) {
-							return;
-						}
-						messageId = "assignmentToReadonlyGlobal";
-					} else {
-						// Reference to an unknown variable, possible global leak.
-						messageId = "globalVariableLeak";
+								report(
+									assignmentParent ?? reference.identifier,
+									"assignmentToReadonlyGlobal",
+								);
+							}
+						});
 					}
+				});
 
+				// Undeclared assigned variables.
+				scope.implicit.variables.forEach(variable => {
 					// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
 					variable.defs.forEach(def => {
-						report(def.node, messageId);
+						report(def.node, "globalVariableLeak");
 					});
 				});
 			},

package/lib/rules/no-magic-numbers.js

@@ -26,10 +26,73 @@ function normalizeIgnoreValue(x) {
 	return x;
 }
 
+/**
+ * Checks if the node parent is a TypeScript enum member
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node parent is a TypeScript enum member
+ */
+function isParentTSEnumDeclaration(node) {
+	return node.parent.type === "TSEnumMember";
+}
+
+/**
+ * Checks if the node is a valid TypeScript numeric literal type.
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node is a TypeScript numeric literal type
+ */
+function isTSNumericLiteralType(node) {
+	let ancestor = node.parent;
+
+	// Go up while we're part of a type union
+	while (ancestor.parent.type === "TSUnionType") {
+		ancestor = ancestor.parent;
+	}
+
+	// Check if the final ancestor is in a type alias declaration
+	return ancestor.parent.type === "TSTypeAliasDeclaration";
+}
+
+/**
+ * Checks if the node parent is a readonly class property
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node parent is a readonly class property
+ */
+function isParentTSReadonlyPropertyDefinition(node) {
+	if (node.parent?.type === "PropertyDefinition" && node.parent.readonly) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Checks if the node is part of a type indexed access (eg. Foo[4])
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node is part of an indexed access
+ */
+function isAncestorTSIndexedAccessType(node) {
+	let ancestor = node.parent;
+
+	/*
+	 * Go up another level while we're part of a type union (eg. 1 | 2) or
+	 * intersection (eg. 1 & 2)
+	 */
+	while (
+		ancestor.parent.type === "TSUnionType" ||
+		ancestor.parent.type === "TSIntersectionType"
+	) {
+		ancestor = ancestor.parent;
+	}
+
+	return ancestor.parent.type === "TSIndexedAccessType";
+}
+
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description: "Disallow magic numbers",
@@ -75,6 +138,22 @@ module.exports = {
 						type: "boolean",
 						default: false,
 					},
+					ignoreEnums: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreNumericLiteralTypes: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreReadonlyClassProperties: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreTypeIndexes: {
+						type: "boolean",
+						default: false,
+					},
 				},
 				additionalProperties: false,
 			},
@@ -94,7 +173,12 @@ module.exports = {
 			ignoreArrayIndexes = !!config.ignoreArrayIndexes,
 			ignoreDefaultValues = !!config.ignoreDefaultValues,
 			ignoreClassFieldInitialValues =
-				!!config.ignoreClassFieldInitialValues;
+				!!config.ignoreClassFieldInitialValues,
+			ignoreEnums = !!config.ignoreEnums,
+			ignoreNumericLiteralTypes = !!config.ignoreNumericLiteralTypes,
+			ignoreReadonlyClassProperties =
+				!!config.ignoreReadonlyClassProperties,
+			ignoreTypeIndexes = !!config.ignoreTypeIndexes;
 
 		const okTypes = detectObjects
 			? []
@@ -217,14 +301,15 @@ module.exports = {
 				let value;
 				let raw;
 
-				// Treat unary minus as a part of the number
+				// Treat unary minus/plus as a part of the number
 				if (
 					node.parent.type === "UnaryExpression" &&
-					node.parent.operator === "-"
+					["-", "+"].includes(node.parent.operator)
 				) {
 					fullNumberNode = node.parent;
-					value = -node.value;
-					raw = `-${node.raw}`;
+					value =
+						node.parent.operator === "-" ? -node.value : node.value;
+					raw = `${node.parent.operator}${node.raw}`;
 				} else {
 					fullNumberNode = node;
 					value = node.value;
@@ -239,6 +324,14 @@ module.exports = {
 					(ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
 					(ignoreClassFieldInitialValues &&
 						isClassFieldInitialValue(fullNumberNode)) ||
+					(ignoreEnums &&
+						isParentTSEnumDeclaration(fullNumberNode)) ||
+					(ignoreNumericLiteralTypes &&
+						isTSNumericLiteralType(fullNumberNode)) ||
+					(ignoreTypeIndexes &&
+						isAncestorTSIndexedAccessType(fullNumberNode)) ||
+					(ignoreReadonlyClassProperties &&
+						isParentTSReadonlyPropertyDefinition(fullNumberNode)) ||
 					isParseIntRadix(fullNumberNode) ||
 					isJSXNumber(fullNumberNode) ||
 					(ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))

package/lib/rules/no-promise-executor-return.js

@@ -9,7 +9,6 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -21,43 +20,13 @@ const functionTypesToCheck = new Set([
 	"FunctionExpression",
 ]);
 
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-	const variable = findVariable(scope, node);
-
-	return (
-		variable !== null &&
-		variable.scope.type === "global" &&
-		variable.defs.length === 0
-	);
-}
-
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-	const upper = scope.upper;
-
-	if (upper.type === "function-expression-name") {
-		return upper.upper;
-	}
-	return upper;
-}
-
 /**
  * Determines whether the given function node is used as a Promise executor.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Function's own scope.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a Promise executor.
  */
-function isPromiseExecutor(node, scope) {
+function isPromiseExecutor(node, sourceCode) {
 	const parent = node.parent;
 
 	return (
@@ -65,7 +34,7 @@ function isPromiseExecutor(node, scope) {
 		parent.arguments[0] === node &&
 		parent.callee.type === "Identifier" &&
 		parent.callee.name === "Promise" &&
-		isGlobalReference(parent.callee, getOuterScope(scope))
+		sourceCode.isGlobalReference(parent.callee)
 	);
 }
 
@@ -203,7 +172,7 @@ module.exports = {
 					upper: funcInfo,
 					shouldCheck:
 						functionTypesToCheck.has(node.type) &&
-						isPromiseExecutor(node, sourceCode.getScope(node)),
+						isPromiseExecutor(node, sourceCode),
 				};
 
 				if (

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

@@ -4,6 +4,18 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const TYPE_NODES = new Set([
+	"TSTypeReference",
+	"TSInterfaceHeritage",
+	"TSClassImplements",
+	"TSTypeQuery",
+	"TSQualifiedName",
+]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -11,6 +23,8 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		docs: {
@@ -100,6 +114,18 @@ module.exports = {
 			return Object.hasOwn(restrictedGlobalMessages, name);
 		}
 
+		/**
+		 * Check if the given reference occurs within a TypeScript type context.
+		 * @param {Reference} reference The variable reference to check.
+		 * @returns {boolean} Whether the reference is in a type context.
+		 * @private
+		 */
+		function isInTypeContext(reference) {
+			const parent = reference.identifier.parent;
+
+			return TYPE_NODES.has(parent.type);
+		}
+
 		return {
 			Program(node) {
 				const scope = sourceCode.getScope(node);
@@ -107,13 +133,20 @@ module.exports = {
 				// Report variables declared elsewhere (ex: variables defined as "global" by eslint)
 				scope.variables.forEach(variable => {
 					if (!variable.defs.length && isRestricted(variable.name)) {
-						variable.references.forEach(reportReference);
+						variable.references.forEach(reference => {
+							if (!isInTypeContext(reference)) {
+								reportReference(reference);
+							}
+						});
 					}
 				});
 
 				// Report variables not declared at all
 				scope.through.forEach(reference => {
-					if (isRestricted(reference.identifier.name)) {
+					if (
+						isRestricted(reference.identifier.name) &&
+						!isInTypeContext(reference)
+					) {
 						reportReference(reference);
 					}
 				});

package/lib/rules/no-restricted-properties.js

@@ -40,6 +40,13 @@ module.exports = {
 						},
 						uniqueItems: true,
 					},
+					allowProperties: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
 					message: {
 						type: "string",
 					},
@@ -53,7 +60,10 @@ module.exports = {
 					},
 				],
 				not: {
-					required: ["allowObjects", "object"],
+					anyOf: [
+						{ required: ["allowObjects", "object"] },
+						{ required: ["allowProperties", "property"] },
+					],
 				},
 				additionalProperties: false,
 			},
@@ -92,6 +102,7 @@ module.exports = {
 				});
 			} else if (typeof propertyName === "undefined") {
 				globallyRestrictedObjects.set(objectName, {
+					allowProperties: option.allowProperties,
 					message: option.message,
 				});
 			} else {
@@ -106,17 +117,17 @@ module.exports = {
 		});
 
 		/**
-		 * Checks if an object name is in the allowed objects list.
-		 * @param {string} objectName The name of the object to check
-		 * @param {string[]} [allowObjects] The list of objects to allow
-		 * @returns {boolean} True if the object is allowed, false otherwise
+		 * Checks if a name is in the allowed list.
+		 * @param {string} name The name to check
+		 * @param {string[]} [allowedList] The list of allowed names
+		 * @returns {boolean} True if the name is allowed, false otherwise
 		 */
-		function isAllowedObject(objectName, allowObjects) {
-			if (!allowObjects) {
+		function isAllowed(name, allowedList) {
+			if (!allowedList) {
 				return false;
 			}
 
-			return allowObjects.includes(objectName);
+			return allowedList.includes(name);
 		}
 
 		/**
@@ -137,7 +148,10 @@ module.exports = {
 			const globalMatchedProperty =
 				globallyRestrictedProperties.get(propertyName);
 
-			if (matchedObjectProperty) {
+			if (
+				matchedObjectProperty &&
+				!isAllowed(propertyName, matchedObjectProperty.allowProperties)
+			) {
 				const message = matchedObjectProperty.message
 					? ` ${matchedObjectProperty.message}`
 					: "";
@@ -153,7 +167,7 @@ module.exports = {
 				});
 			} else if (
 				globalMatchedProperty &&
-				!isAllowedObject(objectName, globalMatchedProperty.allowObjects)
+				!isAllowed(objectName, globalMatchedProperty.allowObjects)
 			) {
 				const message = globalMatchedProperty.message
 					? ` ${globalMatchedProperty.message}`