eslint 9.26.0 → 9.28.0

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-shadow.js

@@ -24,6 +24,23 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
 const SENTINEL_TYPE =
 	/^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
 
+// TS-specific node types
+const TYPES_HOISTED_NODES = new Set([
+	"TSInterfaceDeclaration",
+	"TSTypeAliasDeclaration",
+]);
+
+// TS-specific function variable def types
+const ALLOWED_FUNCTION_VARIABLE_DEF_TYPES = new Set([
+	"TSCallSignatureDeclaration",
+	"TSFunctionType",
+	"TSMethodSignature",
+	"TSEmptyBodyFunctionExpression",
+	"TSDeclareFunction",
+	"TSConstructSignatureDeclaration",
+	"TSConstructorType",
+]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -32,6 +49,8 @@ const SENTINEL_TYPE =
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		defaultOptions: [
 			{
@@ -39,6 +58,8 @@ module.exports = {
 				builtinGlobals: false,
 				hoist: "functions",
 				ignoreOnInitialization: false,
+				ignoreTypeValueShadow: true,
+				ignoreFunctionTypeParameterNameValueShadow: true,
 			},
 		],
 
@@ -54,7 +75,15 @@ module.exports = {
 				type: "object",
 				properties: {
 					builtinGlobals: { type: "boolean" },
-					hoist: { enum: ["all", "functions", "never"] },
+					hoist: {
+						enum: [
+							"all",
+							"functions",
+							"never",
+							"types",
+							"functions-and-types",
+						],
+					},
 					allow: {
 						type: "array",
 						items: {
@@ -62,6 +91,10 @@ module.exports = {
 						},
 					},
 					ignoreOnInitialization: { type: "boolean" },
+					ignoreTypeValueShadow: { type: "boolean" },
+					ignoreFunctionTypeParameterNameValueShadow: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -75,10 +108,112 @@ module.exports = {
 	},
 
 	create(context) {
-		const [{ builtinGlobals, hoist, allow, ignoreOnInitialization }] =
-			context.options;
+		const [
+			{
+				builtinGlobals,
+				hoist,
+				allow,
+				ignoreOnInitialization,
+				ignoreTypeValueShadow,
+				ignoreFunctionTypeParameterNameValueShadow,
+			},
+		] = context.options;
 		const sourceCode = context.sourceCode;
 
+		/**
+		 * Check if a scope is a TypeScript module augmenting the global namespace.
+		 * @param {Scope} scope The scope to check
+		 * @returns {boolean} Whether the scope is a global augmentation
+		 */
+		function isGlobalAugmentation(scope) {
+			return (
+				scope.block.kind === "global" ||
+				(!!scope.upper && isGlobalAugmentation(scope.upper))
+			);
+		}
+
+		/**
+		 * Check if variable is a `this` parameter.
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether the variable is a this parameter
+		 */
+		function isThisParam(variable) {
+			return variable.name === "this";
+		}
+
+		/**
+		 * Checks if type and value shadows each other
+		 * @param {Object} variable The variable to check
+		 * @param {Object} shadowedVariable The shadowed variable
+		 * @returns {boolean} Whether it's a type/value shadow case to ignore
+		 */
+		function isTypeValueShadow(variable, shadowedVariable) {
+			if (ignoreTypeValueShadow !== true) {
+				return false;
+			}
+
+			if (!("isValueVariable" in variable)) {
+				return false;
+			}
+
+			const firstDefinition = shadowedVariable.defs[0];
+
+			// Check if shadowedVariable is a type import
+			const isTypeImport =
+				firstDefinition &&
+				firstDefinition.parent?.type === "ImportDeclaration" &&
+				(firstDefinition.parent.importKind === "type" ||
+					firstDefinition.parent.specifiers.some(
+						s => s.importKind === "type",
+					));
+
+			const isShadowedValue =
+				!firstDefinition ||
+				(isTypeImport ? false : shadowedVariable.isValueVariable);
+
+			return variable.isValueVariable !== isShadowedValue;
+		}
+
+		/**
+		 * Checks if it's a function type parameter shadow
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether it's a function type parameter shadow case to ignore
+		 */
+		function isFunctionTypeParameterNameValueShadow(variable) {
+			if (ignoreFunctionTypeParameterNameValueShadow !== true) {
+				return false;
+			}
+
+			return variable.defs.some(def =>
+				ALLOWED_FUNCTION_VARIABLE_DEF_TYPES.has(def.node.type),
+			);
+		}
+
+		/**
+		 * Checks if the variable is a generic of a static method
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether the variable is a generic of a static method
+		 */
+		function isTypeParameterOfStaticMethod(variable) {
+			const typeParameter = variable.identifiers[0].parent;
+			const typeParameterDecl = typeParameter.parent;
+			if (typeParameterDecl.type !== "TSTypeParameterDeclaration") {
+				return false;
+			}
+			const functionExpr = typeParameterDecl.parent;
+			const methodDefinition = functionExpr.parent;
+			return methodDefinition.static;
+		}
+
+		/**
+		 * Checks for static method generic shadowing class generic
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether it's a static method generic shadowing class generic
+		 */
+		function isGenericOfAStaticMethodShadow(variable) {
+			return isTypeParameterOfStaticMethod(variable);
+		}
+
 		/**
 		 * Checks whether or not a given location is inside of the range of a given node.
 		 * @param {ASTNode} node An node to check.
@@ -114,7 +249,7 @@ module.exports = {
 		function getOuterScope(scope) {
 			const upper = scope.upper;
 
-			if (upper.type === "function-expression-name") {
+			if (upper && upper.type === "function-expression-name") {
 				return upper.upper;
 			}
 			return upper;
@@ -284,6 +419,21 @@ module.exports = {
 			const inner = getNameRange(variable);
 			const outer = getNameRange(scopeVar);
 
+			if (!outer || inner[1] >= outer[0]) {
+				return false;
+			}
+
+			if (hoist === "types") {
+				return !TYPES_HOISTED_NODES.has(outerDef.node.type);
+			}
+
+			if (hoist === "functions-and-types") {
+				return (
+					outerDef.node.type !== "FunctionDeclaration" &&
+					!TYPES_HOISTED_NODES.has(outerDef.node.type)
+				);
+			}
+
 			return (
 				inner &&
 				outer &&
@@ -295,12 +445,111 @@ module.exports = {
 			);
 		}
 
+		/**
+		 * Checks if the initialization of a variable has the declare modifier in a
+		 * definition file.
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether the variable is declared in a definition file
+		 */
+		function isDeclareInDTSFile(variable) {
+			const fileName = context.filename;
+			if (
+				!fileName.endsWith(".d.ts") &&
+				!fileName.endsWith(".d.cts") &&
+				!fileName.endsWith(".d.mts")
+			) {
+				return false;
+			}
+			return variable.defs.some(
+				def =>
+					(def.type === "Variable" && def.parent.declare) ||
+					(def.type === "ClassName" && def.node.declare) ||
+					(def.type === "TSEnumName" && def.node.declare) ||
+					(def.type === "TSModuleName" && def.node.declare),
+			);
+		}
+
+		/**
+		 * Checks if a variable is a duplicate of an enum name in the enum scope
+		 * @param {Object} variable The variable to check
+		 * @returns {boolean} Whether it's a duplicate enum name variable
+		 */
+		function isDuplicatedEnumNameVariable(variable) {
+			const block = variable.scope.block;
+
+			return (
+				block.type === "TSEnumDeclaration" &&
+				block.id === variable.identifiers[0]
+			);
+		}
+
+		/**
+		 * Check if this is an external module declaration merging with a type import
+		 * @param {Scope} scope Current scope
+		 * @param {Object} variable Current variable
+		 * @param {Object} shadowedVariable Shadowed variable
+		 * @returns {boolean} Whether it's an external declaration merging
+		 */
+		function isExternalDeclarationMerging(
+			scope,
+			variable,
+			shadowedVariable,
+		) {
+			const firstDefinition = shadowedVariable.defs[0];
+
+			if (!firstDefinition || !firstDefinition.parent) {
+				return false;
+			}
+
+			// Check if the shadowed variable is a type import
+			const isTypeImport =
+				firstDefinition.parent.type === "ImportDeclaration" &&
+				(firstDefinition.parent.importKind === "type" ||
+					firstDefinition.parent.specifiers?.some(
+						s =>
+							s.type === "ImportSpecifier" &&
+							s.importKind === "type" &&
+							s.local.name === shadowedVariable.name,
+					));
+
+			if (!isTypeImport) {
+				return false;
+			}
+
+			// Check if the current variable is within a module declaration
+			const moduleDecl = findSelfOrAncestor(
+				variable.identifiers[0]?.parent,
+				node => node.type === "TSModuleDeclaration",
+			);
+
+			if (!moduleDecl) {
+				return false;
+			}
+
+			/*
+			 * Module declaration merging should only happen within the same module
+			 * Check if the module name matches the import source
+			 */
+			const importSource = firstDefinition.parent.source.value;
+			const moduleName =
+				moduleDecl.id.type === "Literal"
+					? moduleDecl.id.value
+					: moduleDecl.id.name;
+
+			return importSource === moduleName;
+		}
+
 		/**
 		 * Checks the current context for shadowed variables.
 		 * @param {Scope} scope Fixme
 		 * @returns {void}
 		 */
 		function checkForShadows(scope) {
+			// ignore global augmentation
+			if (isGlobalAugmentation(scope)) {
+				return;
+			}
+
 			const variables = scope.variables;
 
 			for (let i = 0; i < variables.length; ++i) {
@@ -310,7 +559,10 @@ module.exports = {
 				if (
 					variable.identifiers.length === 0 ||
 					isDuplicatedClassNameVariable(variable) ||
-					isAllowed(variable)
+					isDuplicatedEnumNameVariable(variable) ||
+					isAllowed(variable) ||
+					isDeclareInDTSFile(variable) ||
+					isThisParam(variable)
 				) {
 					continue;
 				}
@@ -330,7 +582,11 @@ module.exports = {
 						ignoreOnInitialization &&
 						isInitPatternNode(variable, shadowed)
 					) &&
-					!(hoist !== "all" && isInTdz(variable, shadowed))
+					!(hoist !== "all" && isInTdz(variable, shadowed)) &&
+					!isTypeValueShadow(variable, shadowed) &&
+					!isFunctionTypeParameterNameValueShadow(variable) &&
+					!isGenericOfAStaticMethodShadow(variable, shadowed) &&
+					!isExternalDeclarationMerging(scope, variable, shadowed)
 				) {
 					const location = getDeclaredLocation(shadowed);
 					const messageId = location.global

package/lib/rules/no-unassigned-vars.js

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Rule to flag variables that are never assigned
+ * @author Jacob Bandes-Storch <https://github.com/jtbandes>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
+
+		docs: {
+			description:
+				"Disallow `let` or `var` variables that are read but never assigned",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-unassigned-vars",
+		},
+
+		schema: [],
+		messages: {
+			unassigned:
+				"'{{name}}' is always 'undefined' because it's never assigned.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let insideDeclareModule = false;
+
+		return {
+			"TSModuleDeclaration[declare=true]"() {
+				insideDeclareModule = true;
+			},
+			"TSModuleDeclaration[declare=true]:exit"() {
+				insideDeclareModule = false;
+			},
+			VariableDeclarator(node) {
+				/** @type {import('estree').VariableDeclaration} */
+				const declaration = node.parent;
+				const shouldSkip =
+					node.init ||
+					node.id.type !== "Identifier" ||
+					declaration.kind === "const" ||
+					declaration.declare ||
+					insideDeclareModule;
+				if (shouldSkip) {
+					return;
+				}
+				const [variable] = sourceCode.getDeclaredVariables(node);
+				if (!variable) {
+					return;
+				}
+				let hasRead = false;
+				for (const reference of variable.references) {
+					if (reference.isWrite()) {
+						return;
+					}
+					if (reference.isRead()) {
+						hasRead = true;
+					}
+				}
+				if (!hasRead) {
+					// Variables that are never read should be flagged by no-unused-vars instead
+					return;
+				}
+				context.report({
+					node,
+					messageId: "unassigned",
+					data: { name: node.id.name },
+				});
+			},
+		};
+	},
+};