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

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-restricted-imports.js

@@ -10,6 +10,30 @@
 
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Format import names for error messages.
+ * @param {string[]} importNames The import names to format.
+ * @returns {string} The formatted import names.
+ */
+function formatImportNames(importNames) {
+	return new Intl.ListFormat("en-US").format(
+		importNames.map(name => `'${name}'`),
+	);
+}
+
+/**
+ * Returns "is" or "are" based on the number of import names.
+ * @param {string[]} importNames The import names to check.
+ * @returns {string} "is" if one import name, otherwise "are".
+ */
+function isOrAre(importNames) {
+	return importNames.length === 1 ? "is" : "are";
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -175,22 +199,22 @@ module.exports = {
 				"'{{importName}}' import from '{{importSource}}' is restricted from being used by a pattern. {{customMessage}}",
 
 			patternAndEverything:
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted from being used by a pattern.",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern.",
 
 			patternAndEverythingWithRegexImportName:
 				"* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used.",
 			patternAndEverythingWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted from being used by a pattern. {{customMessage}}",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern. {{customMessage}}",
 			patternAndEverythingWithRegexImportNameAndCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
 				"* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used. {{customMessage}}",
 
 			everything:
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted.",
 			everythingWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted. {{customMessage}}",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted. {{customMessage}}",
 
 			importName:
 				"'{{importName}}' import from '{{importSource}}' is restricted.",
@@ -199,16 +223,16 @@ module.exports = {
 				"'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}",
 
 			allowedImportName:
-				"'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed.",
+				"'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed.",
 			allowedImportNameWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed. {{customMessage}}",
+				"'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed. {{customMessage}}",
 
 			everythingWithAllowImportNames:
-				"* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed.",
+				"* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed.",
 			everythingWithAllowImportNamesAndCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed. {{customMessage}}",
+				"* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed. {{customMessage}}",
 
 			allowedImportNamePattern:
 				"'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'.",
@@ -452,7 +476,10 @@ module.exports = {
 									loc: specifier.loc,
 									data: {
 										importSource,
-										importNames: restrictedImportNames,
+										importNames: formatImportNames(
+											restrictedImportNames,
+										),
+										isOrAre: isOrAre(restrictedImportNames),
 										customMessage,
 									},
 								});
@@ -465,7 +492,11 @@ module.exports = {
 									loc: specifier.loc,
 									data: {
 										importSource,
-										allowedImportNames,
+										allowedImportNames:
+											formatImportNames(
+												allowedImportNames,
+											),
+										isOrAre: isOrAre(allowedImportNames),
 										customMessage,
 									},
 								});
@@ -525,7 +556,11 @@ module.exports = {
 										importSource,
 										customMessage,
 										importName,
-										allowedImportNames,
+										allowedImportNames:
+											formatImportNames(
+												allowedImportNames,
+											),
+										isOrAre: isOrAre(allowedImportNames),
 									},
 								});
 							});
@@ -612,7 +647,10 @@ module.exports = {
 							loc: specifier.loc,
 							data: {
 								importSource,
-								importNames: restrictedImportNames,
+								importNames: formatImportNames(
+									restrictedImportNames,
+								),
+								isOrAre: isOrAre(restrictedImportNames),
 								customMessage,
 							},
 						});
@@ -625,7 +663,9 @@ module.exports = {
 							loc: specifier.loc,
 							data: {
 								importSource,
-								allowedImportNames,
+								allowedImportNames:
+									formatImportNames(allowedImportNames),
+								isOrAre: isOrAre(allowedImportNames),
 								customMessage,
 							},
 						});
@@ -713,7 +753,9 @@ module.exports = {
 								importSource,
 								customMessage,
 								importName,
-								allowedImportNames,
+								allowedImportNames:
+									formatImportNames(allowedImportNames),
+								isOrAre: isOrAre(allowedImportNames),
 							},
 						});
 					});

package/lib/rules/no-useless-assignment.js

@@ -336,9 +336,12 @@ module.exports = {
 				}
 
 				if (
-					targetAssignment.variable.references.some(
-						ref => ref.identifier.type !== "Identifier",
-					)
+					targetAssignment.variable.references.some(ref => {
+						const type = ref.identifier.type;
+						return (
+							type !== "Identifier" && type !== "JSXIdentifier"
+						);
+					})
 				) {
 					/**
 					 * Skip checking for a variable that has at least one non-identifier reference.
@@ -529,7 +532,7 @@ module.exports = {
 			TryStatement(node) {
 				scopeStack.tryStatementBlocks.push(node.block);
 			},
-			Identifier(node) {
+			"Identifier, JSXIdentifier"(node) {
 				for (const segment of scopeStack.currentSegments) {
 					const segmentInfo = scopeStack.segments[segment.id];
 
@@ -539,7 +542,7 @@ module.exports = {
 					segmentInfo.last = node;
 				}
 			},
-			":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(
+			"VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression:exit"(
 				node,
 			) {
 				if (scopeStack.currentSegments.size === 0) {

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

@@ -704,60 +704,63 @@ function isKeywordToken(token) {
 }
 
 /**
- * Check to see if its a ES6 export declaration.
- * @param {ASTNode} astNode An AST node.
- * @returns {boolean} whether the given node represents an export declaration.
+ * Checks whether the given node represents an ES6 export declaration.
+ * @param {ASTNode} node A node to check.
+ * @returns {boolean} `true` if the node is an export declaration.
  * @private
  */
-function looksLikeExport(astNode) {
+function isExportDeclaration(node) {
 	return (
-		astNode.type === "ExportDefaultDeclaration" ||
-		astNode.type === "ExportNamedDeclaration" ||
-		astNode.type === "ExportAllDeclaration" ||
-		astNode.type === "ExportSpecifier"
+		node.type === "ExportDefaultDeclaration" ||
+		node.type === "ExportNamedDeclaration" ||
+		node.type === "ExportAllDeclaration"
 	);
 }
 
 /**
- * Retrieves the JSDoc comment for a given node.
- * @param {ASTNode} node The AST node to get the comment for.
+ * Checks for the presence of a JSDoc comment for the given node and returns it.
+ * @param {ASTNode} node The node to get the comment for.
  * @param {SourceCode} sourceCode A SourceCode instance to get comments.
  * @returns {Token|null} The Block comment token containing the JSDoc comment for the given node or null if not found.
  * @private
  */
-function getJSDocComment(node, sourceCode) {
-	/**
-	 * Checks for the presence of a JSDoc comment for the given node and returns it.
-	 * @param {ASTNode} astNode The AST node to get the comment for.
-	 * @returns {Token|null} The Block comment token containing the JSDoc comment for the given node or null if not found.
-	 * @private
-	 */
-	function findJSDocComment(astNode) {
-		const tokenBefore = sourceCode.getTokenBefore(astNode, {
-			includeComments: true,
-		});
+function findJSDocComment(node, sourceCode) {
+	const tokenBefore = sourceCode.getTokenBefore(node, {
+		includeComments: true,
+	});
 
-		if (
-			tokenBefore &&
-			isCommentToken(tokenBefore) &&
-			tokenBefore.type === "Block" &&
-			tokenBefore.value.charAt(0) === "*" &&
-			astNode.loc.start.line - tokenBefore.loc.end.line <= 1
-		) {
-			return tokenBefore;
-		}
-
-		return null;
+	if (
+		tokenBefore &&
+		tokenBefore.type === "Block" &&
+		tokenBefore.value.charAt(0) === "*" &&
+		node.loc.start.line - tokenBefore.loc.end.line <= 1
+	) {
+		return tokenBefore;
 	}
+
+	return null;
+}
+
+/**
+ * Retrieves the JSDoc comment for a given node.
+ * @param {ASTNode} node The node to get the comment for.
+ * @param {SourceCode} sourceCode A SourceCode instance to get comments.
+ * @returns {Token|null} The Block comment token containing the JSDoc comment for the given node or null if not found.
+ * @private
+ */
+function getJSDocComment(node, sourceCode) {
 	let parent = node.parent;
 
 	switch (node.type) {
 		case "ClassDeclaration":
 		case "FunctionDeclaration":
-			return findJSDocComment(looksLikeExport(parent) ? parent : node);
+			return findJSDocComment(
+				isExportDeclaration(parent) ? parent : node,
+				sourceCode,
+			);
 
 		case "ClassExpression":
-			return findJSDocComment(parent.parent);
+			return findJSDocComment(parent.parent, sourceCode);
 
 		case "ArrowFunctionExpression":
 		case "FunctionExpression":
@@ -783,11 +786,11 @@ function getJSDocComment(node, sourceCode) {
 					parent.type !== "FunctionDeclaration" &&
 					parent.type !== "Program"
 				) {
-					return findJSDocComment(parent);
+					return findJSDocComment(parent, sourceCode);
 				}
 			}
 
-			return findJSDocComment(node);
+			return findJSDocComment(node, sourceCode);
 
 		// falls through
 		default:

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,
@@ -115,7 +114,7 @@ export namespace AST {
 		end: ESTree.Position;
 	}
 
-	type Range = [number, number];
+	type Range = SourceRange;
 
 	interface Program extends ESTree.Program {
 		comments: ESTree.Comment[];
@@ -125,6 +124,11 @@ export namespace AST {
 	}
 }
 
+interface JSXIdentifier extends ESTree.BaseNode {
+	type: "JSXIdentifier";
+	name: string;
+}
+
 export namespace Scope {
 	interface ScopeManager {
 		scopes: Scope[];
@@ -134,7 +138,7 @@ export namespace Scope {
 
 		getDeclaredVariables(node: ESTree.Node): Variable[];
 
-		addGlobals(names: string[]): void;
+		addGlobals(names: ReadonlyArray<string>): void;
 	}
 
 	interface Scope {
@@ -150,8 +154,7 @@ export namespace Scope {
 			| "global"
 			| "module"
 			| "switch"
-			| "with"
-			| "TDZ";
+			| "with";
 		isStrict: boolean;
 		upper: Scope | null;
 		childScopes: Scope[];
@@ -177,11 +180,11 @@ export namespace Scope {
 	}
 
 	interface Reference {
-		identifier: ESTree.Identifier;
+		identifier: ESTree.Identifier | JSXIdentifier;
 		from: Scope;
 		resolved: Variable | null;
-		writeExpr: ESTree.Node | null;
-		init: boolean;
+		writeExpr?: ESTree.Expression | null;
+		init?: boolean;
 
 		isWrite(): boolean;
 
@@ -230,7 +233,6 @@ export namespace Scope {
 					| ESTree.ArrowFunctionExpression;
 				parent: null;
 		  }
-		| { type: "TDZ"; node: any; parent: null }
 		| {
 				type: "Variable";
 				node: ESTree.VariableDeclarator;
@@ -807,23 +809,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;
 
@@ -930,7 +932,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`.
@@ -1256,9 +1294,8 @@ export namespace ESLint {
 		foundWarnings: number;
 	}
 
-	interface LintResultData {
+	interface LintResultData extends ResultsMeta {
 		cwd: string;
-		maxWarningsExceeded?: MaxWarningsExceeded | undefined;
 		rulesMeta: {
 			[ruleId: string]: Rule.RuleMetaData;
 		};
@@ -1290,6 +1327,14 @@ export namespace ESLint {
 	 * Metadata about results for formatters.
 	 */
 	interface ResultsMeta {
+		/**
+		 * Whether or not to use color in the formatter output.
+		 * - If `--color` was set, this property is `true`.
+		 * - If `--no-color` was set, it is `false`.
+		 * - If neither option was provided, the property is omitted.
+		 */
+		color?: boolean | undefined;
+
 		/**
 		 * Present if the maxWarnings threshold was exceeded.
 		 */
@@ -1301,9 +1346,9 @@ export namespace ESLint {
 		/**
 		 * Used to call the underlying formatter.
 		 * @param results An array of lint results to format.
-		 * @param resultsMeta An object with an optional `maxWarningsExceeded` property that will be
+		 * @param resultsMeta An object with optional `color` and `maxWarningsExceeded` properties that will be
 		 * passed to the underlying formatter function along with other properties set by ESLint.
-		 * This argument can be omitted if `maxWarningsExceeded` is not needed.
+		 * This argument can be omitted if `color` and `maxWarningsExceeded` are not needed.
 		 * @return The formatter output.
 		 */
 		format(
@@ -1332,9 +1377,10 @@ export namespace ESLint {
 
 // #endregion
 
-export function loadESLint(options?: {
-	useFlatConfig?: boolean | undefined;
-}): Promise<typeof ESLint>;
+/**
+ * Loads the correct `ESLint` constructor.
+ */
+export function loadESLint(): Promise<typeof ESLint>;
 
 // #region RuleTester
 
@@ -1342,6 +1388,9 @@ export class RuleTester {
 	static describe: ((...args: any) => any) | null;
 	static it: ((...args: any) => any) | null;
 	static itOnly: ((...args: any) => any) | null;
+	static setDefaultConfig(config: Linter.Config): void;
+	static getDefaultConfig(): Linter.Config;
+	static resetDefaultConfig(): void;
 
 	constructor(config?: Linter.Config);
 
@@ -1351,6 +1400,32 @@ export class RuleTester {
 		tests: {
 			valid: Array<string | RuleTester.ValidTestCase>;
 			invalid: RuleTester.InvalidTestCase[];
+			/**
+			 * Additional assertions for the "error" matchers of invalid test cases to enforce consistency.
+			 */
+			assertionOptions?: {
+				/**
+				 * If true, each `errors` block must check the expected error
+				 * message, either via a string in the `errors` array, or via
+				 * `message`/`messageId` in an errors object.
+				 * `"message"`/`"messageId"` can be used to further limit the
+				 * message assertions to the respective versions.
+				 */
+				requireMessage?: boolean | "message" | "messageId";
+				/**
+				 * If true, each `errors` block must be an array of objects,
+				 * that each check all location properties `line`, `column`,
+				 * `endLine`, `endColumn`, the later may be omitted, if the
+				 * 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;
 
@@ -1360,14 +1435,22 @@ export class RuleTester {
 }
 
 export namespace RuleTester {
-	interface ValidTestCase {
+	interface ValidTestCase
+		extends Omit<
+			Linter.Config,
+			| "name"
+			| "basePath"
+			| "files"
+			| "ignores"
+			| "linterOptions"
+			| "plugins"
+			| "rules"
+		> {
 		name?: string;
 		code: string;
-		options?: any;
+		options?: any[];
 		filename?: string | undefined;
 		only?: boolean;
-		languageOptions?: Linter.LanguageOptions | undefined;
-		settings?: { [name: string]: any } | undefined;
 		before?: () => void;
 		after?: () => void;
 	}
@@ -1380,7 +1463,7 @@ export namespace RuleTester {
 	}
 
 	interface InvalidTestCase extends ValidTestCase {
-		errors: number | Array<TestCaseError | string>;
+		errors: number | Array<TestCaseError | string | RegExp>;
 		output?: string | null | undefined;
 	}
 
@@ -1392,7 +1475,7 @@ export namespace RuleTester {
 		column?: number | undefined;
 		endLine?: number | undefined;
 		endColumn?: number | undefined;
-		suggestions?: SuggestionOutput[] | undefined;
+		suggestions?: SuggestionOutput[] | 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/lib/types/use-at-your-own-risk.d.ts

@@ -31,4 +31,4 @@ import { Rule } from "./index.js";
 export const builtinRules: Map<string, Rule.RuleModule>;
 
 /** @deprecated */
-export function shouldUseFlatConfig(): Promise<boolean>;
+export function shouldUseFlatConfig(): Promise<true>;