eslint 9.27.0 → 9.29.0

package/lib/rules/no-setter-return.js

@@ -10,33 +10,16 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { findVariable } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * 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
-	);
-}
-
 /**
  * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
  * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @param {string} objectName Name of the global object.
  * @param {string} methodName Name of the method.
  * @param {number} index The given position.
@@ -44,7 +27,7 @@ function isGlobalReference(node, scope) {
  */
 function isArgumentOfGlobalMethodCall(
 	node,
-	scope,
+	sourceCode,
 	objectName,
 	methodName,
 	index,
@@ -59,9 +42,8 @@ function isArgumentOfGlobalMethodCall(
 			objectName,
 			methodName,
 		) &&
-		isGlobalReference(
+		sourceCode.isGlobalReference(
 			astUtils.skipChainExpression(callNode.callee).object,
-			scope,
 		)
 	);
 }
@@ -69,21 +51,21 @@ function isArgumentOfGlobalMethodCall(
 /**
  * Determines whether the given node is used as a property descriptor.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a property descriptor.
  */
-function isPropertyDescriptor(node, scope) {
+function isPropertyDescriptor(node, sourceCode) {
 	if (
 		isArgumentOfGlobalMethodCall(
 			node,
-			scope,
+			sourceCode,
 			"Object",
 			"defineProperty",
 			2,
 		) ||
 		isArgumentOfGlobalMethodCall(
 			node,
-			scope,
+			sourceCode,
 			"Reflect",
 			"defineProperty",
 			2,
@@ -101,14 +83,14 @@ function isPropertyDescriptor(node, scope) {
 			grandparent.type === "ObjectExpression" &&
 			(isArgumentOfGlobalMethodCall(
 				grandparent,
-				scope,
+				sourceCode,
 				"Object",
 				"create",
 				1,
 			) ||
 				isArgumentOfGlobalMethodCall(
 					grandparent,
-					scope,
+					sourceCode,
 					"Object",
 					"defineProperties",
 					1,
@@ -124,10 +106,10 @@ function isPropertyDescriptor(node, scope) {
 /**
  * Determines whether the given function node is used as a setter function.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a setter.
  */
-function isSetter(node, scope) {
+function isSetter(node, sourceCode) {
 	const parent = node.parent;
 
 	if (
@@ -144,7 +126,7 @@ function isSetter(node, scope) {
 		parent.value === node &&
 		astUtils.getStaticPropertyName(parent) === "set" &&
 		parent.parent.type === "ObjectExpression" &&
-		isPropertyDescriptor(parent.parent, scope)
+		isPropertyDescriptor(parent.parent, sourceCode)
 	) {
 		// Setter in a property descriptor
 		return true;
@@ -153,21 +135,6 @@ function isSetter(node, scope) {
 	return false;
 }
 
-/**
- * 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;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -200,11 +167,9 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function enterFunction(node) {
-			const outerScope = getOuterScope(sourceCode.getScope(node));
-
 			funcInfo = {
 				upper: funcInfo,
-				isSetter: isSetter(node, outerScope),
+				isSetter: isSetter(node, sourceCode),
 			};
 		}
 

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

@@ -31,17 +31,25 @@ module.exports = {
 
 	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 shouldCheck =
-					!node.init &&
-					node.id.type === "Identifier" &&
-					declaration.kind !== "const" &&
-					!declaration.declare;
-				if (!shouldCheck) {
+				const shouldSkip =
+					node.init ||
+					node.id.type !== "Identifier" ||
+					declaration.kind === "const" ||
+					declaration.declare ||
+					insideDeclareModule;
+				if (shouldSkip) {
 					return;
 				}
 				const [variable] = sourceCode.getDeclaredVariables(node);

package/lib/rules/no-use-before-define.js

@@ -30,6 +30,9 @@ function parseOptions(options) {
 		classes: true,
 		variables: true,
 		allowNamedExports: false,
+		enums: true,
+		typedefs: true,
+		ignoreTypeReferences: true,
 	};
 }
 
@@ -208,6 +211,57 @@ function isEvaluatedDuringInitialization(reference) {
 	return false;
 }
 
+/**
+ * check whether the reference contains a type query.
+ * @param {ASTNode} node Identifier node to check.
+ * @returns {boolean} true if reference contains type query.
+ */
+function referenceContainsTypeQuery(node) {
+	switch (node.type) {
+		case "TSTypeQuery":
+			return true;
+
+		case "TSQualifiedName":
+		case "Identifier":
+			return referenceContainsTypeQuery(node.parent);
+
+		default:
+			// if we find a different node, there's no chance that we're in a TSTypeQuery
+			return false;
+	}
+}
+
+/**
+ * Decorators are transpiled such that the decorator is placed after the class declaration
+ * So it is considered safe
+ * @param {Variable} variable The variable to check.
+ * @param {Reference} reference The reference to check.
+ * @returns {boolean} `true` if the reference is in a class decorator.
+ */
+function isClassRefInClassDecorator(variable, reference) {
+	if (variable.defs[0].type !== "ClassName") {
+		return false;
+	}
+
+	if (
+		!variable.defs[0].node.decorators ||
+		variable.defs[0].node.decorators.length === 0
+	) {
+		return false;
+	}
+
+	for (const deco of variable.defs[0].node.decorators) {
+		if (
+			reference.identifier.range[0] >= deco.range[0] &&
+			reference.identifier.range[1] <= deco.range[1]
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -215,6 +269,8 @@ function isEvaluatedDuringInitialization(reference) {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "problem",
 
 		docs: {
@@ -237,6 +293,9 @@ module.exports = {
 							classes: { type: "boolean" },
 							variables: { type: "boolean" },
 							allowNamedExports: { type: "boolean" },
+							enums: { type: "boolean" },
+							typedefs: { type: "boolean" },
+							ignoreTypeReferences: { type: "boolean" },
 						},
 						additionalProperties: false,
 					},
@@ -250,6 +309,9 @@ module.exports = {
 				functions: true,
 				variables: true,
 				allowNamedExports: false,
+				enums: true,
+				typedefs: true,
+				ignoreTypeReferences: true,
 			},
 		],
 
@@ -310,6 +372,41 @@ module.exports = {
 				return false;
 			}
 
+			if (!options.enums && definitionType === "TSEnumName") {
+				return false;
+			}
+
+			if (!options.typedefs && definitionType === "Type") {
+				return false;
+			}
+
+			if (
+				options.ignoreTypeReferences &&
+				(referenceContainsTypeQuery(identifier) ||
+					identifier.parent.type === "TSTypeReference")
+			) {
+				return false;
+			}
+
+			// skip nested namespace aliases as variable references
+			if (identifier.parent.type === "TSQualifiedName") {
+				let currentNode = identifier.parent;
+
+				while (currentNode.type === "TSQualifiedName") {
+					currentNode = currentNode.left;
+				}
+
+				if (currentNode === identifier) {
+					return true;
+				}
+
+				return false;
+			}
+
+			if (isClassRefInClassDecorator(variable, reference)) {
+				return false;
+			}
+
 			return true;
 		}
 
@@ -326,7 +423,8 @@ module.exports = {
 				if (
 					reference.identifier.range[1] <
 						definitionIdentifier.range[1] ||
-					isEvaluatedDuringInitialization(reference)
+					(isEvaluatedDuringInitialization(reference) &&
+						reference.identifier.parent.type !== "TSTypeReference")
 				) {
 					context.report({
 						node: reference.identifier,

package/lib/rules/no-var.js

@@ -199,6 +199,8 @@ function hasNameDisallowedForLetDeclarations(variable) {
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description: "Require `let` or `const` instead of `var`",
@@ -346,9 +348,19 @@ module.exports = {
 
 		return {
 			"VariableDeclaration:exit"(node) {
-				if (node.kind === "var") {
-					report(node);
+				if (node.kind !== "var") {
+					return;
 				}
+
+				if (
+					node.parent.type === "TSModuleBlock" &&
+					node.parent.parent.type === "TSModuleDeclaration" &&
+					node.parent.parent.global
+				) {
+					return;
+				}
+
+				report(node);
 			},
 		};
 	},