eslint 9.27.0 → 9.28.0

package/lib/cli.js

@@ -439,10 +439,8 @@ const cli = {
 		debug("Using flat config?", usingFlatConfig);
 
 		if (allowFlatConfig && !usingFlatConfig) {
-			process.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",
-			);
+			const { WarningService } = require("./services/warning-service");
+			new WarningService().emitESLintRCWarning();
 		}
 
 		const CLIOptions = createCLIOptions(usingFlatConfig);
@@ -736,17 +734,21 @@ const cli = {
 				);
 			}
 
-			const unusedSuppressionsCount =
-				Object.keys(unusedSuppressions).length;
+			if (!options.passOnUnprunedSuppressions) {
+				const unusedSuppressionsCount =
+					Object.keys(unusedSuppressions).length;
 
-			if (unusedSuppressionsCount > 0) {
-				log.error(
-					"There are suppressions left that do not occur anymore. Consider re-running the command with `--prune-suppressions`.",
-				);
-				debug(JSON.stringify(unusedSuppressions, null, 2));
+				if (unusedSuppressionsCount > 0) {
+					log.error(
+						"There are suppressions left that do not occur anymore. Consider re-running the command with `--prune-suppressions`.",
+					);
+					debug(JSON.stringify(unusedSuppressions, null, 2));
+
+					return 2;
+				}
 			}
 
-			if (shouldExitForFatalErrors || unusedSuppressionsCount > 0) {
+			if (shouldExitForFatalErrors) {
 				return 2;
 			}
 

package/lib/config/config-loader.js

@@ -15,6 +15,7 @@ const findUp = require("find-up");
 const { pathToFileURL } = require("node:url");
 const debug = require("debug")("eslint:config-loader");
 const { FlatConfigArray } = require("./flat-config-array");
+const { WarningService } = require("../services/warning-service");
 
 //-----------------------------------------------------------------------------
 // Types
@@ -32,6 +33,7 @@ const { FlatConfigArray } = require("./flat-config-array");
  * @property {Array<string>} [ignorePatterns] The ignore patterns to use.
  * @property {Config|Array<Config>} [overrideConfig] The override config to use.
  * @property {boolean} [hasUnstableNativeNodeJsTSConfigFlag] The flag to indicate whether the `unstable_native_nodejs_ts_config` flag is enabled.
+ * @property {WarningService} [warningService] The warning service to use.
  */
 
 //------------------------------------------------------------------------------
@@ -137,12 +139,13 @@ function isNativeTypeScriptSupportEnabled() {
  * @since 9.24.0
  */
 async function loadTypeScriptConfigFileWithJiti(filePath, fileURL, mtime) {
-	// eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing
-	const { createJiti } = await ConfigLoader.loadJiti().catch(() => {
-		throw new Error(
-			"The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.",
-		);
-	});
+	const { createJiti, version: jitiVersion } =
+		// eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing
+		await ConfigLoader.loadJiti().catch(() => {
+			throw new Error(
+				"The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.",
+			);
+		});
 
 	// `createJiti` was added in jiti v2.
 	if (typeof createJiti !== "function") {
@@ -155,11 +158,15 @@ async function loadTypeScriptConfigFileWithJiti(filePath, fileURL, mtime) {
 	 * Disabling `moduleCache` allows us to reload a
 	 * config file when the last modified timestamp changes.
 	 */
-
-	const jiti = createJiti(__filename, {
+	const jitiOptions = {
 		moduleCache: false,
-		interopDefault: false,
-	});
+	};
+
+	if (jitiVersion.startsWith("2.1.")) {
+		jitiOptions.interopDefault = false;
+	}
+
+	const jiti = createJiti(__filename, jitiOptions);
 	const config = await jiti.import(fileURL.href);
 
 	importedConfigFileModificationTime.set(filePath, mtime);
@@ -301,7 +308,9 @@ class ConfigLoader {
 	 * @param {ConfigLoaderOptions} options The options to use when loading configuration files.
 	 */
 	constructor(options) {
-		this.#options = options;
+		this.#options = options.warningService
+			? options
+			: { ...options, warningService: new WarningService() };
 	}
 
 	/**
@@ -494,11 +503,12 @@ class ConfigLoader {
 
 	/**
 	 * Used to import the jiti dependency. This method is exposed internally for testing purposes.
-	 * @returns {Promise<Record<string, unknown>>} A promise that fulfills with a module object
-	 *      or rejects with an error if jiti is not found.
+	 * @returns {Promise<{createJiti: Function|undefined, version: string;}>} A promise that fulfills with an object containing the jiti module's createJiti function and version.
 	 */
-	static loadJiti() {
-		return import("jiti");
+	static async loadJiti() {
+		const { createJiti } = await import("jiti");
+		const version = require("jiti/package.json").version;
+		return { createJiti, version };
 	}
 
 	/**
@@ -561,6 +571,7 @@ class ConfigLoader {
 			overrideConfig,
 			hasUnstableNativeNodeJsTSConfigFlag = false,
 			defaultConfigs = [],
+			warningService,
 		} = options;
 
 		debug(
@@ -622,10 +633,7 @@ class ConfigLoader {
 			}
 
 			if (emptyConfig) {
-				globalThis.process?.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",
-				);
+				warningService.emitEmptyConfigWarning(configFilePath);
 			}
 		}
 
@@ -713,8 +721,11 @@ class LegacyConfigLoader extends ConfigLoader {
 	 * @param {ConfigLoaderOptions} options The options to use when loading configuration files.
 	 */
 	constructor(options) {
-		super(options);
-		this.#options = options;
+		const normalizedOptions = options.warningService
+			? options
+			: { ...options, warningService: new WarningService() };
+		super(normalizedOptions);
+		this.#options = normalizedOptions;
 	}
 
 	/**

package/lib/config/config.js

@@ -265,6 +265,27 @@ function getObjectId(object) {
 	return name;
 }
 
+/**
+ * Asserts that a value is not a function.
+ * @param {any} value The value to check.
+ * @param {string} key The key of the value in the object.
+ * @param {string} objectKey The key of the object being checked.
+ * @returns {void}
+ * @throws {TypeError} If the value is a function.
+ */
+function assertNotFunction(value, key, objectKey) {
+	if (typeof value === "function") {
+		const error = new TypeError(
+			`Cannot serialize key "${key}" in "${objectKey}": Function values are not supported.`,
+		);
+
+		error.messageTemplate = "config-serialize-function";
+		error.messageData = { key, objectKey };
+
+		throw error;
+	}
+}
+
 /**
  * Converts a languageOptions object to a JSON representation.
  * @param {Record<string, any>} languageOptions The options to create a JSON
@@ -274,6 +295,14 @@ function getObjectId(object) {
  * @throws {TypeError} If a function is found in the languageOptions.
  */
 function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
+	if (typeof languageOptions.toJSON === "function") {
+		const result = languageOptions.toJSON();
+
+		assertNotFunction(result, "toJSON", objectKey);
+
+		return result;
+	}
+
 	const result = {};
 
 	for (const [key, value] of Object.entries(languageOptions)) {
@@ -281,7 +310,10 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 			if (typeof value === "object") {
 				const name = getObjectId(value);
 
-				if (name && hasMethod(value)) {
+				if (typeof value.toJSON === "function") {
+					result[key] = value.toJSON();
+					assertNotFunction(result[key], key, objectKey);
+				} else if (name && hasMethod(value)) {
 					result[key] = name;
 				} else {
 					result[key] = languageOptionsToJSON(value, key);
@@ -289,16 +321,7 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 				continue;
 			}
 
-			if (typeof value === "function") {
-				const error = new TypeError(
-					`Cannot serialize key "${key}" in ${objectKey}: Function values are not supported.`,
-				);
-
-				error.messageTemplate = "config-serialize-function";
-				error.messageData = { key, objectKey };
-
-				throw error;
-			}
+			assertNotFunction(value, key, objectKey);
 		}
 
 		result[key] = value;

package/lib/eslint/eslint.js

@@ -40,6 +40,7 @@ const { pathToFileURL } = require("node:url");
 const LintResultCache = require("../cli-engine/lint-result-cache");
 const { Retrier } = require("@humanwhocodes/retry");
 const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
+const { WarningService } = require("../services/warning-service");
 
 /*
  * This is necessary to allow overwriting writeFile for testing purposes.
@@ -431,10 +432,12 @@ class ESLint {
 	constructor(options = {}) {
 		const defaultConfigs = [];
 		const processedOptions = processOptions(options);
+		const warningService = new WarningService();
 		const linter = new Linter({
 			cwd: processedOptions.cwd,
 			configType: "flat",
 			flags: mergeEnvironmentFlags(processedOptions.flags),
+			warningService,
 		});
 
 		const cacheFilePath = getCacheFile(
@@ -457,6 +460,7 @@ class ESLint {
 			hasUnstableNativeNodeJsTSConfigFlag: linter.hasFlag(
 				"unstable_native_nodejs_ts_config",
 			),
+			warningService,
 		};
 
 		this.#configLoader = linter.hasFlag("unstable_config_lookup_from_file")
@@ -496,10 +500,7 @@ class ESLint {
 
 		// Check for the .eslintignore file, and warn if it's present.
 		if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) {
-			process.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",
-			);
+			warningService.emitESLintIgnoreWarning();
 		}
 	}
 

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

@@ -316,6 +316,36 @@ function addDeclaredGlobals(
 
 		return true;
 	});
+
+	/*
+	 * "implicit" contains information about implicit global variables (those created
+	 * implicitly by assigning values to undeclared variables in non-strict code).
+	 * Since we augment the global scope using configuration, we need to remove
+	 * the ones that were added by configuration, as they are either built-in
+	 * or declared elsewhere, therefore not implicit.
+	 * Since the "implicit" property was not documented, first we'll check if it exists
+	 * because it's possible that not all custom scope managers create this property.
+	 * If it exists, we assume it has properties `variables` and `set`. Property
+	 * `left` is considered optional (for example, typescript-eslint's scope manage
+	 * has this property named `leftToBeResolved`).
+	 */
+	const { implicit } = globalScope;
+	if (typeof implicit === "object" && implicit !== null) {
+		implicit.variables = implicit.variables.filter(variable => {
+			const name = variable.name;
+			if (globalScope.set.has(name)) {
+				implicit.set.delete(name);
+				return false;
+			}
+			return true;
+		});
+
+		if (implicit.left) {
+			implicit.left = implicit.left.filter(
+				reference => !globalScope.set.has(reference.identifier.name),
+			);
+		}
+	}
 }
 
 /**

package/lib/linter/linter.js

@@ -27,7 +27,6 @@ const path = require("node:path"),
 	{ SourceCode } = require("../languages/js/source-code"),
 	applyDisableDirectives = require("./apply-disable-directives"),
 	{ ConfigCommentParser } = require("@eslint/plugin-kit"),
-	NodeEventGenerator = require("./node-event-generator"),
 	createReportTranslator = require("./report-translator"),
 	Rules = require("./rules"),
 	createEmitter = require("./safe-emitter"),
@@ -65,8 +64,8 @@ const { FileContext } = require("./file-context");
 const { ProcessorService } = require("../services/processor-service");
 const { containsDifferentProperty } = require("../shared/option-utils");
 const { Config } = require("../config/config");
-const STEP_KIND_VISIT = 1;
-const STEP_KIND_CALL = 2;
+const { WarningService } = require("../services/warning-service");
+const { SourceCodeTraverser } = require("./source-code-traverser");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -113,6 +112,7 @@ const STEP_KIND_CALL = 2;
  * @property {Map<string, Parser>} parserMap The loaded parsers.
  * @property {{ passes: TimePass[]; }} times The times spent on applying a rule to a file (see `stats` option).
  * @property {Rules} ruleMap The loaded rules.
+ * @property {WarningService} warningService The warning service.
  */
 
 /**
@@ -1177,9 +1177,6 @@ function runRules(
 ) {
 	const emitter = createEmitter();
 
-	// must happen first to assign all node.parent properties
-	const eventQueue = sourceCode.traverse();
-
 	/*
 	 * Create a frozen object with the ruleContext properties and methods that are shared by all rules.
 	 * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the
@@ -1199,6 +1196,7 @@ function runRules(
 	});
 
 	const lintingProblems = [];
+	const steps = sourceCode.traverse();
 
 	Object.keys(configuredRules).forEach(ruleId => {
 		const severity = Config.getRuleNumericSeverity(configuredRules[ruleId]);
@@ -1345,40 +1343,9 @@ function runRules(
 		});
 	});
 
-	const eventGenerator = new NodeEventGenerator(emitter, {
-		visitorKeys: sourceCode.visitorKeys ?? language.visitorKeys,
-		fallback: Traverser.getKeys,
-		matchClass: language.matchesSelectorClass ?? (() => false),
-		nodeTypeKey: language.nodeTypeKey,
-	});
-
-	for (const step of eventQueue) {
-		switch (step.kind) {
-			case STEP_KIND_VISIT: {
-				try {
-					if (step.phase === 1) {
-						eventGenerator.enterNode(step.target);
-					} else {
-						eventGenerator.leaveNode(step.target);
-					}
-				} catch (err) {
-					err.currentNode = step.target;
-					throw err;
-				}
-				break;
-			}
-
-			case STEP_KIND_CALL: {
-				emitter.emit(step.target, ...step.args);
-				break;
-			}
+	const traverser = SourceCodeTraverser.getInstance(language);
 
-			default:
-				throw new Error(
-					`Invalid traversal step found: "${step.type}".`,
-				);
-		}
-	}
+	traverser.traverseSync(sourceCode, emitter, { steps });
 
 	return lintingProblems;
 }
@@ -1483,8 +1450,14 @@ class Linter {
 	 * @param {string} [config.cwd] path to a directory that should be considered as the current working directory, can be undefined.
 	 * @param {Array<string>} [config.flags] the feature flags to enable.
 	 * @param {"flat"|"eslintrc"} [config.configType="flat"] the type of config used.
+	 * @param {WarningService} [config.warningService] The warning service to use.
 	 */
-	constructor({ cwd, configType = "flat", flags = [] } = {}) {
+	constructor({
+		cwd,
+		configType = "flat",
+		flags = [],
+		warningService = new WarningService(),
+	} = {}) {
 		const processedFlags = [];
 
 		flags.forEach(flag => {
@@ -1492,11 +1465,10 @@ class Linter {
 				const inactiveFlagData = inactiveFlags.get(flag);
 				const inactivityReason =
 					getInactivityReasonMessage(inactiveFlagData);
+				const message = `The flag '${flag}' is inactive: ${inactivityReason}`;
 
 				if (typeof inactiveFlagData.replacedBy === "undefined") {
-					throw new Error(
-						`The flag '${flag}' is inactive: ${inactivityReason}`,
-					);
+					throw new Error(message);
 				}
 
 				// if there's a replacement, enable it instead of original
@@ -1504,10 +1476,7 @@ class Linter {
 					processedFlags.push(inactiveFlagData.replacedBy);
 				}
 
-				globalThis.process?.emitWarning?.(
-					`The flag '${flag}' is inactive: ${inactivityReason}`,
-					`ESLintInactiveFlag_${flag}`,
-				);
+				warningService.emitInactiveFlagWarning(flag, message);
 
 				return;
 			}
@@ -1528,6 +1497,7 @@ class Linter {
 			configType, // TODO: Remove after flat config conversion
 			parserMap: new Map([["espree", espree]]),
 			ruleMap: new Rules(),
+			warningService,
 		});
 
 		this.version = pkg.version;
@@ -2710,6 +2680,14 @@ class Linter {
 			options && typeof options.fix !== "undefined" ? options.fix : true;
 		const stats = options?.stats;
 
+		const slots = internalSlotsMap.get(this);
+
+		// Remove lint times from the last run.
+		if (stats) {
+			delete slots.times;
+			slots.fixPasses = 0;
+		}
+
 		/**
 		 * This loop continues until one of the following is true:
 		 *
@@ -2719,14 +2697,6 @@ class Linter {
 		 * That means anytime a fix is successfully applied, there will be another pass.
 		 * Essentially, guaranteeing a minimum of two passes.
 		 */
-		const slots = internalSlotsMap.get(this);
-
-		// Remove lint times from the last run.
-		if (stats) {
-			delete slots.times;
-			slots.fixPasses = 0;
-		}
-
 		do {
 			passNumber++;
 			let tTotal;
@@ -2798,9 +2768,8 @@ class Linter {
 				debug(
 					`Circular fixes detected after pass ${passNumber}. Exiting fix loop.`,
 				);
-				globalThis?.process?.emitWarning?.(
-					`Circular fixes detected while fixing ${options?.filename ?? "text"}. It is likely that you have conflicting rules in your configuration.`,
-					"ESLintCircularFixesWarning",
+				slots.warningService.emitCircularFixesWarning(
+					options?.filename ?? "text",
 				);
 				break;
 			}