eslint 9.30.1 → 9.32.0

package/lib/rule-tester/rule-tester.js

@@ -1236,35 +1236,34 @@ class RuleTester {
 							);
 						}
 
+						const actualLocation = {};
+						const expectedLocation = {};
+
 						if (hasOwnProperty(error, "line")) {
-							assert.strictEqual(
-								message.line,
-								error.line,
-								`Error line should be ${error.line}`,
-							);
+							actualLocation.line = message.line;
+							expectedLocation.line = error.line;
 						}
 
 						if (hasOwnProperty(error, "column")) {
-							assert.strictEqual(
-								message.column,
-								error.column,
-								`Error column should be ${error.column}`,
-							);
+							actualLocation.column = message.column;
+							expectedLocation.column = error.column;
 						}
 
 						if (hasOwnProperty(error, "endLine")) {
-							assert.strictEqual(
-								message.endLine,
-								error.endLine,
-								`Error endLine should be ${error.endLine}`,
-							);
+							actualLocation.endLine = message.endLine;
+							expectedLocation.endLine = error.endLine;
 						}
 
 						if (hasOwnProperty(error, "endColumn")) {
-							assert.strictEqual(
-								message.endColumn,
-								error.endColumn,
-								`Error endColumn should be ${error.endColumn}`,
+							actualLocation.endColumn = message.endColumn;
+							expectedLocation.endColumn = error.endColumn;
+						}
+
+						if (Object.keys(expectedLocation).length > 0) {
+							assert.deepStrictEqual(
+								actualLocation,
+								expectedLocation,
+								"Actual error location does not match expected error location.",
 							);
 						}
 

package/lib/rules/accessor-pairs.js

@@ -148,6 +148,7 @@ module.exports = {
 
 		defaultOptions: [
 			{
+				enforceForTSTypes: false,
 				enforceForClassMembers: true,
 				getWithoutSet: false,
 				setWithoutGet: true,
@@ -174,6 +175,9 @@ module.exports = {
 					enforceForClassMembers: {
 						type: "boolean",
 					},
+					enforceForTSTypes: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -190,6 +194,8 @@ module.exports = {
 				"Setter is not present for {{ name }}.",
 			missingGetterInClass: "Getter is not present for class {{ name }}.",
 			missingSetterInClass: "Setter is not present for class {{ name }}.",
+			missingGetterInType: "Getter is not present for type {{ name }}.",
+			missingSetterInType: "Setter is not present for type {{ name }}.",
 		},
 	},
 	create(context) {
@@ -198,6 +204,7 @@ module.exports = {
 				getWithoutSet: checkGetWithoutSet,
 				setWithoutGet: checkSetWithoutGet,
 				enforceForClassMembers,
+				enforceForTSTypes,
 			},
 		] = context.options;
 		const sourceCode = context.sourceCode;
@@ -228,6 +235,15 @@ module.exports = {
 						name: astUtils.getFunctionNameWithKind(node.value),
 					},
 				});
+			} else if (node.type === "TSMethodSignature") {
+				context.report({
+					node,
+					messageId: `${messageKind}InType`,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					data: {
+						name: astUtils.getFunctionNameWithKind(node),
+					},
+				});
 			} else {
 				context.report({
 					node,
@@ -371,6 +387,22 @@ module.exports = {
 			checkList(methodDefinitions.filter(m => !m.static));
 		}
 
+		/**
+		 * Checks the given type.
+		 * @param {ASTNode} node `TSTypeLiteral` or `TSInterfaceBody` node to check.
+		 * @returns {void}
+		 * @private
+		 */
+		function checkType(node) {
+			const members =
+				node.type === "TSTypeLiteral" ? node.members : node.body;
+			const methodDefinitions = members.filter(
+				m => m.type === "TSMethodSignature",
+			);
+
+			checkList(methodDefinitions);
+		}
+
 		const listeners = {};
 
 		if (checkSetWithoutGet || checkGetWithoutSet) {
@@ -378,6 +410,9 @@ module.exports = {
 			if (enforceForClassMembers) {
 				listeners.ClassBody = checkClassBody;
 			}
+			if (enforceForTSTypes) {
+				listeners["TSTypeLiteral, TSInterfaceBody"] = checkType;
+			}
 		}
 
 		return listeners;

package/lib/rules/grouped-accessor-pairs.js

@@ -87,6 +87,8 @@ function isAccessorKind(node) {
 	return node.kind === "get" || node.kind === "set";
 }
 
+const DEFAULT_ORDER = "anyOrder";
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -96,7 +98,7 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
-		defaultOptions: ["anyOrder"],
+		defaultOptions: [DEFAULT_ORDER],
 
 		docs: {
 			description:
@@ -106,8 +108,15 @@ module.exports = {
 		},
 
 		schema: [
+			{ enum: ["anyOrder", "getBeforeSet", "setBeforeGet"] },
 			{
-				enum: ["anyOrder", "getBeforeSet", "setBeforeGet"],
+				type: "object",
+				properties: {
+					enforceForTSTypes: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
 			},
 		],
 
@@ -120,7 +129,9 @@ module.exports = {
 	},
 
 	create(context) {
-		const [order] = context.options;
+		const order = context.options[0] ?? DEFAULT_ORDER;
+		const enforceForTSTypes =
+			context.options[1]?.enforceForTSTypes ?? false;
 		const sourceCode = context.sourceCode;
 
 		/**
@@ -135,13 +146,22 @@ module.exports = {
 			context.report({
 				node: latterNode,
 				messageId,
-				loc: astUtils.getFunctionHeadLoc(latterNode.value, sourceCode),
+				loc: astUtils.getFunctionHeadLoc(
+					latterNode.type !== "TSMethodSignature"
+						? latterNode.value
+						: latterNode,
+					sourceCode,
+				),
 				data: {
 					formerName: astUtils.getFunctionNameWithKind(
-						formerNode.value,
+						formerNode.type !== "TSMethodSignature"
+							? formerNode.value
+							: formerNode,
 					),
 					latterName: astUtils.getFunctionNameWithKind(
-						latterNode.value,
+						latterNode.type !== "TSMethodSignature"
+							? latterNode.value
+							: latterNode,
 					),
 				},
 			});
@@ -232,6 +252,16 @@ module.exports = {
 					n => n.type === "MethodDefinition" && n.static,
 				);
 			},
+			"TSTypeLiteral, TSInterfaceBody"(node) {
+				if (enforceForTSTypes) {
+					checkList(
+						node.type === "TSTypeLiteral"
+							? node.members
+							: node.body,
+						n => n.type === "TSMethodSignature",
+					);
+				}
+			},
 		};
 	},
 };

package/lib/rules/init-declarations.js

@@ -9,6 +9,8 @@
 // Helpers
 //------------------------------------------------------------------------------
 
+const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
+
 /**
  * Checks whether or not a given node is a for loop.
  * @param {ASTNode} block A node to check.
@@ -147,7 +149,7 @@ module.exports = {
 						messageId = "initialized";
 					} else if (
 						mode === MODE_NEVER &&
-						kind !== "const" &&
+						!CONSTANT_BINDINGS.has(kind) &&
 						initialized &&
 						!isIgnoredForLoop
 					) {

package/lib/rules/no-await-in-loop.js

@@ -41,7 +41,10 @@ function isLooped(node, parent) {
 
 		case "ForOfStatement":
 		case "ForInStatement":
-			return node === parent.body;
+			return (
+				node === parent.body ||
+				(node === parent.left && node.kind === "await using")
+			);
 
 		case "WhileStatement":
 		case "DoWhileStatement":
@@ -76,6 +79,13 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function validate(awaitNode) {
+			if (
+				awaitNode.type === "VariableDeclaration" &&
+				awaitNode.kind !== "await using"
+			) {
+				return;
+			}
+
 			if (awaitNode.type === "ForOfStatement" && !awaitNode.await) {
 				return;
 			}
@@ -99,6 +109,7 @@ module.exports = {
 		return {
 			AwaitExpression: validate,
 			ForOfStatement: validate,
+			VariableDeclaration: validate,
 		};
 	},
 };

package/lib/rules/no-const-assign.js

@@ -5,8 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -17,7 +27,8 @@ module.exports = {
 		type: "problem",
 
 		docs: {
-			description: "Disallow reassigning `const` variables",
+			description:
+				"Disallow reassigning `const`, `using`, and `await using` variables",
 			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/no-const-assign",
 		},
@@ -51,7 +62,7 @@ module.exports = {
 
 		return {
 			VariableDeclaration(node) {
-				if (node.kind === "const") {
+				if (CONSTANT_BINDINGS.has(node.kind)) {
 					sourceCode
 						.getDeclaredVariables(node)
 						.forEach(checkVariable);

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

@@ -32,6 +32,7 @@ module.exports = {
 		messages: {
 			impliedEval:
 				"Implied eval. Consider passing a function instead of a string.",
+			execScript: "Implied eval. Do not use execScript().",
 		},
 	},
 
@@ -85,9 +86,14 @@ module.exports = {
 					isStaticString || isEvaluatedString(firstArgument);
 
 				if (isString) {
+					const calleeName =
+						node.callee.type === "Identifier"
+							? node.callee.name
+							: astUtils.getStaticPropertyName(node.callee);
+					const isExecScript = calleeName === "execScript";
 					context.report({
 						node,
-						messageId: "impliedEval",
+						messageId: isExecScript ? "execScript" : "impliedEval",
 					});
 				}
 			}
@@ -139,7 +145,11 @@ module.exports = {
 		return {
 			CallExpression(node) {
 				if (
-					astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)
+					astUtils.isSpecificId(
+						node.callee,
+						EVAL_LIKE_FUNC_PATTERN,
+					) &&
+					sourceCode.isGlobalReference(node.callee)
 				) {
 					reportImpliedEvalCallExpression(node);
 				}

package/lib/rules/no-loop-func.js

@@ -9,6 +9,8 @@
 // Helpers
 //------------------------------------------------------------------------------
 
+const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
+
 /**
  * Identifies is a node is a FunctionExpression which is part of an IIFE
  * @param {ASTNode} node Node to test
@@ -148,8 +150,8 @@ module.exports = {
 					? declaration.kind
 					: "";
 
-			// Variables which are declared by `const` is safe.
-			if (kind === "const") {
+			// Constant variables are safe.
+			if (CONSTANT_BINDINGS.has(kind)) {
 				return true;
 			}
 

package/lib/rules/no-undef-init.js

@@ -5,8 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -49,7 +59,7 @@ module.exports = {
 
 				if (
 					init === "undefined" &&
-					node.parent.kind !== "const" &&
+					!CONSTANT_BINDINGS.has(node.parent.kind) &&
 					!shadowed
 				) {
 					context.report({

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

@@ -88,6 +88,9 @@ module.exports = {
 							ignoreClassWithStaticInitBlock: {
 								type: "boolean",
 							},
+							ignoreUsingDeclarations: {
+								type: "boolean",
+							},
 							reportUsedIgnorePattern: {
 								type: "boolean",
 							},
@@ -119,6 +122,7 @@ module.exports = {
 			ignoreRestSiblings: false,
 			caughtErrors: "all",
 			ignoreClassWithStaticInitBlock: false,
+			ignoreUsingDeclarations: false,
 			reportUsedIgnorePattern: false,
 		};
 
@@ -137,6 +141,9 @@ module.exports = {
 				config.ignoreClassWithStaticInitBlock =
 					firstOption.ignoreClassWithStaticInitBlock ||
 					config.ignoreClassWithStaticInitBlock;
+				config.ignoreUsingDeclarations =
+					firstOption.ignoreUsingDeclarations ||
+					config.ignoreUsingDeclarations;
 				config.reportUsedIgnorePattern =
 					firstOption.reportUsedIgnorePattern ||
 					config.reportUsedIgnorePattern;
@@ -357,6 +364,22 @@ module.exports = {
 			return false;
 		}
 
+		/**
+		 * Determines if a given variable uses the explicit resource management protocol.
+		 * @param {Variable} variable eslint-scope variable object.
+		 * @returns {boolean} True if the variable is declared with "using" or "await using"
+		 * @private
+		 */
+		function usesExplicitResourceManagement(variable) {
+			const [definition] = variable.defs;
+
+			return (
+				definition?.type === "Variable" &&
+				(definition.parent.kind === "using" ||
+					definition.parent.kind === "await using")
+			);
+		}
+
 		/**
 		 * Checks whether a node is a sibling of the rest property or not.
 		 * @param {ASTNode} node a node to check
@@ -922,6 +945,10 @@ module.exports = {
 					if (
 						!isUsedVariable(variable) &&
 						!isExported(variable) &&
+						!(
+							config.ignoreUsingDeclarations &&
+							usesExplicitResourceManagement(variable)
+						) &&
 						!hasRestSpreadSibling(variable)
 					) {
 						unusedVars.push(variable);

package/lib/rules/prefer-destructuring.js

@@ -293,6 +293,14 @@ module.exports = {
 				return;
 			}
 
+			// Variable declarations using explicit resource management cannot use destructuring (parse error)
+			if (
+				node.parent.kind === "using" ||
+				node.parent.kind === "await using"
+			) {
+				return;
+			}
+
 			// We only care about member expressions past this point
 			if (node.init.type !== "MemberExpression") {
 				return;

package/lib/rules/require-await.js

@@ -170,6 +170,15 @@ module.exports = {
 					scopeInfo.hasAwait = true;
 				}
 			},
+			VariableDeclaration(node) {
+				if (!scopeInfo) {
+					return;
+				}
+
+				if (node.kind === "await using") {
+					scopeInfo.hasAwait = true;
+				}
+			},
 		};
 	},
 };

package/lib/rules/utils/ast-utils.js

@@ -47,6 +47,12 @@ const STATEMENT_LIST_PARENTS = new Set([
 	"StaticBlock",
 	"SwitchCase",
 ]);
+const LEXICAL_DECLARATION_KINDS = new Set([
+	"let",
+	"const",
+	"using",
+	"await using",
+]);
 
 const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
@@ -298,6 +304,8 @@ function getStaticPropertyName(node) {
 		case "Property":
 		case "PropertyDefinition":
 		case "MethodDefinition":
+		case "TSPropertySignature":
+		case "TSMethodSignature":
 			prop = node.key;
 			break;
 
@@ -1989,13 +1997,15 @@ module.exports = {
 
 		if (
 			parent.type === "MethodDefinition" ||
-			parent.type === "PropertyDefinition"
+			parent.type === "PropertyDefinition" ||
+			node.type === "TSPropertySignature" ||
+			node.type === "TSMethodSignature"
 		) {
 			// The proposal uses `static` word consistently before visibility words: https://github.com/tc39/proposal-static-class-features
 			if (parent.static) {
 				tokens.push("static");
 			}
-			if (!parent.computed && parent.key.type === "PrivateIdentifier") {
+			if (!parent.computed && parent.key?.type === "PrivateIdentifier") {
 				tokens.push("private");
 			}
 		}
@@ -2017,6 +2027,14 @@ module.exports = {
 			} else {
 				tokens.push("method");
 			}
+		} else if (node.type === "TSMethodSignature") {
+			if (node.kind === "get") {
+				tokens.push("getter");
+			} else if (node.kind === "set") {
+				tokens.push("setter");
+			} else {
+				tokens.push("method");
+			}
 		} else if (parent.type === "PropertyDefinition") {
 			tokens.push("method");
 		} else {
@@ -2042,6 +2060,8 @@ module.exports = {
 					tokens.push(`'${node.id.name}'`);
 				}
 			}
+		} else if (node.type === "TSMethodSignature") {
+			tokens.push(`'${getStaticPropertyName(node)}'`);
 		} else if (node.id) {
 			tokens.push(`'${node.id.name}'`);
 		}
@@ -2154,7 +2174,9 @@ module.exports = {
 		if (
 			parent.type === "Property" ||
 			parent.type === "MethodDefinition" ||
-			parent.type === "PropertyDefinition"
+			parent.type === "PropertyDefinition" ||
+			parent.type === "TSPropertySignature" ||
+			parent.type === "TSMethodSignature"
 		) {
 			start = parent.loc.start;
 			end = getOpeningParenOfParams(node, sourceCode).loc.start;
@@ -2573,16 +2595,14 @@ module.exports = {
 	 */
 	areBracesNecessary(node, sourceCode) {
 		/**
-		 * Determines if the given node is a lexical declaration (let, const, function, or class)
+		 * Determines if the given node is a lexical declaration (let, const, using, await using, function, or class)
 		 * @param {ASTNode} nodeToCheck The node to check
 		 * @returns {boolean} True if the node is a lexical declaration
 		 * @private
 		 */
 		function isLexicalDeclaration(nodeToCheck) {
 			if (nodeToCheck.type === "VariableDeclaration") {
-				return (
-					nodeToCheck.kind === "const" || nodeToCheck.kind === "let"
-				);
+				return LEXICAL_DECLARATION_KINDS.has(nodeToCheck.kind);
 			}
 
 			return (

package/lib/types/index.d.ts

@@ -27,15 +27,17 @@
 
 import * as ESTree from "estree";
 import type {
-	RuleVisitor,
-	TextSourceCode,
+	CustomRuleDefinitionType,
+	CustomRuleTypeDefinitions,
+	DeprecatedInfo,
 	Language,
-	SourceRange,
-	TraversalStep,
 	LanguageOptions as GenericLanguageOptions,
-	RuleDefinition,
 	RuleContext as CoreRuleContext,
-	DeprecatedInfo,
+	RuleDefinition,
+	RuleVisitor,
+	SourceRange,
+	TextSourceCode,
+	TraversalStep,
 } from "@eslint/core";
 import { JSONSchema4 } from "json-schema";
 import { LegacyESLint } from "./use-at-your-own-risk.js";
@@ -1186,25 +1188,7 @@ export namespace Rule {
 			RuleOptions: any[];
 			Node: JSSyntaxElement;
 			MessageIds: string;
-		}> {
-		/*
-		 * Need to extend the `RuleContext` interface to include the
-		 * deprecated methods that have not yet been removed.
-		 * TODO: Remove in v10.0.0.
-		 */
-
-		/** @deprecated Use `sourceCode.getAncestors()` instead */
-		getAncestors(): ESTree.Node[];
-
-		/** @deprecated Use `sourceCode.getDeclaredVariables()` instead */
-		getDeclaredVariables(node: ESTree.Node): Scope.Variable[];
-
-		/** @deprecated Use `sourceCode.getScope()` instead */
-		getScope(): Scope.Scope;
-
-		/** @deprecated Use `sourceCode.markVariableAsUsed()` instead */
-		markVariableAsUsed(name: string): boolean;
-	}
+		}> {}
 
 	type ReportFixer = (
 		fixer: RuleFixer,
@@ -1268,27 +1252,18 @@ export namespace Rule {
 	}
 }
 
-export type JSRuleDefinitionTypeOptions = {
-	RuleOptions: unknown[];
-	MessageIds: string;
-	ExtRuleDocs: Record<string, unknown>;
-};
+export type JSRuleDefinitionTypeOptions = CustomRuleTypeDefinitions;
 
 export type JSRuleDefinition<
 	Options extends Partial<JSRuleDefinitionTypeOptions> = {},
-> = RuleDefinition<
-	// Language specific type options (non-configurable)
+> = CustomRuleDefinitionType<
 	{
 		LangOptions: Linter.LanguageOptions;
 		Code: SourceCode;
 		Visitor: Rule.NodeListener;
 		Node: JSSyntaxElement;
-	} & Required<
-		// Rule specific type options (custom)
-		Options &
-			// Rule specific type options (defaults)
-			Omit<JSRuleDefinitionTypeOptions, keyof Options>
-	>
+	},
+	Options
 >;
 
 // #region Linter
@@ -1615,7 +1590,6 @@ export namespace Linter {
 					globalReturn?: boolean | undefined;
 					impliedStrict?: boolean | undefined;
 					jsx?: boolean | undefined;
-					experimentalObjectRestSpread?: boolean | undefined;
 					[key: string]: any;
 			  }
 			| undefined;