eslint 9.26.0 → 9.28.0

package/lib/rules/no-use-before-define.js

@@ -30,6 +30,9 @@ function parseOptions(options) {
 		classes: true,
 		variables: true,
 		allowNamedExports: false,
+		enums: true,
+		typedefs: true,
+		ignoreTypeReferences: true,
 	};
 }
 
@@ -208,6 +211,57 @@ function isEvaluatedDuringInitialization(reference) {
 	return false;
 }
 
+/**
+ * check whether the reference contains a type query.
+ * @param {ASTNode} node Identifier node to check.
+ * @returns {boolean} true if reference contains type query.
+ */
+function referenceContainsTypeQuery(node) {
+	switch (node.type) {
+		case "TSTypeQuery":
+			return true;
+
+		case "TSQualifiedName":
+		case "Identifier":
+			return referenceContainsTypeQuery(node.parent);
+
+		default:
+			// if we find a different node, there's no chance that we're in a TSTypeQuery
+			return false;
+	}
+}
+
+/**
+ * Decorators are transpiled such that the decorator is placed after the class declaration
+ * So it is considered safe
+ * @param {Variable} variable The variable to check.
+ * @param {Reference} reference The reference to check.
+ * @returns {boolean} `true` if the reference is in a class decorator.
+ */
+function isClassRefInClassDecorator(variable, reference) {
+	if (variable.defs[0].type !== "ClassName") {
+		return false;
+	}
+
+	if (
+		!variable.defs[0].node.decorators ||
+		variable.defs[0].node.decorators.length === 0
+	) {
+		return false;
+	}
+
+	for (const deco of variable.defs[0].node.decorators) {
+		if (
+			reference.identifier.range[0] >= deco.range[0] &&
+			reference.identifier.range[1] <= deco.range[1]
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -237,6 +291,9 @@ module.exports = {
 							classes: { type: "boolean" },
 							variables: { type: "boolean" },
 							allowNamedExports: { type: "boolean" },
+							enums: { type: "boolean" },
+							typedefs: { type: "boolean" },
+							ignoreTypeReferences: { type: "boolean" },
 						},
 						additionalProperties: false,
 					},
@@ -250,6 +307,9 @@ module.exports = {
 				functions: true,
 				variables: true,
 				allowNamedExports: false,
+				enums: true,
+				typedefs: true,
+				ignoreTypeReferences: true,
 			},
 		],
 
@@ -310,6 +370,41 @@ module.exports = {
 				return false;
 			}
 
+			if (!options.enums && definitionType === "TSEnumName") {
+				return false;
+			}
+
+			if (!options.typedefs && definitionType === "Type") {
+				return false;
+			}
+
+			if (
+				options.ignoreTypeReferences &&
+				(referenceContainsTypeQuery(identifier) ||
+					identifier.parent.type === "TSTypeReference")
+			) {
+				return false;
+			}
+
+			// skip nested namespace aliases as variable references
+			if (identifier.parent.type === "TSQualifiedName") {
+				let currentNode = identifier.parent;
+
+				while (currentNode.type === "TSQualifiedName") {
+					currentNode = currentNode.left;
+				}
+
+				if (currentNode === identifier) {
+					return true;
+				}
+
+				return false;
+			}
+
+			if (isClassRefInClassDecorator(variable, reference)) {
+				return false;
+			}
+
 			return true;
 		}
 
@@ -326,7 +421,8 @@ module.exports = {
 				if (
 					reference.identifier.range[1] <
 						definitionIdentifier.range[1] ||
-					isEvaluatedDuringInitialization(reference)
+					(isEvaluatedDuringInitialization(reference) &&
+						reference.identifier.parent.type !== "TSTypeReference")
 				) {
 					context.report({
 						node: reference.identifier,

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

@@ -60,6 +60,12 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
+		defaultOptions: [
+			{
+				allowRegexCharacters: [],
+			},
+		],
+
 		docs: {
 			description: "Disallow unnecessary escape characters",
 			recommended: true,
@@ -78,11 +84,26 @@ module.exports = {
 				"Replace the `\\` with `\\\\` to include the actual backslash character.",
 		},
 
-		schema: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowRegexCharacters: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 	},
 
 	create(context) {
 		const sourceCode = context.sourceCode;
+		const [{ allowRegexCharacters }] = context.options;
 		const parser = new RegExpParser();
 
 		/**
@@ -217,7 +238,8 @@ module.exports = {
 
 					if (
 						escapedChar !==
-						String.fromCodePoint(characterNode.value)
+							String.fromCodePoint(characterNode.value) ||
+						allowRegexCharacters.includes(escapedChar)
 					) {
 						// It's a valid escape.
 						return;

package/lib/rules/prefer-arrow-callback.js

@@ -151,6 +151,8 @@ function hasDuplicateParams(paramsList) {
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 
 		defaultOptions: [
 			{ allowNamedFunctions: false, allowUnboundThis: true },
@@ -308,6 +310,13 @@ module.exports = {
 								return;
 							}
 
+							if (
+								node.params.length &&
+								node.params[0].name === "this"
+							) {
+								return;
+							}
+
 							// Remove `.bind(this)` if exists.
 							if (callbackInfo.isLexicalThis) {
 								const memberNode = node.parent;

package/lib/rules/prefer-named-capture-group.js

@@ -17,6 +17,12 @@ const {
 } = require("@eslint-community/eslint-utils");
 const regexpp = require("@eslint-community/regexpp");
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @import { SuggestedEdit } from "@eslint/core"; */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -29,7 +35,7 @@ const parser = new regexpp.RegExpParser();
  * @param {string} pattern The regular expression pattern to be checked.
  * @param {string} rawText Source text of the regexNode.
  * @param {ASTNode} regexNode AST node which contains the regular expression.
- * @returns {Array<SuggestionResult>} Fixer suggestions for the regex, if statically determinable.
+ * @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
  */
 function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
 	switch (regexNode.type) {

package/lib/services/processor-service.js

@@ -17,7 +17,7 @@ const { VFile } = require("../linter/vfile.js");
 // Types
 //-----------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types.js").LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("../linter/vfile.js").VFile} VFile */
 /** @typedef {import("@eslint/core").Language} Language */
 /** @typedef {import("eslint").Linter.Processor} Processor */

package/lib/services/suppressions-service.js

@@ -12,14 +12,16 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const { calculateStatsPerFile } = require("../eslint/eslint-helpers");
+const stringify = require("json-stable-stringify-without-jsonify");
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
 // For VSCode IntelliSense
-/** @typedef {import("../shared/types").LintResult} LintResult */
-/** @typedef {import("../shared/types").SuppressedViolations} SuppressedViolations */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {Record<string, Record<string, { count: number; }>>} SuppressedViolations */
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -224,7 +226,7 @@ class SuppressionsService {
 	save(suppressions) {
 		return fs.promises.writeFile(
 			this.filePath,
-			JSON.stringify(suppressions, null, 2),
+			stringify(suppressions, { space: 2 }),
 		);
 	}
 

package/lib/services/warning-service.js

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Emits warnings for ESLint.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * A service that emits warnings for ESLint.
+ */
+class WarningService {
+	/**
+	 * Creates a new instance of the service.
+	 * @param {{ emitWarning?: ((warning: string, type: string) => void) | undefined }} [options] A function called internally to emit warnings using API provided by the runtime.
+	 */
+	constructor({
+		emitWarning = globalThis.process?.emitWarning ?? (() => {}),
+	} = {}) {
+		this.emitWarning = emitWarning;
+	}
+
+	/**
+	 * Emits a warning when circular fixes are detected while fixing a file.
+	 * This method is used by the Linter and is safe to call outside Node.js.
+	 * @param {string} filename The name of the file being fixed.
+	 * @returns {void}
+	 */
+	emitCircularFixesWarning(filename) {
+		this.emitWarning(
+			`Circular fixes detected while fixing ${filename}. It is likely that you have conflicting rules in your configuration.`,
+			"ESLintCircularFixesWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an empty config file has been loaded.
+	 * @param {string} configFilePath The path to the config file.
+	 * @returns {void}
+	 */
+	emitEmptyConfigWarning(configFilePath) {
+		this.emitWarning(
+			`Running ESLint with an empty config (from ${configFilePath}). Please double-check that this is what you want. If you want to run ESLint with an empty config, export [{}] to remove this warning.`,
+			"ESLintEmptyConfigWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an ".eslintignore" file is found.
+	 * @returns {void}
+	 */
+	emitESLintIgnoreWarning() {
+		this.emitWarning(
+			'The ".eslintignore" file is no longer supported. Switch to using the "ignores" property in "eslint.config.js": https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files',
+			"ESLintIgnoreWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when the ESLINT_USE_FLAT_CONFIG environment variable is set to "false".
+	 * @returns {void}
+	 */
+	emitESLintRCWarning() {
+		this.emitWarning(
+			"You are using an eslintrc configuration file, which is deprecated and support will be removed in v10.0.0. Please migrate to an eslint.config.js file. See https://eslint.org/docs/latest/use/configure/migration-guide for details. An eslintrc configuration file is used because you have the ESLINT_USE_FLAT_CONFIG environment variable set to false. If you want to use an eslint.config.js file, remove the environment variable. If you want to find the location of the eslintrc configuration file, use the --debug flag.",
+			"ESLintRCWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an inactive flag is used.
+	 * This method is used by the Linter and is safe to call outside Node.js.
+	 * @param {string} flag The name of the flag.
+	 * @param {string} message The warning message.
+	 * @returns {void}
+	 */
+	emitInactiveFlagWarning(flag, message) {
+		this.emitWarning(message, `ESLintInactiveFlag_${flag}`);
+	}
+}
+
+module.exports = { WarningService };

package/lib/shared/flags.js

@@ -27,6 +27,7 @@
  */
 const activeFlags = new Map([
 	["test_only", "Used only for testing."],
+	["test_only_2", "Used only for testing."],
 	[
 		"unstable_config_lookup_from_file",
 		"Look up `eslint.config.js` from the file being linted.",

package/lib/types/index.d.ts

@@ -584,6 +584,11 @@ export namespace SourceCode {
 
 // #endregion
 
+export type JSSyntaxElement = {
+	type: string;
+	loc?: ESTree.SourceLocation | null | undefined;
+};
+
 export namespace Rule {
 	interface RuleModule
 		extends RuleDefinition<{
@@ -591,7 +596,7 @@ export namespace Rule {
 			Code: SourceCode;
 			RuleOptions: any[];
 			Visitor: NodeListener;
-			Node: ESTree.Node;
+			Node: JSSyntaxElement;
 			MessageIds: string;
 			ExtRuleDocs: {};
 		}> {
@@ -1159,10 +1164,10 @@ export namespace Rule {
 		/**
 		 * Indicates the type of rule:
 		 * - `"problem"` means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve.
-		 * - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed.
+		 * - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn't changed.
 		 * - `"layout"` means the rule cares primarily about whitespace, semicolons, commas, and parentheses,
 		 *   all the parts of the program that determine how the code looks rather than how it executes.
-		 *   These rules work on parts of the code that aren’t specified in the AST.
+		 *   These rules work on parts of the code that aren't specified in the AST.
 		 */
 		type?: "problem" | "suggestion" | "layout" | undefined;
 		/**
@@ -1177,7 +1182,7 @@ export namespace Rule {
 			LangOptions: Linter.LanguageOptions;
 			Code: SourceCode;
 			RuleOptions: any[];
-			Node: ESTree.Node;
+			Node: JSSyntaxElement;
 			MessageIds: string;
 		}> {
 		/*
@@ -1275,7 +1280,7 @@ export type JSRuleDefinition<
 		LangOptions: Linter.LanguageOptions;
 		Code: SourceCode;
 		Visitor: Rule.NodeListener;
-		Node: ESTree.Node;
+		Node: JSSyntaxElement;
 	} & Required<
 		// Rule specific type options (custom)
 		Options &
@@ -1560,9 +1565,16 @@ export namespace Linter {
 	/**
 	 * Parser options.
 	 *
-	 * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
+	 * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
 	 */
 	interface ParserOptions {
+		/**
+		 * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
+		 *
+		 * @default false
+		 */
+		allowReserved?: boolean | undefined;
+
 		/**
 		 * Accepts any valid ECMAScript version number or `'latest'`:
 		 *
@@ -1619,26 +1631,54 @@ export namespace Linter {
 	}
 
 	interface LintSuggestion {
+		/** A short description. */
 		desc: string;
+
+		/** Fix result info. */
 		fix: Rule.Fix;
+
+		/** Id referencing a message for the description. */
 		messageId?: string | undefined;
 	}
 
 	interface LintMessage {
+		/** The 1-based column number. */
 		column: number;
+
+		/** The 1-based line number. */
 		line: number;
+
+		/** The 1-based column number of the end location. */
 		endColumn?: number | undefined;
+
+		/** The 1-based line number of the end location. */
 		endLine?: number | undefined;
+
+		/** The ID of the rule which makes this message. */
 		ruleId: string | null;
+
+		/** The reported message. */
 		message: string;
+
+		/** The ID of the message in the rule's meta. */
 		messageId?: string | undefined;
+
 		/**
+		 * Type of node.
 		 * @deprecated `nodeType` is deprecated and will be removed in the next major version.
 		 */
 		nodeType?: string | undefined;
+
+		/** If `true` then this is a fatal error. */
 		fatal?: true | undefined;
+
+		/** The severity of this message. */
 		severity: Exclude<Severity, 0>;
+
+		/** Information for autofix. */
 		fix?: Rule.Fix | undefined;
+
+		/** Information for suggestions. */
 		suggestions?: LintSuggestion[] | undefined;
 	}
 
@@ -1648,6 +1688,7 @@ export namespace Linter {
 	}
 
 	interface SuppressedLintMessage extends LintMessage {
+		/** The suppression info. */
 		suppressions: LintSuppression[];
 	}
 
@@ -1661,8 +1702,8 @@ export namespace Linter {
 		messages: LintMessage[];
 	}
 
-	// Temporarily loosen type for just flat config files (see #68232)
-	type NonESTreeParser = Omit<ESTreeParser, "parseForESLint"> &
+	// Temporarily loosen type for just flat config files (see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68232)
+	type NonESTreeParser = ESLint.ObjectMetaProperties &
 		(
 			| {
 					parse(text: string, options?: any): unknown;
@@ -1687,9 +1728,16 @@ export namespace Linter {
 	type Parser = NonESTreeParser | ESTreeParser;
 
 	interface ESLintParseResult {
+		/** The AST object. */
 		ast: AST.Program;
-		parserServices?: SourceCode.ParserServices | undefined;
+
+		/** The services that the parser provides. */
+		services?: SourceCode.ParserServices | undefined;
+
+		/** The scope manager of the AST. */
 		scopeManager?: Scope.ScopeManager | undefined;
+
+		/** The visitor keys of the AST. */
 		visitorKeys?: SourceCode.VisitorKeys | undefined;
 	}
 
@@ -1702,8 +1750,13 @@ export namespace Linter {
 	interface Processor<
 		T extends string | ProcessorFile = string | ProcessorFile,
 	> extends ESLint.ObjectMetaProperties {
+		/** If `true` then it means the processor supports autofix. */
 		supportsAutofix?: boolean | undefined;
+
+		/** The function to extract code blocks. */
 		preprocess?(text: string, filename: string): T[];
+
+		/** The function to merge messages. */
 		postprocess?(
 			messages: LintMessage[][],
 			filename: string,
@@ -1844,6 +1897,9 @@ export namespace Linter {
 		reportUnusedInlineConfigs?: Severity | StringSeverity;
 	}
 
+	/**
+	 * Performance statistics.
+	 */
 	interface Stats {
 		/**
 		 * The number of times ESLint has applied at least one fix after linting.
@@ -1857,9 +1913,24 @@ export namespace Linter {
 	}
 
 	interface TimePass {
+		/**
+		 * The parse object containing all parse time information.
+		 */
 		parse: { total: number };
+
+		/**
+		 * The rules object containing all lint time information for each rule.
+		 */
 		rules?: Record<string, { total: number }>;
+
+		/**
+		 * The fix object containing all fix time information.
+		 */
 		fix: { total: number };
+
+		/**
+		 * The total time that is spent on (parsing, fixing, linting) a file.
+		 */
 		total: number;
 	}
 }
@@ -1915,7 +1986,10 @@ export namespace ESLint {
 		Omit<Linter.LegacyConfig<Rules>, "$schema">;
 
 	interface Environment {
+		/** The definition of global variables. */
 		globals?: Linter.Globals | undefined;
+
+		/** The parser options that will be enabled under this environment. */
 		parserOptions?: Linter.ParserOptions | undefined;
 	}
 
@@ -2022,21 +2096,48 @@ export namespace ESLint {
 		flags?: string[] | undefined;
 	}
 
+	/** A linting result. */
 	interface LintResult {
+		/** The path to the file that was linted. */
 		filePath: string;
+
+		/** All of the messages for the result. */
 		messages: Linter.LintMessage[];
+
+		/** All of the suppressed messages for the result. */
 		suppressedMessages: Linter.SuppressedLintMessage[];
+
+		/** Number of errors for the result. */
 		errorCount: number;
+
+		/** Number of fatal errors for the result. */
 		fatalErrorCount: number;
+
+		/** Number of warnings for the result. */
 		warningCount: number;
+
+		/** Number of fixable errors for the result. */
 		fixableErrorCount: number;
+
+		/** Number of fixable warnings for the result. */
 		fixableWarningCount: number;
+
+		/** The source code of the file that was linted, with as many fixes applied as possible. */
 		output?: string | undefined;
+
+		/** The source code of the file that was linted. */
 		source?: string | undefined;
+
+		/** The performance statistics collected with the `stats` flag. */
 		stats?: Linter.Stats | undefined;
+
+		/** The list of used deprecated rules. */
 		usedDeprecatedRules: DeprecatedRuleUse[];
 	}
 
+	/**
+	 * Information provided when the maximum warning threshold is exceeded.
+	 */
 	interface MaxWarningsExceeded {
 		/**
 		 * Number of warnings to trigger nonzero exit code.
@@ -2057,12 +2158,34 @@ export namespace ESLint {
 		};
 	}
 
+	/**
+	 * Information about deprecated rules.
+	 */
 	interface DeprecatedRuleUse {
+		/**
+		 * The rule ID.
+		 */
 		ruleId: string;
+
+		/**
+		 * The rule IDs that replace this deprecated rule.
+		 */
 		replacedBy: string[];
+
+		/**
+		 * The raw deprecated info provided by the rule.
+		 * Unset if the rule's `meta.deprecated` property is a boolean.
+		 */
+		info?: DeprecatedInfo;
 	}
 
+	/**
+	 * Metadata about results for formatters.
+	 */
 	interface ResultsMeta {
+		/**
+		 * Present if the maxWarnings threshold was exceeded.
+		 */
 		maxWarningsExceeded?: MaxWarningsExceeded | undefined;
 	}