eslint 9.31.0 → 9.33.0

package/lib/rules/one-var.js

@@ -64,6 +64,12 @@ module.exports = {
 							const: {
 								enum: ["always", "never", "consecutive"],
 							},
+							using: {
+								enum: ["always", "never", "consecutive"],
+							},
+							awaitUsing: {
+								enum: ["always", "never", "consecutive"],
+							},
 						},
 						additionalProperties: false,
 					},
@@ -112,6 +118,8 @@ module.exports = {
 			options.var = { uninitialized: mode, initialized: mode };
 			options.let = { uninitialized: mode, initialized: mode };
 			options.const = { uninitialized: mode, initialized: mode };
+			options.using = { uninitialized: mode, initialized: mode };
+			options.awaitUsing = { uninitialized: mode, initialized: mode };
 		} else if (typeof mode === "object") {
 			// options configuration is an object
 			options.separateRequires = !!mode.separateRequires;
@@ -121,15 +129,27 @@ module.exports = {
 				uninitialized: mode.const,
 				initialized: mode.const,
 			};
+			options.using = {
+				uninitialized: mode.using,
+				initialized: mode.using,
+			};
+			options.awaitUsing = {
+				uninitialized: mode.awaitUsing,
+				initialized: mode.awaitUsing,
+			};
 			if (Object.hasOwn(mode, "uninitialized")) {
 				options.var.uninitialized = mode.uninitialized;
 				options.let.uninitialized = mode.uninitialized;
 				options.const.uninitialized = mode.uninitialized;
+				options.using.uninitialized = mode.uninitialized;
+				options.awaitUsing.uninitialized = mode.uninitialized;
 			}
 			if (Object.hasOwn(mode, "initialized")) {
 				options.var.initialized = mode.initialized;
 				options.let.initialized = mode.initialized;
 				options.const.initialized = mode.initialized;
+				options.using.initialized = mode.initialized;
+				options.awaitUsing.initialized = mode.initialized;
 			}
 		}
 
@@ -151,6 +171,8 @@ module.exports = {
 			blockStack.push({
 				let: { initialized: false, uninitialized: false },
 				const: { initialized: false, uninitialized: false },
+				using: { initialized: false, uninitialized: false },
+				awaitUsing: { initialized: false, uninitialized: false },
 			});
 		}
 
@@ -199,7 +221,7 @@ module.exports = {
 
 		/**
 		 * Records whether initialized/uninitialized/required variables are defined in current scope.
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @param {ASTNode[]} declarations List of declarations
 		 * @param {Object} currentScope The scope being investigated
 		 * @returns {void}
@@ -234,7 +256,7 @@ module.exports = {
 
 		/**
 		 * Determines the current scope (function or block)
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @returns {Object} The scope associated with statementType
 		 */
 		function getCurrentScope(statementType) {
@@ -246,6 +268,10 @@ module.exports = {
 				currentScope = blockStack.at(-1).let;
 			} else if (statementType === "const") {
 				currentScope = blockStack.at(-1).const;
+			} else if (statementType === "using") {
+				currentScope = blockStack.at(-1).using;
+			} else if (statementType === "awaitUsing") {
+				currentScope = blockStack.at(-1).awaitUsing;
 			}
 			return currentScope;
 		}
@@ -271,7 +297,7 @@ module.exports = {
 
 		/**
 		 * Determines if there is more than one var statement in the current scope.
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @param {ASTNode[]} declarations List of declarations
 		 * @returns {boolean} Returns true if it is the first var declaration, false if not.
 		 * @private
@@ -333,24 +359,27 @@ module.exports = {
 			);
 			const previousNode = body[currentIndex - 1];
 
-			return fixer => {
-				const type = sourceCode.getTokenBefore(declaration);
-				const prevSemi = sourceCode.getTokenBefore(type);
-				const res = [];
+			return function* joinDeclarationsFixer(fixer) {
+				const type = sourceCode.getFirstToken(declaration.parent);
+				const beforeType = sourceCode.getTokenBefore(type);
 
 				if (
 					previousNode &&
-					previousNode.kind === sourceCode.getText(type)
+					previousNode.kind === declaration.parent.kind
 				) {
-					if (prevSemi.value === ";") {
-						res.push(fixer.replaceText(prevSemi, ","));
+					if (beforeType.value === ";") {
+						yield fixer.replaceText(beforeType, ",");
 					} else {
-						res.push(fixer.insertTextAfter(prevSemi, ","));
+						yield fixer.insertTextAfter(beforeType, ",");
+					}
+
+					if (declaration.parent.kind === "await using") {
+						const usingToken = sourceCode.getTokenAfter(type);
+						yield fixer.remove(usingToken);
 					}
-					res.push(fixer.replaceText(type, ""));
-				}
 
-				return res;
+					yield fixer.replaceText(type, "");
+				}
 			};
 		}
 
@@ -440,7 +469,10 @@ module.exports = {
 									tokenAfterDeclarator.range[0],
 									lastComment.range[0],
 								],
-								`;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${exportPlacement}${declaration.kind} `,
+								`;${sourceCode.text.slice(
+									tokenAfterDeclarator.range[1],
+									lastComment.range[0],
+								)}${exportPlacement}${declaration.kind} `,
 							);
 						}
 
@@ -461,8 +493,9 @@ module.exports = {
 		function checkVariableDeclaration(node) {
 			const parent = node.parent;
 			const type = node.kind;
+			const key = type === "await using" ? "awaitUsing" : type;
 
-			if (!options[type]) {
+			if (!options[key]) {
 				return;
 			}
 
@@ -471,7 +504,7 @@ module.exports = {
 			const mixedRequires =
 				declarations.some(isRequire) && !declarations.every(isRequire);
 
-			if (options[type].initialized === MODE_ALWAYS) {
+			if (options[key].initialized === MODE_ALWAYS) {
 				if (options.separateRequires && mixedRequires) {
 					context.report({
 						node,
@@ -508,8 +541,8 @@ module.exports = {
 					);
 
 					if (
-						options[type].initialized === MODE_CONSECUTIVE &&
-						options[type].uninitialized === MODE_CONSECUTIVE
+						options[key].initialized === MODE_CONSECUTIVE &&
+						options[key].uninitialized === MODE_CONSECUTIVE
 					) {
 						context.report({
 							node,
@@ -520,7 +553,7 @@ module.exports = {
 							fix: joinDeclarations(declarations),
 						});
 					} else if (
-						options[type].initialized === MODE_CONSECUTIVE &&
+						options[key].initialized === MODE_CONSECUTIVE &&
 						declarationCounts.initialized > 0 &&
 						previousDeclCounts.initialized > 0
 					) {
@@ -533,7 +566,7 @@ module.exports = {
 							fix: joinDeclarations(declarations),
 						});
 					} else if (
-						options[type].uninitialized === MODE_CONSECUTIVE &&
+						options[key].uninitialized === MODE_CONSECUTIVE &&
 						declarationCounts.uninitialized > 0 &&
 						previousDeclCounts.uninitialized > 0
 					) {
@@ -550,10 +583,10 @@ module.exports = {
 			}
 
 			// always
-			if (!hasOnlyOneStatement(type, declarations)) {
+			if (!hasOnlyOneStatement(key, declarations)) {
 				if (
-					options[type].initialized === MODE_ALWAYS &&
-					options[type].uninitialized === MODE_ALWAYS
+					options[key].initialized === MODE_ALWAYS &&
+					options[key].uninitialized === MODE_ALWAYS
 				) {
 					context.report({
 						node,
@@ -565,7 +598,7 @@ module.exports = {
 					});
 				} else {
 					if (
-						options[type].initialized === MODE_ALWAYS &&
+						options[key].initialized === MODE_ALWAYS &&
 						declarationCounts.initialized > 0
 					) {
 						context.report({
@@ -578,7 +611,7 @@ module.exports = {
 						});
 					}
 					if (
-						options[type].uninitialized === MODE_ALWAYS &&
+						options[key].uninitialized === MODE_ALWAYS &&
 						declarationCounts.uninitialized > 0
 					) {
 						if (
@@ -608,8 +641,8 @@ module.exports = {
 
 				if (totalDeclarations > 1) {
 					if (
-						options[type].initialized === MODE_NEVER &&
-						options[type].uninitialized === MODE_NEVER
+						options[key].initialized === MODE_NEVER &&
+						options[key].uninitialized === MODE_NEVER
 					) {
 						// both initialized and uninitialized
 						context.report({
@@ -621,7 +654,7 @@ module.exports = {
 							fix: splitDeclarations(node),
 						});
 					} else if (
-						options[type].initialized === MODE_NEVER &&
+						options[key].initialized === MODE_NEVER &&
 						declarationCounts.initialized > 0
 					) {
 						// initialized
@@ -634,7 +667,7 @@ module.exports = {
 							fix: splitDeclarations(node),
 						});
 					} else if (
-						options[type].uninitialized === MODE_NEVER &&
+						options[key].uninitialized === MODE_NEVER &&
 						declarationCounts.uninitialized > 0
 					) {
 						// uninitialized

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;
+			}>,
+		]
 	>;
 
 	/**
@@ -3391,13 +3403,26 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 */
 	"no-restricted-globals": Linter.RuleEntry<
 		[
-			...Array<
-				| string
-				| {
-						name: string;
-						message?: string | undefined;
-				  }
-			>,
+			...(
+				| Array<
+						| string
+						| {
+								name: string;
+								message?: string | undefined;
+						  }
+				  >
+				| Array<{
+						globals: Array<
+							| string
+							| {
+									name: string;
+									message?: string | undefined;
+							  }
+						>;
+						checkGlobalObject?: boolean;
+						globalObjects?: string[];
+				  }>
+			),
 		]
 	>;
 
@@ -4066,6 +4091,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 					 * @default false
 					 */
 					ignoreClassWithStaticInitBlock: boolean;
+					/**
+					 * @default false
+					 */
+					ignoreUsingDeclarations: boolean;
 					/**
 					 * @default false
 					 */
@@ -4493,7 +4522,7 @@ export interface ESLintRules extends Linter.RulesRecord {
 						 */
 						separateRequires: boolean;
 					} & Record<
-						"var" | "let" | "const",
+						"var" | "let" | "const" | "using" | "awaitUsing",
 						"always" | "never" | "consecutive"
 					>
 			  >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.31.0",
+  "version": "9.33.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -107,11 +107,11 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.12.1",
     "@eslint/config-array": "^0.21.0",
-    "@eslint/config-helpers": "^0.3.0",
-    "@eslint/core": "^0.15.0",
+    "@eslint/config-helpers": "^0.3.1",
+    "@eslint/core": "^0.15.2",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "9.31.0",
-    "@eslint/plugin-kit": "^0.3.1",
+    "@eslint/js": "9.33.0",
+    "@eslint/plugin-kit": "^0.3.5",
     "@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",