eslint 9.27.0 → 9.29.0

package/lib/linter/code-path-analysis/code-path-analyzer.js

@@ -196,7 +196,7 @@ function forwardCurrentToHead(analyzer, node) {
 
 			debug.dump(`${eventName} ${currentSegment.id}`);
 
-			analyzer.emitter.emit(eventName, currentSegment, node);
+			analyzer.emit(eventName, [currentSegment, node]);
 		}
 	}
 
@@ -215,7 +215,7 @@ function forwardCurrentToHead(analyzer, node) {
 
 			debug.dump(`${eventName} ${headSegment.id}`);
 			CodePathSegment.markUsed(headSegment);
-			analyzer.emitter.emit(eventName, headSegment, node);
+			analyzer.emit(eventName, [headSegment, node]);
 		}
 	}
 }
@@ -239,7 +239,7 @@ function leaveFromCurrentSegment(analyzer, node) {
 
 		debug.dump(`${eventName} ${currentSegment.id}`);
 
-		analyzer.emitter.emit(eventName, currentSegment, node);
+		analyzer.emit(eventName, [currentSegment, node]);
 	}
 
 	state.currentSegments = [];
@@ -416,7 +416,7 @@ function processCodePathToEnter(analyzer, node) {
 
 		// Emits onCodePathStart events.
 		debug.dump(`onCodePathStart ${codePath.id}`);
-		analyzer.emitter.emit("onCodePathStart", codePath, node);
+		analyzer.emit("onCodePathStart", [codePath, node]);
 	}
 
 	/*
@@ -681,7 +681,7 @@ function postprocess(analyzer, node) {
 
 		// Emits onCodePathEnd event of this code path.
 		debug.dump(`onCodePathEnd ${codePath.id}`);
-		analyzer.emitter.emit("onCodePathEnd", codePath, node);
+		analyzer.emit("onCodePathEnd", [codePath, node]);
 		debug.dumpDot(codePath);
 
 		codePath = analyzer.codePath = analyzer.codePath.upper;
@@ -747,7 +747,7 @@ class CodePathAnalyzer {
 	 */
 	constructor(eventGenerator) {
 		this.original = eventGenerator;
-		this.emitter = eventGenerator.emitter;
+		this.emit = eventGenerator.emit;
 		this.codePath = null;
 		this.idGenerator = new IdGenerator("s");
 		this.currentNode = null;
@@ -816,12 +816,11 @@ class CodePathAnalyzer {
 			debug.dump(
 				`onCodePathSegmentLoop ${fromSegment.id} -> ${toSegment.id}`,
 			);
-			this.emitter.emit(
-				"onCodePathSegmentLoop",
+			this.emit("onCodePathSegmentLoop", [
 				fromSegment,
 				toSegment,
 				this.currentNode,
-			);
+			]);
 		}
 	}
 }

package/lib/linter/linter.js

@@ -27,11 +27,10 @@ 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"),
 	SourceCodeFixer = require("./source-code-fixer"),
+	{ SourceCodeVisitor } = require("./source-code-visitor"),
 	timing = require("./timing"),
 	ruleReplacements = require("../../conf/replacements.json");
 const { FlatConfigArray } = require("../config/flat-config-array");
@@ -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.
  */
 
 /**
@@ -1175,10 +1175,7 @@ function runRules(
 	stats,
 	slots,
 ) {
-	const emitter = createEmitter();
-
-	// must happen first to assign all node.parent properties
-	const eventQueue = sourceCode.traverse();
+	const visitor = new SourceCodeVisitor();
 
 	/*
 	 * Create a frozen object with the ruleContext properties and methods that are shared by all rules.
@@ -1199,6 +1196,7 @@ function runRules(
 	});
 
 	const lintingProblems = [];
+	const steps = sourceCode.traverse();
 
 	Object.keys(configuredRules).forEach(ruleId => {
 		const severity = Config.getRuleNumericSeverity(configuredRules[ruleId]);
@@ -1341,44 +1339,13 @@ function runRules(
 					? timing.time(ruleId, ruleListeners[selector], stats)
 					: ruleListeners[selector];
 
-			emitter.on(selector, addRuleErrorHandler(ruleListener));
+			visitor.add(selector, addRuleErrorHandler(ruleListener));
 		});
 	});
 
-	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, visitor, { 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;
 			}

package/lib/linter/source-code-traverser.js

@@ -0,0 +1,327 @@
+/**
+ * @fileoverview Traverser for SourceCode objects.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { parse, matches } = require("./esquery");
+const vk = require("eslint-visitor-keys");
+
+//-----------------------------------------------------------------------------
+// Typedefs
+//-----------------------------------------------------------------------------
+
+/**
+ * @import { ESQueryParsedSelector } from "./esquery.js";
+ * @import { Language, SourceCode } from "@eslint/core";
+ * @import { SourceCodeVisitor } from "./source-code-visitor.js";
+ */
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const STEP_KIND_VISIT = 1;
+const STEP_KIND_CALL = 2;
+
+/**
+ * Compares two ESQuery selectors by specificity.
+ * @param {ESQueryParsedSelector} a The first selector to compare.
+ * @param {ESQueryParsedSelector} b The second selector to compare.
+ * @returns {number} A negative number if `a` is less specific than `b` or they are equally specific and `a` <= `b` alphabetically, a positive number if `a` is more specific than `b`.
+ */
+function compareSpecificity(a, b) {
+	return a.compare(b);
+}
+
+/**
+ * Helper to wrap ESQuery operations.
+ */
+class ESQueryHelper {
+	/**
+	 * Creates a new instance.
+	 * @param {SourceCodeVisitor} visitor The visitor containing the functions to call.
+	 * @param {ESQueryOptions} esqueryOptions `esquery` options for traversing custom nodes.
+	 * @returns {NodeEventGenerator} new instance
+	 */
+	constructor(visitor, esqueryOptions) {
+		/**
+		 * The emitter to use during traversal.
+		 * @type {SourceCodeVisitor}
+		 */
+		this.visitor = visitor;
+
+		/**
+		 * The options for `esquery` to use during matching.
+		 * @type {ESQueryOptions}
+		 */
+		this.esqueryOptions = esqueryOptions;
+
+		/**
+		 * A map of node type to selectors targeting that node type on the
+		 * enter phase of traversal.
+		 * @type {Map<string, ESQueryParsedSelector[]>}
+		 */
+		this.enterSelectorsByNodeType = new Map();
+
+		/**
+		 * A map of node type to selectors targeting that node type on the
+		 * exit phase of traversal.
+		 * @type {Map<string, ESQueryParsedSelector[]>}
+		 */
+		this.exitSelectorsByNodeType = new Map();
+
+		/**
+		 * An array of selectors that match any node type on the
+		 * enter phase of traversal.
+		 * @type {ESQueryParsedSelector[]}
+		 */
+		this.anyTypeEnterSelectors = [];
+
+		/**
+		 * An array of selectors that match any node type on the
+		 * exit phase of traversal.
+		 * @type {ESQueryParsedSelector[]}
+		 */
+		this.anyTypeExitSelectors = [];
+
+		visitor.forEachName(rawSelector => {
+			const selector = parse(rawSelector);
+
+			/*
+			 * If this selector has identified specific node types,
+			 * add it to the map for these node types for faster lookup.
+			 */
+			if (selector.nodeTypes) {
+				const typeMap = selector.isExit
+					? this.exitSelectorsByNodeType
+					: this.enterSelectorsByNodeType;
+
+				selector.nodeTypes.forEach(nodeType => {
+					if (!typeMap.has(nodeType)) {
+						typeMap.set(nodeType, []);
+					}
+					typeMap.get(nodeType).push(selector);
+				});
+				return;
+			}
+
+			/*
+			 * Remaining selectors are added to the "any type" selectors
+			 * list for the appropriate phase of traversal. This ensures
+			 * that all selectors will still be applied even if no
+			 * specific node type is matched.
+			 */
+			const selectors = selector.isExit
+				? this.anyTypeExitSelectors
+				: this.anyTypeEnterSelectors;
+
+			selectors.push(selector);
+		});
+
+		// sort all selectors by specificity for prioritizing call order
+		this.anyTypeEnterSelectors.sort(compareSpecificity);
+		this.anyTypeExitSelectors.sort(compareSpecificity);
+		this.enterSelectorsByNodeType.forEach(selectorList =>
+			selectorList.sort(compareSpecificity),
+		);
+		this.exitSelectorsByNodeType.forEach(selectorList =>
+			selectorList.sort(compareSpecificity),
+		);
+	}
+
+	/**
+	 * Checks if a node matches a given selector.
+	 * @param {ASTNode} node The node to check
+	 * @param {ASTNode[]} ancestry The ancestry of the node being checked.
+	 * @param {ESQueryParsedSelector} selector An AST selector descriptor
+	 * @returns {boolean} `true` if the selector matches the node, `false` otherwise
+	 */
+	matches(node, ancestry, selector) {
+		return matches(node, selector.root, ancestry, this.esqueryOptions);
+	}
+
+	/**
+	 * Calculates all appropriate selectors to a node, in specificity order
+	 * @param {ASTNode} node The node to check
+	 * @param {ASTNode[]} ancestry The ancestry of the node being checked.
+	 * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited
+	 * @returns {string[]} An array of selectors that match the node.
+	 */
+	calculateSelectors(node, ancestry, isExit) {
+		const nodeTypeKey = this.esqueryOptions?.nodeTypeKey || "type";
+		const selectors = [];
+
+		/*
+		 * Get the selectors that may match this node. First, check
+		 * to see if the node type has specific selectors,
+		 * then gather the "any type" selectors.
+		 */
+		const selectorsByNodeType =
+			(isExit
+				? this.exitSelectorsByNodeType
+				: this.enterSelectorsByNodeType
+			).get(node[nodeTypeKey]) || [];
+		const anyTypeSelectors = isExit
+			? this.anyTypeExitSelectors
+			: this.anyTypeEnterSelectors;
+
+		/*
+		 * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
+		 * Iterate through each of them, applying selectors in the right order.
+		 */
+		let selectorsByNodeTypeIndex = 0;
+		let anyTypeSelectorsIndex = 0;
+
+		while (
+			selectorsByNodeTypeIndex < selectorsByNodeType.length ||
+			anyTypeSelectorsIndex < anyTypeSelectors.length
+		) {
+			/*
+			 * If we've already exhausted the selectors for this node type,
+			 * or if the next any type selector is more specific than the
+			 * next selector for this node type, apply the any type selector.
+			 */
+			const hasMoreNodeTypeSelectors =
+				selectorsByNodeTypeIndex < selectorsByNodeType.length;
+			const hasMoreAnyTypeSelectors =
+				anyTypeSelectorsIndex < anyTypeSelectors.length;
+			const anyTypeSelector = anyTypeSelectors[anyTypeSelectorsIndex];
+			const nodeTypeSelector =
+				selectorsByNodeType[selectorsByNodeTypeIndex];
+
+			// Only compare specificity if both selectors exist
+			const isAnyTypeSelectorLessSpecific =
+				hasMoreAnyTypeSelectors &&
+				hasMoreNodeTypeSelectors &&
+				anyTypeSelector.compare(nodeTypeSelector) < 0;
+
+			if (!hasMoreNodeTypeSelectors || isAnyTypeSelectorLessSpecific) {
+				anyTypeSelectorsIndex++;
+
+				if (this.matches(node, ancestry, anyTypeSelector)) {
+					selectors.push(anyTypeSelector.source);
+				}
+			} else {
+				selectorsByNodeTypeIndex++;
+
+				if (this.matches(node, ancestry, nodeTypeSelector)) {
+					selectors.push(nodeTypeSelector.source);
+				}
+			}
+		}
+
+		return selectors;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Traverses source code and ensures that visitor methods are called when
+ * entering and leaving each node.
+ */
+class SourceCodeTraverser {
+	/**
+	 * The language of the source code being traversed.
+	 * @type {Language}
+	 */
+	#language;
+
+	/**
+	 * Map of languages to instances of this class.
+	 * @type {WeakMap<Language, SourceCodeTraverser>}
+	 */
+	static instances = new WeakMap();
+
+	/**
+	 * Creates a new instance.
+	 * @param {Language} language The language of the source code being traversed.
+	 */
+	constructor(language) {
+		this.#language = language;
+	}
+
+	static getInstance(language) {
+		if (!this.instances.has(language)) {
+			this.instances.set(language, new this(language));
+		}
+
+		return this.instances.get(language);
+	}
+
+	/**
+	 * Traverses the given source code synchronously.
+	 * @param {SourceCode} sourceCode The source code to traverse.
+	 * @param {SourceCodeVisitor} visitor The emitter to use for events.
+	 * @param {Object} options Options for traversal.
+	 * @param {ReturnType<SourceCode["traverse"]>} options.steps The steps to take during traversal.
+	 * @returns {void}
+	 * @throws {Error} If an error occurs during traversal.
+	 */
+	traverseSync(sourceCode, visitor, { steps } = {}) {
+		const esquery = new ESQueryHelper(visitor, {
+			visitorKeys: sourceCode.visitorKeys ?? this.#language.visitorKeys,
+			fallback: vk.getKeys,
+			matchClass: this.#language.matchesSelectorClass ?? (() => false),
+			nodeTypeKey: this.#language.nodeTypeKey,
+		});
+
+		const currentAncestry = [];
+
+		for (const step of steps ?? sourceCode.traverse()) {
+			switch (step.kind) {
+				case STEP_KIND_VISIT: {
+					try {
+						if (step.phase === 1) {
+							esquery
+								.calculateSelectors(
+									step.target,
+									currentAncestry,
+									false,
+								)
+								.forEach(selector => {
+									visitor.callSync(selector, step.target);
+								});
+							currentAncestry.unshift(step.target);
+						} else {
+							currentAncestry.shift();
+							esquery
+								.calculateSelectors(
+									step.target,
+									currentAncestry,
+									true,
+								)
+								.forEach(selector => {
+									visitor.callSync(selector, step.target);
+								});
+						}
+					} catch (err) {
+						err.currentNode = step.target;
+						throw err;
+					}
+					break;
+				}
+
+				case STEP_KIND_CALL: {
+					visitor.callSync(step.target, ...step.args);
+					break;
+				}
+
+				default:
+					throw new Error(
+						`Invalid traversal step found: "${step.kind}".`,
+					);
+			}
+		}
+	}
+}
+
+module.exports = { SourceCodeTraverser };

package/lib/linter/source-code-visitor.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview SourceCodeVisitor class
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const emptyArray = Object.freeze([]);
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * A structure to hold a list of functions to call for a given name.
+ * This is used to allow multiple rules to register functions for a given name
+ * without having to know about each other.
+ */
+class SourceCodeVisitor {
+	/**
+	 * The functions to call for a given name.
+	 * @type {Map<string, Function[]>}
+	 */
+	#functions = new Map();
+
+	/**
+	 * Adds a function to the list of functions to call for a given name.
+	 * @param {string} name The name of the function to call.
+	 * @param {Function} func The function to call.
+	 * @returns {void}
+	 */
+	add(name, func) {
+		if (this.#functions.has(name)) {
+			this.#functions.get(name).push(func);
+		} else {
+			this.#functions.set(name, [func]);
+		}
+	}
+
+	/**
+	 * Gets the list of functions to call for a given name.
+	 * @param {string} name The name of the function to call.
+	 * @returns {Function[]} The list of functions to call.
+	 */
+	get(name) {
+		if (this.#functions.has(name)) {
+			return this.#functions.get(name);
+		}
+
+		return emptyArray;
+	}
+
+	/**
+	 * Iterates over all names and calls the callback with the name.
+	 * @param {(name:string) => void} callback The callback to call for each name.
+	 * @returns {void}
+	 */
+	forEachName(callback) {
+		this.#functions.forEach((funcs, name) => {
+			callback(name);
+		});
+	}
+
+	/**
+	 * Calls the functions for a given name with the given arguments.
+	 * @param {string} name The name of the function to call.
+	 * @param {any[]} args The arguments to pass to the function.
+	 * @returns {void}
+	 */
+	callSync(name, ...args) {
+		if (this.#functions.has(name)) {
+			this.#functions.get(name).forEach(func => func(...args));
+		}
+	}
+}
+
+module.exports = { SourceCodeVisitor };

package/lib/options.js

@@ -66,6 +66,7 @@ const optionator = require("optionator");
  * @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
  */
 
 //------------------------------------------------------------------------------
@@ -449,6 +450,12 @@ module.exports = function (usingFlatConfig) {
 				default: "false",
 				description: "Prune unused suppressions",
 			},
+			{
+				option: "pass-on-unpruned-suppressions",
+				type: "Boolean",
+				default: "false",
+				description: "Ignore unused suppressions",
+			},
 			{
 				heading: "Miscellaneous",
 			},