eslint 9.32.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-restricted-globals.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -16,10 +22,34 @@ const TYPE_NODES = new Set([
 	"TSQualifiedName",
 ]);
 
+const GLOBAL_OBJECTS = new Set(["globalThis", "self", "window"]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const arrayOfGlobals = {
+	type: "array",
+	items: {
+		oneOf: [
+			{
+				type: "string",
+			},
+			{
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					message: { type: "string" },
+				},
+				required: ["name"],
+				additionalProperties: false,
+			},
+		],
+	},
+	uniqueItems: true,
+	minItems: 0,
+};
+
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
@@ -34,25 +64,33 @@ module.exports = {
 		},
 
 		schema: {
-			type: "array",
-			items: {
-				oneOf: [
-					{
-						type: "string",
-					},
-					{
-						type: "object",
-						properties: {
-							name: { type: "string" },
-							message: { type: "string" },
+			anyOf: [
+				arrayOfGlobals,
+				{
+					type: "array",
+					items: [
+						{
+							type: "object",
+							properties: {
+								globals: arrayOfGlobals,
+								checkGlobalObject: {
+									type: "boolean",
+								},
+								globalObjects: {
+									type: "array",
+									items: {
+										type: "string",
+									},
+									uniqueItems: true,
+								},
+							},
+							required: ["globals"],
+							additionalProperties: false,
 						},
-						required: ["name"],
-						additionalProperties: false,
-					},
-				],
-			},
-			uniqueItems: true,
-			minItems: 0,
+					],
+					additionalItems: false,
+				},
+			],
 		},
 
 		messages: {
@@ -63,14 +101,33 @@ module.exports = {
 	},
 
 	create(context) {
-		const sourceCode = context.sourceCode;
+		const { sourceCode, options } = context;
+
+		const isGlobalsObject =
+			typeof options[0] === "object" &&
+			Object.hasOwn(options[0], "globals");
+
+		const restrictedGlobals = isGlobalsObject
+			? options[0].globals
+			: options;
+		const checkGlobalObject = isGlobalsObject
+			? options[0].checkGlobalObject
+			: false;
+		const userGlobalObjects = isGlobalsObject
+			? options[0].globalObjects || []
+			: [];
+
+		const globalObjects = new Set([
+			...GLOBAL_OBJECTS,
+			...userGlobalObjects,
+		]);
 
 		// If no globals are restricted, we don't need to do anything
-		if (context.options.length === 0) {
+		if (restrictedGlobals.length === 0) {
 			return {};
 		}
 
-		const restrictedGlobalMessages = context.options.reduce(
+		const restrictedGlobalMessages = restrictedGlobals.reduce(
 			(memo, option) => {
 				if (typeof option === "string") {
 					memo[option] = null;
@@ -151,6 +208,59 @@ module.exports = {
 					}
 				});
 			},
+
+			"Program:exit"(node) {
+				if (!checkGlobalObject) {
+					return;
+				}
+
+				const globalScope = sourceCode.getScope(node);
+				globalObjects.forEach(globalObjectName => {
+					const variable = astUtils.getVariableByName(
+						globalScope,
+						globalObjectName,
+					);
+
+					if (!variable) {
+						return;
+					}
+
+					variable.references.forEach(reference => {
+						const identifier = reference.identifier;
+						let parent = identifier.parent;
+
+						// To detect code like `window.window.Promise`.
+						while (
+							astUtils.isSpecificMemberAccess(
+								parent,
+								null,
+								globalObjectName,
+							)
+						) {
+							parent = parent.parent;
+						}
+
+						const propertyName =
+							astUtils.getStaticPropertyName(parent);
+						if (propertyName && isRestricted(propertyName)) {
+							const customMessage =
+								restrictedGlobalMessages[propertyName];
+							const messageId = customMessage
+								? "customMessage"
+								: "defaultMessage";
+
+							context.report({
+								node: parent.property,
+								messageId,
+								data: {
+									name: propertyName,
+									customMessage,
+								},
+							});
+						}
+					});
+				});
+			},
 		};
 	},
 };

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))) {