eslint 9.33.0 → 9.34.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/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/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/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

@@ -162,7 +162,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")) ||

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);
+
+			/*
+			 * 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,
 							)
 						) {

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

@@ -58,7 +58,7 @@ const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
 // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
 const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN =
-	/^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
+	/^(?:[^\\]|\\.)*\\(?:[1-9]|0\d)/su;
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 

package/lib/rules/utils/char-source.js

@@ -85,7 +85,7 @@ function readHexSequence(reader, length) {
  * @returns {string} A code unit.
  */
 function readUnicodeSequence(reader) {
-	const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+	const regExp = /\{(?<hexDigits>[\dA-F]+)\}/iuy;
 
 	regExp.lastIndex = reader.pos;
 	const match = regExp.exec(reader.source);

package/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-	return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
+	return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-	return /^(==|===)$/u.test(operator);
+	return /^(?:==|===)$/u.test(operator);
 }
 
 /**

package/lib/services/warning-service.js

@@ -80,6 +80,19 @@ class WarningService {
 	emitInactiveFlagWarning(flag, message) {
 		this.emitWarning(message, `ESLintInactiveFlag_${flag}`);
 	}
+
+	/**
+	 * Emits a warning when a suboptimal concurrency setting is detected.
+	 * Currently, this is only used to warn when the net linting ratio is low.
+	 * @param {string} notice A notice about how to improve performance.
+	 * @returns {void}
+	 */
+	emitPoorConcurrencyWarning(notice) {
+		this.emitWarning(
+			`You may ${notice} to improve performance.`,
+			"ESLintPoorConcurrencyWarning",
+		);
+	}
 }
 
 module.exports = { WarningService };

package/lib/shared/naming.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-const NAMESPACE_REGEX = /^@.*\//iu;
+const NAMESPACE_REGEX = /^@.*\//u;
 
 /**
  * Brings package name to correct format based on prefix