eslint 9.31.0 → 9.32.0

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/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-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-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";
@@ -1250,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
@@ -1597,7 +1590,6 @@ export namespace Linter {
 					globalReturn?: boolean | undefined;
 					impliedStrict?: boolean | undefined;
 					jsx?: boolean | undefined;
-					experimentalObjectRestSpread?: boolean | undefined;
 					[key: string]: any;
 			  }
 			| undefined;

package/lib/types/rules.d.ts

@@ -116,6 +116,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 * @default true
 				 */
 				enforceForClassMembers: boolean;
+				/**
+				 * @default true
+				 */
+				enforceForTSTypes: boolean;
 			}>,
 		]
 	>;
@@ -945,7 +949,15 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs
 	 */
 	"grouped-accessor-pairs": Linter.RuleEntry<
-		["anyOrder" | "getBeforeSet" | "setBeforeGet"]
+		[
+			"anyOrder" | "getBeforeSet" | "setBeforeGet",
+			Partial<{
+				/**
+				 * @default false
+				 */
+				enforceForTSTypes: boolean;
+			}>,
+		]
 	>;
 
 	/**
@@ -4066,6 +4078,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 					 * @default false
 					 */
 					ignoreClassWithStaticInitBlock: boolean;
+					/**
+					 * @default false
+					 */
+					ignoreUsingDeclarations: boolean;
 					/**
 					 * @default false
 					 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.31.0",
+  "version": "9.32.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -110,8 +110,8 @@
     "@eslint/config-helpers": "^0.3.0",
     "@eslint/core": "^0.15.0",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "9.31.0",
-    "@eslint/plugin-kit": "^0.3.1",
+    "@eslint/js": "9.32.0",
+    "@eslint/plugin-kit": "^0.3.4",
     "@humanfs/node": "^0.16.6",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.4.2",
@@ -173,12 +173,11 @@
     "globals": "^16.2.0",
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
-    "jiti": "^2.2.0",
+    "jiti": "^2.5.1",
     "jiti-v2.0": "npm:jiti@2.0.x",
     "jiti-v2.1": "npm:jiti@2.1.x",
     "knip": "^5.60.2",
     "lint-staged": "^11.0.0",
-    "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
     "marked": "^4.0.8",