eslint 9.33.0 → 9.35.0

package/lib/eslint/worker.js

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Worker thread for multithread linting.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+const hrtimeBigint = process.hrtime.bigint;
+
+const startTime = hrtimeBigint();
+
+// eslint-disable-next-line n/no-unsupported-features/node-builtins -- enable V8's code cache if supported
+require("node:module").enableCompileCache?.();
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { parentPort, threadId, workerData } = require("node:worker_threads");
+const createDebug = require("debug");
+const {
+	createConfigLoader,
+	createDefaultConfigs,
+	createLinter,
+	createLintResultCache,
+	getCacheFile,
+	lintFile,
+	loadOptionsFromModule,
+	processOptions,
+} = require("./eslint-helpers");
+const { WarningService } = require("../services/warning-service");
+
+const depsLoadedTime = hrtimeBigint();
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {import("../types").ESLint.Options} ESLintOptions */
+/** @typedef {LintResult & { index?: number; }} IndexedLintResult */
+/** @typedef {IndexedLintResult[] & { netLintingDuration: bigint; }} WorkerLintResults */
+/**
+ * @typedef {Object} WorkerData - Data passed to the worker thread.
+ * @property {ESLintOptions | string} eslintOptionsOrURL - The unprocessed ESLint options or the URL of the options module.
+ * @property {Uint32Array<SharedArrayBuffer>} filePathIndexArray - Shared counter used to track the next file to lint.
+ * @property {string[]} filePaths - File paths to lint.
+ */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const debug = createDebug(`eslint:worker:thread-${threadId}`);
+createDebug.formatters.t = timeDiff =>
+	`${(timeDiff + 500_000n) / 1_000_000n} ms`;
+
+//------------------------------------------------------------------------------
+// Main
+//------------------------------------------------------------------------------
+
+debug("Dependencies loaded in %t", depsLoadedTime - startTime);
+
+(async () => {
+	/** @type {WorkerData} */
+	const { eslintOptionsOrURL, filePathIndexArray, filePaths } = workerData;
+	const eslintOptions =
+		typeof eslintOptionsOrURL === "object"
+			? eslintOptionsOrURL
+			: await loadOptionsFromModule(eslintOptionsOrURL);
+	const processedESLintOptions = processOptions(eslintOptions);
+
+	const warningService = new WarningService();
+
+	// These warnings are always emitted by the controlling thread.
+	warningService.emitEmptyConfigWarning =
+		warningService.emitInactiveFlagWarning = () => {};
+
+	const linter = createLinter(processedESLintOptions, warningService);
+
+	const cacheFilePath = getCacheFile(
+		processedESLintOptions.cacheLocation,
+		processedESLintOptions.cwd,
+	);
+
+	const lintResultCache = createLintResultCache(
+		processedESLintOptions,
+		cacheFilePath,
+	);
+	const defaultConfigs = createDefaultConfigs(eslintOptions.plugins);
+
+	const configLoader = createConfigLoader(
+		processedESLintOptions,
+		defaultConfigs,
+		linter,
+		warningService,
+	);
+
+	/** @type {WorkerLintResults} */
+	const indexedResults = [];
+	let loadConfigTotalDuration = 0n;
+	const readFileCounter = { duration: 0n };
+
+	const lintingStartTime = hrtimeBigint();
+	debug(
+		"Linting started %t after dependencies loaded",
+		lintingStartTime - depsLoadedTime,
+	);
+
+	for (;;) {
+		const fileLintingStartTime = hrtimeBigint();
+
+		// It seems hard to produce an arithmetic overflow under realistic conditions here.
+		const index = Atomics.add(filePathIndexArray, 0, 1);
+
+		const filePath = filePaths[index];
+		if (!filePath) {
+			break;
+		}
+
+		const loadConfigEnterTime = hrtimeBigint();
+		const configs = await configLoader.loadConfigArrayForFile(filePath);
+		const loadConfigExitTime = hrtimeBigint();
+		const loadConfigDuration = loadConfigExitTime - loadConfigEnterTime;
+		debug(
+			'Config array for file "%s" loaded in %t',
+			filePath,
+			loadConfigDuration,
+		);
+		loadConfigTotalDuration += loadConfigDuration;
+
+		/** @type {IndexedLintResult} */
+		const result = await lintFile(
+			filePath,
+			configs,
+			processedESLintOptions,
+			linter,
+			lintResultCache,
+			readFileCounter,
+		);
+		if (result) {
+			result.index = index;
+			indexedResults.push(result);
+		}
+
+		const fileLintingEndTime = hrtimeBigint();
+		debug(
+			'File "%s" processed in %t',
+			filePath,
+			fileLintingEndTime - fileLintingStartTime,
+		);
+	}
+
+	const lintingDuration = hrtimeBigint() - lintingStartTime;
+
+	/*
+	 * The net linting duration is the total linting time minus the time spent loading configs and reading files.
+	 * It captures the processing time dedicated to computation-intensive tasks that are highly parallelizable and not repeated across threads.
+	 */
+	indexedResults.netLintingDuration =
+		lintingDuration - loadConfigTotalDuration - readFileCounter.duration;
+
+	parentPort.postMessage(indexedResults);
+})();

package/lib/languages/js/source-code/source-code.js

@@ -1056,7 +1056,7 @@ class SourceCode extends TokenStore {
 			// only certain comment types are supported as line comments
 			return (
 				comment.type !== "Line" ||
-				!!/^eslint-disable-(next-)?line$/u.test(directive.label)
+				!!/^eslint-disable-(?:next-)?line$/u.test(directive.label)
 			);
 		});
 
@@ -1091,9 +1091,8 @@ class SourceCode extends TokenStore {
 			} = commentParser.parseDirective(comment.value);
 
 			// Step 2: Extract the directive value
-			const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(
-				label,
-			);
+			const lineCommentSupported =
+				/^eslint-disable-(?:next-)?line$/u.test(label);
 
 			if (comment.type === "Line" && !lineCommentSupported) {
 				return;

package/lib/linter/esquery.js

@@ -271,6 +271,9 @@ function tryParseSelector(selector) {
 		) {
 			throw new SyntaxError(
 				`Syntax error in selector "${selector}" at position ${err.location.start.offset}: ${err.message}`,
+				{
+					cause: err,
+				},
 			);
 		}
 		throw err;

package/lib/linter/interpolate.js

@@ -14,7 +14,7 @@
  * @returns {RegExp} Global regular expression matching placeholders
  */
 function getPlaceholderMatcher() {
-	return /\{\{([^{}]+?)\}\}/gu;
+	return /\{\{([^{}]+)\}\}/gu;
 }
 
 /**

package/lib/linter/linter.js

@@ -438,9 +438,8 @@ function getDirectiveComments(
 				justification: justificationPart,
 			} = directive;
 
-			const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(
-				label,
-			);
+			const lineCommentSupported =
+				/^eslint-disable-(?:next-)?line$/u.test(label);
 
 			if (comment.type === "Line" && !lineCommentSupported) {
 				return;
@@ -739,7 +738,7 @@ function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
 	return LATEST_ECMA_VERSION;
 }
 
-const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)(?:\*\/|$)/gsu;
+const eslintEnvPattern = /\/\*\s*eslint-env\s.+?(?:\*\/|$)/gsu;
 
 /**
  * Checks whether or not there is a comment which has "eslint-env *" in a given text.

package/lib/options.js

@@ -23,6 +23,7 @@ const optionator = require("optionator");
  * @property {string} [cacheLocation] Path to the cache file or directory
  * @property {"metadata" | "content"} cacheStrategy Strategy to use for detecting changed files in the cache
  * @property {boolean} [color] Force enabling/disabling of color
+ * @property {number | "auto" | "off"} [concurrency] Number of linting threads, "auto" to choose automatically, "off" for no multithreading
  * @property {string} [config] Use this configuration, overriding .eslintrc.* config options if present
  * @property {boolean} debug Output debugging information
  * @property {string[]} [env] Specify environments
@@ -46,27 +47,27 @@ const optionator = require("optionator");
  * @property {string} [outputFile] Specify file to write report to
  * @property {string} [parser] Specify the parser to be used
  * @property {Object} [parserOptions] Specify parser options
+ * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
+ *      the linting operation to short circuit and not report any failures.
+ * @property {boolean} [passOnUnprunedSuppressions] Ignore unused suppressions
  * @property {string[]} [plugin] Specify plugins
  * @property {string} [printConfig] Print the configuration for the given file
+ * @property {boolean} [pruneSuppressions] Prune unused suppressions
+ * @property {boolean} quiet Report errors only
  * @property {boolean | undefined} reportUnusedDisableDirectives Adds reported errors for unused eslint-disable and eslint-enable directives
  * @property {string | undefined} reportUnusedDisableDirectivesSeverity A severity string indicating if and how unused disable and enable directives should be tracked and reported.
  * @property {string} [resolvePluginsRelativeTo] A folder where plugins should be resolved from, CWD by default
  * @property {Object} [rule] Specify rules
  * @property {string[]} [rulesdir] Load additional rules from this directory. Deprecated: Use rules from plugins
+ * @property {boolean} [stats] Report additional statistics
  * @property {boolean} stdin Lint code provided on <STDIN>
  * @property {string} [stdinFilename] Specify filename to process STDIN as
- * @property {boolean} quiet Report errors only
+ * @property {boolean} [suppressAll] Suppress all error violations
+ * @property {string} [suppressionsLocation] Path to the suppressions file or directory
+ * @property {string[]} [suppressRule] Suppress specific rules
  * @property {boolean} [version] Output the version number
  * @property {boolean} warnIgnored Show warnings when the file list includes ignored files
- * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
- *      the linting operation to short circuit and not report any failures.
  * @property {string[]} _ Positional filenames or patterns
- * @property {boolean} [stats] Report additional statistics
- * @property {boolean} [suppressAll] Suppress all error violations
- * @property {string[]} [suppressRule] Suppress specific rules
- * @property {string} [suppressionsLocation] Path to the suppressions file or directory
- * @property {boolean} [pruneSuppressions] Prune unused suppressions
- * @property {boolean} [passOnUnprunedSuppressions] Ignore unused suppressions
  */
 
 //------------------------------------------------------------------------------
@@ -224,6 +225,18 @@ module.exports = function (usingFlatConfig) {
 		};
 	}
 
+	let concurrencyFlag;
+
+	if (usingFlatConfig) {
+		concurrencyFlag = {
+			option: "concurrency",
+			type: "Int|String",
+			default: "off",
+			description:
+				"Number of linting threads, auto to choose automatically, off for no multithreading",
+		};
+	}
+
 	return optionator({
 		prepend: "eslint [options] file.js [file.js] [dir]",
 		defaults: {
@@ -517,6 +530,7 @@ module.exports = function (usingFlatConfig) {
 			statsFlag,
 			flagFlag,
 			mcpFlag,
+			concurrencyFlag,
 		].filter(value => !!value),
 	});
 };

package/lib/rule-tester/rule-tester.js

@@ -851,6 +851,9 @@ class RuleTester {
 				} catch (err) {
 					throw new Error(
 						`Schema for rule ${ruleName} is invalid: ${err.message}`,
+						{
+							cause: err,
+						},
 					);
 				}
 			}

package/lib/rules/array-callback-return.js

@@ -233,7 +233,6 @@ module.exports = {
 			url: "https://eslint.org/docs/latest/rules/array-callback-return",
 		},
 
-		// eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- false positive
 		hasSuggestions: true,
 
 		schema: [

package/lib/rules/dot-notation.js

@@ -15,7 +15,7 @@ const keywords = require("./utils/keywords");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/u;
+const validIdentifier = /^[a-zA-Z_$][\w$]*$/u;
 
 // `null` literal must be handled separately.
 const literalTypesToCheck = new Set(["string", "boolean"]);

package/lib/rules/grouped-accessor-pairs.js

@@ -87,8 +87,6 @@ function isAccessorKind(node) {
 	return node.kind === "get" || node.kind === "set";
 }
 
-const DEFAULT_ORDER = "anyOrder";
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -98,7 +96,12 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
-		defaultOptions: [DEFAULT_ORDER],
+		defaultOptions: [
+			"anyOrder",
+			{
+				enforceForTSTypes: false,
+			},
+		],
 
 		docs: {
 			description:
@@ -129,10 +132,8 @@ module.exports = {
 	},
 
 	create(context) {
-		const order = context.options[0] ?? DEFAULT_ORDER;
-		const enforceForTSTypes =
-			context.options[1]?.enforceForTSTypes ?? false;
-		const sourceCode = context.sourceCode;
+		const [order, { enforceForTSTypes }] = context.options;
+		const { sourceCode } = context;
 
 		/**
 		 * Reports the given accessor pair.

package/lib/rules/indent-legacy.js

@@ -1162,7 +1162,7 @@ module.exports = {
 		 * @returns {boolean} the result
 		 */
 		function isWrappedInParenthesis(node) {
-			const regex = /^return\s*?\(\s*?\);*?/u;
+			const regex = /^return\s*\(\s*\)/u;
 
 			const statementWithoutArgument = sourceCode
 				.getText(node)

package/lib/rules/index.js

@@ -293,6 +293,7 @@ module.exports = new LazyLoadingRuleMap(
 		"prefer-rest-params": () => require("./prefer-rest-params"),
 		"prefer-spread": () => require("./prefer-spread"),
 		"prefer-template": () => require("./prefer-template"),
+		"preserve-caught-error": () => require("./preserve-caught-error"),
 		"quote-props": () => require("./quote-props"),
 		quotes: () => require("./quotes"),
 		radix: () => require("./radix"),

package/lib/rules/no-alert.js

@@ -24,7 +24,7 @@ const {
  * @returns {boolean} Whether or not the name is prohibited.
  */
 function isProhibitedIdentifier(name) {
-	return /^(alert|confirm|prompt)$/u.test(name);
+	return /^(?:alert|confirm|prompt)$/u.test(name);
 }
 
 /**

package/lib/rules/no-empty-function.js

@@ -105,6 +105,7 @@ module.exports = {
 	meta: {
 		dialects: ["javascript", "typescript"],
 		language: "javascript",
+		hasSuggestions: true,
 		type: "suggestion",
 
 		defaultOptions: [{ allow: [] }],
@@ -131,6 +132,7 @@ module.exports = {
 
 		messages: {
 			unexpected: "Unexpected empty {{name}}.",
+			suggestComment: "Add comment inside empty {{name}}.",
 		},
 	},
 
@@ -162,7 +164,7 @@ module.exports = {
 				}
 			}
 
-			if (/(g|s)etters|methods$/iu.test(kind)) {
+			if (/(?:g|s)etters|methods$/iu.test(kind)) {
 				if (
 					(node.parent.decorators?.length &&
 						allow.includes("decoratedFunctions")) ||
@@ -204,6 +206,23 @@ module.exports = {
 					loc: node.body.loc,
 					messageId: "unexpected",
 					data: { name },
+					suggest: [
+						{
+							messageId: "suggestComment",
+							data: { name },
+							fix(fixer) {
+								const range = [
+									node.body.range[0] + 1,
+									node.body.range[1] - 1,
+								];
+
+								return fixer.replaceTextRange(
+									range,
+									" /* empty */ ",
+								);
+							},
+						},
+					],
 				});
 			}
 		}

package/lib/rules/no-empty-static-block.js

@@ -11,6 +11,7 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		hasSuggestions: true,
 		type: "suggestion",
 
 		docs: {
@@ -23,6 +24,7 @@ module.exports = {
 
 		messages: {
 			unexpected: "Unexpected empty static block.",
+			suggestComment: "Add comment inside empty static block.",
 		},
 	},
 
@@ -32,14 +34,36 @@ module.exports = {
 		return {
 			StaticBlock(node) {
 				if (node.body.length === 0) {
+					const openingBrace = sourceCode.getFirstToken(node, {
+						skip: 1,
+					});
 					const closingBrace = sourceCode.getLastToken(node);
 
 					if (
 						sourceCode.getCommentsBefore(closingBrace).length === 0
 					) {
 						context.report({
-							node,
+							loc: {
+								start: openingBrace.loc.start,
+								end: closingBrace.loc.end,
+							},
 							messageId: "unexpected",
+							suggest: [
+								{
+									messageId: "suggestComment",
+									fix(fixer) {
+										const range = [
+											openingBrace.range[1],
+											closingBrace.range[0],
+										];
+
+										return fixer.replaceTextRange(
+											range,
+											" /* empty */ ",
+										);
+									},
+								},
+							],
 						});
 					}
 				}

package/lib/rules/no-empty.js

@@ -104,10 +104,47 @@ module.exports = {
 					typeof node.cases === "undefined" ||
 					node.cases.length === 0
 				) {
+					const openingBrace = sourceCode.getTokenAfter(
+						node.discriminant,
+						astUtils.isOpeningBraceToken,
+					);
+
+					const closingBrace = sourceCode.getLastToken(node);
+
+					if (
+						sourceCode.commentsExistBetween(
+							openingBrace,
+							closingBrace,
+						)
+					) {
+						return;
+					}
+
 					context.report({
 						node,
+						loc: {
+							start: openingBrace.loc.start,
+							end: closingBrace.loc.end,
+						},
 						messageId: "unexpected",
 						data: { type: "switch" },
+						suggest: [
+							{
+								messageId: "suggestComment",
+								data: { type: "switch" },
+								fix(fixer) {
+									const range = [
+										openingBrace.range[1],
+										closingBrace.range[0],
+									];
+
+									return fixer.replaceTextRange(
+										range,
+										" /* empty */ ",
+									);
+								},
+							},
+						],
 					});
 				}
 			},

package/lib/rules/no-eval.js

@@ -226,7 +226,9 @@ module.exports = {
 
 			Program(node) {
 				const scope = sourceCode.getScope(node),
-					features = context.parserOptions.ecmaFeatures || {},
+					features =
+						context.languageOptions.parserOptions.ecmaFeatures ||
+						{},
 					strict =
 						scope.isStrict ||
 						node.sourceType === "module" ||

package/lib/rules/no-irregular-whitespace.js

@@ -19,8 +19,8 @@ const astUtils = require("./utils/ast-utils");
 const ALL_IRREGULARS =
 	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
 const IRREGULAR_WHITESPACE =
-	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gmu;
-const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gmu;
+	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu;
+const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu;
 const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
 
 //------------------------------------------------------------------------------

package/lib/rules/no-loss-of-precision.js

@@ -189,9 +189,32 @@ module.exports = {
 		 * @returns {boolean} true if they do not match
 		 */
 		function baseTenLosesPrecision(node) {
-			const normalizedRawNumber = convertNumberToScientificNotation(
-				getRaw(node),
-			);
+			const rawNumber = getRaw(node).toLowerCase();
+
+			/*
+			 * If trailing zeros equal the exponent, this is a valid representation
+			 * like "9.00e2" where 00 = 2 (meaning 9.00 * 10^2 = 900)
+			 * https://github.com/eslint/eslint/issues/19957
+			 */
+			if (rawNumber.includes(".") && rawNumber.includes("e")) {
+				const parts = rawNumber.split("e");
+				const coefficient = parts[0];
+				const exponent = parseInt(parts[1], 10);
+
+				// Count trailing zeros after decimal
+				const decimalParts = coefficient.split(".");
+				if (decimalParts.length === 2) {
+					const decimalPart = decimalParts[1];
+					const trailingZeros = decimalPart.match(/0*$/u)[0].length;
+
+					if (trailingZeros === exponent) {
+						return false;
+					}
+				}
+			}
+
+			const normalizedRawNumber =
+				convertNumberToScientificNotation(rawNumber);
 			const requestedPrecision = normalizedRawNumber
 				.split("e")[0]
 				.replace(".", "").length;

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -99,6 +99,7 @@ module.exports = {
 					 * At least one space followed by a tab
 					 * before non-tab/-space characters begin.
 					 */
+					// eslint-disable-next-line regexp/no-empty-lookarounds-assertion -- False positive
 					regex = /^(?=(\t*))\1(?=( +))\2\t/u;
 				}
 

package/lib/rules/no-octal.js

@@ -30,10 +30,7 @@ module.exports = {
 	create(context) {
 		return {
 			Literal(node) {
-				if (
-					typeof node.value === "number" &&
-					/^0[0-9]/u.test(node.raw)
-				) {
+				if (typeof node.value === "number" && /^0\d/u.test(node.raw)) {
 					context.report({
 						node,
 						messageId: "noOctal",

package/lib/rules/no-trailing-spaces.js

@@ -82,7 +82,8 @@ module.exports = {
 	create(context) {
 		const sourceCode = context.sourceCode;
 
-		const BLANK_CLASS = "[ \t\u00a0\u2000-\u200b\u3000]",
+		const BLANK_CLASS =
+				"[ \t\u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u3000]",
 			SKIP_BLANK = `^${BLANK_CLASS}*$`,
 			NONBLANK = `${BLANK_CLASS}+$`;
 

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

@@ -387,7 +387,7 @@ module.exports = {
 				const value = isTemplateElement
 					? sourceCode.getText(node)
 					: node.raw;
-				const pattern = /\\[^\d]/gu;
+				const pattern = /\\\D/gu;
 				let match;
 
 				while ((match = pattern.exec(value))) {

package/lib/rules/prefer-regex-literals.js

@@ -522,7 +522,7 @@ module.exports = {
 						}
 
 						if (
-							!/^[-a-zA-Z0-9\\[\](){} \t\r\n\v\f!@#$%^&*+^_=/~`.><?,'"|:;]*$/u.test(
+							!/^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.><?,'"|:;]*$/u.test(
 								regexContent,
 							)
 						) {