eslint 10.0.0-beta.0 → 10.0.0-rc.1

package/lib/rules/max-params.js

@@ -53,8 +53,14 @@ module.exports = {
 								description:
 									"Whether to count a `this` declaration when the type is `void`.",
 							},
+							countThis: {
+								enum: ["never", "except-void", "always"],
+								description:
+									"Whether to count a `this` declaration.",
+							},
 						},
 						additionalProperties: false,
+						not: { required: ["countVoidThis", "countThis"] },
 					},
 				],
 			},
@@ -68,7 +74,7 @@ module.exports = {
 		const sourceCode = context.sourceCode;
 		const option = context.options[0];
 		let numParams = 3;
-		let countVoidThis = false;
+		let countThis = "except-void";
 
 		if (typeof option === "object") {
 			if (
@@ -77,7 +83,12 @@ module.exports = {
 			) {
 				numParams = option.maximum || option.max;
 			}
-			countVoidThis = option.countVoidThis;
+
+			countThis = option.countThis;
+			if (!countThis && Object.hasOwn(option, "countVoidThis")) {
+				countThis = option.countVoidThis ? "always" : "except-void";
+			}
+			countThis ||= "except-void";
 		}
 		if (typeof option === "number") {
 			numParams = option;
@@ -90,17 +101,25 @@ module.exports = {
 		 * @private
 		 */
 		function checkFunction(node) {
-			const hasVoidThisParam =
+			const thisParam =
 				node.params.length > 0 &&
 				node.params[0].type === "Identifier" &&
-				node.params[0].name === "this" &&
-				node.params[0].typeAnnotation?.typeAnnotation.type ===
-					"TSVoidKeyword";
+				node.params[0].name === "this"
+					? node.params[0]
+					: null;
 
-			const effectiveParamCount =
-				hasVoidThisParam && !countVoidThis
-					? node.params.length - 1
-					: node.params.length;
+			let effectiveParamCount = node.params.length;
+			if (thisParam) {
+				if (countThis === "never") {
+					effectiveParamCount = node.params.length - 1;
+				} else if (
+					countThis === "except-void" &&
+					thisParam.typeAnnotation?.typeAnnotation.type ===
+						"TSVoidKeyword"
+				) {
+					effectiveParamCount = node.params.length - 1;
+				}
+			}
 
 			if (effectiveParamCount > numParams) {
 				context.report({

package/lib/rules/no-shadow.js

@@ -346,32 +346,97 @@ module.exports = {
 		}
 
 		/**
-		 * Checks if a variable is inside the initializer of scopeVar.
+		 * Finds the uppermost expression node that can evaluate to the given one.
 		 *
-		 * To avoid reporting at declarations such as `var a = function a() {};`.
-		 * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
-		 * @param {Object} variable The variable to check.
-		 * @param {Object} scopeVar The scope variable to look for.
-		 * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.
+		 * Examples:
+		 *    If given `a` in `a || foo`, it returns the `a || foo` node.
+		 *    If given `a` in `foo ? a : bar`, it returns the `foo ? a : bar` node.
+		 *    If given `a` in `foo ? bar : (baz && a)`, it returns the `foo ? bar : (baz && a)` node.
+		 *    If given `a` in `a ? foo : bar`, it returns the `a` node.
+		 *    If given `a` in `foo(a)`, it returns the `a` node.
+		 * @param {ASTNode} expression The expression node to unwrap.
+		 * @returns {ASTNode} The uppermost ancestor that can evaluate to the given node
+		 *     or the given node if there is no such ancestor.
 		 */
-		function isOnInitializer(variable, scopeVar) {
-			const outerScope = scopeVar.scope;
-			const outerDef = scopeVar.defs[0];
-			const outer = outerDef && outerDef.parent && outerDef.parent.range;
-			const innerScope = variable.scope;
-			const innerDef = variable.defs[0];
-			const inner = innerDef && innerDef.name.range;
+		function unwrapExpression(expression) {
+			const { parent } = expression;
 
-			return (
-				outer &&
-				inner &&
-				outer[0] < inner[0] &&
-				inner[1] < outer[1] &&
-				((innerDef.type === "FunctionName" &&
-					innerDef.node.type === "FunctionExpression") ||
-					innerDef.node.type === "ClassExpression") &&
-				outerScope === innerScope.upper
-			);
+			const shouldUnwrap =
+				parent.type === "LogicalExpression" ||
+				(parent.type === "ConditionalExpression" &&
+					parent.test !== expression);
+
+			return shouldUnwrap ? unwrapExpression(parent) : expression;
+		}
+
+		/**
+		 * Checks if inner variable is the name of a function or class
+		 * that is assigned to outer variable as its initializer.
+		 *
+		 * To avoid reporting at declarations such as:
+		 *    var a = function a() {};
+		 *    var A = class A {};
+		 *    var a = foo || function a() {};
+		 *    var a = foo ? function a() {} : bar;
+		 *    var { a = function a() {} } = foo;
+		 *
+		 * But it should report at declarations such as:
+		 *    var a = function(a) {};
+		 *    var a = function() { function a() {} };
+		 *    var a = wrap(function a() {});
+		 * @param {Object} innerVariable The inner variable to check.
+		 * @param {Object} outerVariable The outer variable.
+		 * @returns {boolean} Whether or not inner variable is the name of a
+		 *   function or class that is assigned to outer variable as its initializer.
+		 */
+		function isFunctionNameInitializerException(
+			innerVariable,
+			outerVariable,
+		) {
+			const outerDef = outerVariable.defs[0];
+			const innerDef = innerVariable.defs[0];
+
+			if (!outerDef || !innerDef) {
+				return false;
+			}
+
+			if (
+				!(
+					(innerDef.type === "FunctionName" &&
+						innerDef.node.type === "FunctionExpression") ||
+					(innerDef.type === "ClassName" &&
+						innerDef.node.type === "ClassExpression")
+				)
+			) {
+				return false;
+			}
+
+			const outerIdentifier = outerDef.name;
+			let initializerNode;
+
+			if (outerIdentifier.parent.type === "VariableDeclarator") {
+				initializerNode = outerIdentifier.parent.init;
+			} else if (outerIdentifier.parent.type === "AssignmentPattern") {
+				initializerNode = outerIdentifier.parent.right;
+			}
+
+			if (!initializerNode) {
+				return false;
+			}
+
+			const nodeToCheck = innerDef.node; // FunctionExpression or ClassExpression node
+
+			// Exit early if the node to check isn't inside the initializer
+			if (
+				!(
+					initializerNode.range[0] <= nodeToCheck.range[0] &&
+					nodeToCheck.range[1] <= initializerNode.range[1]
+				)
+			) {
+				return false;
+			}
+
+			return initializerNode === unwrapExpression(nodeToCheck);
 		}
 
 		/**
@@ -577,7 +642,7 @@ module.exports = {
 					shadowed &&
 					(shadowed.identifiers.length > 0 ||
 						(builtinGlobals && "writeable" in shadowed)) &&
-					!isOnInitializer(variable, shadowed) &&
+					!isFunctionNameInitializerException(variable, shadowed) &&
 					!(
 						ignoreOnInitialization &&
 						isInitPatternNode(variable, shadowed)

package/lib/types/index.d.ts

@@ -53,7 +53,6 @@ import type {
 	EcmaVersion as CoreEcmaVersion,
 	ConfigOverride as CoreConfigOverride,
 	ProcessorFile as CoreProcessorFile,
-	JavaScriptParserOptionsConfig,
 	RulesMeta,
 	RuleConfig,
 	RuleTextEditor,
@@ -71,6 +70,7 @@ import type {
 	SuggestedEditBase,
 	SuggestedEdit,
 	ViolationReport,
+	MessagePlaceholderData,
 } from "@eslint/core";
 
 //------------------------------------------------------------------------------
@@ -139,7 +139,7 @@ export namespace Scope {
 
 		getDeclaredVariables(node: ESTree.Node): Variable[];
 
-		addGlobals(names: string[]): void;
+		addGlobals(names: ReadonlyArray<string>): void;
 	}
 
 	interface Scope {
@@ -155,8 +155,7 @@ export namespace Scope {
 			| "global"
 			| "module"
 			| "switch"
-			| "with"
-			| "TDZ";
+			| "with";
 		isStrict: boolean;
 		upper: Scope | null;
 		childScopes: Scope[];
@@ -185,8 +184,8 @@ export namespace Scope {
 		identifier: ESTree.Identifier | JSXIdentifier;
 		from: Scope;
 		resolved: Variable | null;
-		writeExpr: ESTree.Node | null;
-		init: boolean;
+		writeExpr?: ESTree.Expression | null;
+		init?: boolean;
 
 		isWrite(): boolean;
 
@@ -235,7 +234,6 @@ export namespace Scope {
 					| ESTree.ArrowFunctionExpression;
 				parent: null;
 		  }
-		| { type: "TDZ"; node: any; parent: null }
 		| {
 				type: "Variable";
 				node: ESTree.VariableDeclarator;
@@ -812,23 +810,23 @@ export class Linter {
 
 	verify(
 		code: SourceCode | string,
-		config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+		config: Linter.Config | Linter.Config[],
 		filename?: string,
 	): Linter.LintMessage[];
 	verify(
 		code: SourceCode | string,
-		config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+		config: Linter.Config | Linter.Config[],
 		options: Linter.LintOptions,
 	): Linter.LintMessage[];
 
 	verifyAndFix(
 		code: string,
-		config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+		config: Linter.Config | Linter.Config[],
 		filename?: string,
 	): Linter.FixReport;
 	verifyAndFix(
 		code: string,
-		config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+		config: Linter.Config | Linter.Config[],
 		options: Linter.FixOptions,
 	): Linter.FixReport;
 
@@ -935,7 +933,43 @@ export namespace Linter {
 	 *
 	 * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
 	 */
-	type ParserOptions = JavaScriptParserOptionsConfig;
+	interface ParserOptions {
+		/**
+		 * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
+		 *
+		 * @default false
+		 */
+		allowReserved?: boolean | undefined;
+		/**
+		 * An object indicating which additional language features you'd like to use.
+		 *
+		 * @see https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options
+		 */
+		ecmaFeatures?:
+			| {
+					/**
+					 * Allow `return` statements in the global scope.
+					 *
+					 * @default false
+					 */
+					globalReturn?: boolean | undefined;
+					/**
+					 * Enable global [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) (if `ecmaVersion` is 5 or greater).
+					 *
+					 * @default false
+					 */
+					impliedStrict?: boolean | undefined;
+					/**
+					 * Enable [JSX](https://facebook.github.io/jsx/).
+					 *
+					 * @default false
+					 */
+					jsx?: boolean | undefined;
+					[key: string]: any;
+			  }
+			| undefined;
+		[key: string]: any;
+	}
 
 	/**
 	 * Options used for linting code with `Linter#verify` and `Linter#verifyAndFix`.
@@ -1386,6 +1420,12 @@ export class RuleTester {
 				 * error does not contain them.
 				 */
 				requireLocation?: boolean;
+				/**
+				 * If true, each error and suggestion with a `messageId` must specify a `data`
+				 * property if the referenced message contains placeholders.
+				 * `"error"` and `"suggestion" limit the assertion to errors and suggestions respectively.
+				 */
+				requireData?: boolean | "error" | "suggestion";
 			};
 		},
 	): void;
@@ -1419,7 +1459,7 @@ export namespace RuleTester {
 	interface SuggestionOutput {
 		messageId?: string;
 		desc?: string;
-		data?: Record<string, unknown> | undefined;
+		data?: MessagePlaceholderData | undefined;
 		output: string;
 	}
 
@@ -1431,7 +1471,7 @@ export namespace RuleTester {
 	interface TestCaseError {
 		message?: string | RegExp;
 		messageId?: string;
-		data?: any;
+		data?: MessagePlaceholderData | undefined;
 		line?: number | undefined;
 		column?: number | undefined;
 		endLine?: number | undefined;

package/lib/types/rules.d.ts

@@ -1858,9 +1858,14 @@ export interface ESLintRules extends Linter.RulesRecord {
 					 */
 					max: number;
 					/**
+					 * @deprecated Replaced with `countThis'
 					 * @default false
 					 */
 					countVoidThis: boolean;
+					/**
+					 * @default "except-void"
+					 */
+					countThis: "always" | "never" | "except-void";
 			  }>,
 		]
 	>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "10.0.0-beta.0",
+  "version": "10.0.0-rc.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -109,9 +109,9 @@
     "@eslint-community/eslint-utils": "^4.8.0",
     "@eslint-community/regexpp": "^4.12.2",
     "@eslint/config-array": "^0.23.0",
-    "@eslint/config-helpers": "^0.5.0",
-    "@eslint/core": "^1.0.0",
-    "@eslint/plugin-kit": "^0.5.0",
+    "@eslint/config-helpers": "^0.5.1",
+    "@eslint/core": "^1.0.1",
+    "@eslint/plugin-kit": "^0.5.1",
     "@humanfs/node": "^0.16.6",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.4.2",
@@ -120,9 +120,9 @@
     "cross-spawn": "^7.0.6",
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^9.0.0",
+    "eslint-scope": "^9.1.0",
     "eslint-visitor-keys": "^5.0.0",
-    "espree": "^11.0.0",
+    "espree": "^11.1.0",
     "esquery": "^1.5.0",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -193,7 +193,7 @@
     "semver": "^7.5.3",
     "shelljs": "^0.10.0",
     "sinon": "^11.0.0",
-    "typescript": "^5.3.3",
+    "typescript": "^5.9.3",
     "webpack": "^5.23.0",
     "webpack-cli": "^4.5.0",
     "yorkie": "^2.0.0"

package/lib/linter/rules.js

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Defines a storage for rules.
- * @author Nicholas C. Zakas
- * @author aladdin-add
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const builtInRules = require("../rules");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/** @typedef {import("../types").Rule.RuleModule} Rule */
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * A storage for rules.
- */
-class Rules {
-	constructor() {
-		this._rules = Object.create(null);
-	}
-
-	/**
-	 * Registers a rule module for rule id in storage.
-	 * @param {string} ruleId Rule id (file name).
-	 * @param {Rule} rule Rule object.
-	 * @returns {void}
-	 */
-	define(ruleId, rule) {
-		this._rules[ruleId] = rule;
-	}
-
-	/**
-	 * Access rule handler by id (file name).
-	 * @param {string} ruleId Rule id (file name).
-	 * @returns {Rule} Rule object.
-	 */
-	get(ruleId) {
-		if (typeof this._rules[ruleId] === "string") {
-			this.define(ruleId, require(this._rules[ruleId]));
-		}
-		if (this._rules[ruleId]) {
-			return this._rules[ruleId];
-		}
-		if (builtInRules.has(ruleId)) {
-			return builtInRules.get(ruleId);
-		}
-
-		return null;
-	}
-
-	*[Symbol.iterator]() {
-		yield* builtInRules;
-
-		for (const ruleId of Object.keys(this._rules)) {
-			yield [ruleId, this.get(ruleId)];
-		}
-	}
-}
-
-module.exports = Rules;