eslint
diff --git a/‎lib/linter/linter.js
Copy file name to clipboard
+4-39Lines changed: 4 additions & 39 deletions b/‎lib/linter/linter.js
Copy file name to clipboard
+4-39Lines changed: 4 additions & 39 deletions
diff --git a/‎lib/linter/node-event-generator.js renamed to ‎lib/linter/source-code-traverser.js
Copy file name to clipboard
+143-87Lines changed: 143 additions & 87 deletions b/‎lib/linter/node-event-generator.js renamed to ‎lib/linter/source-code-traverser.js
Copy file name to clipboard
+143-87Lines changed: 143 additions & 87 deletions
@@ -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"),
@@ -66,8 +65,7 @@ const { ProcessorService } = require("../services/processor-service");
 const { containsDifferentProperty } = require("../shared/option-utils");
 const { Config } = require("../config/config");
 const { WarningService } = require("../services/warning-service");
-const STEP_KIND_VISIT = 1;
-const STEP_KIND_CALL = 2;
+const { SourceCodeTraverser } = require("./source-code-traverser");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -1179,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
@@ -1201,6 +1196,7 @@ function runRules(
 	});
 
 	const lintingProblems = [];
+	const steps = sourceCode.traverse();
 
 	Object.keys(configuredRules).forEach(ruleId => {
 		const severity = Config.getRuleNumericSeverity(configuredRules[ruleId]);
@@ -1347,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;
 }
 
@@ -1,6 +1,6 @@
 /**
- * @fileoverview The event generator for AST nodes.
- * @author Toru Nagashima
+ * @fileoverview Traverser for SourceCode objects.
+ * @author Nicholas C. Zakas
  */
 
 "use strict";
@@ -10,19 +10,24 @@
 //------------------------------------------------------------------------------
 
 const { parse, matches } = require("./esquery");
+const vk = require("eslint-visitor-keys");
 
 //-----------------------------------------------------------------------------
 // Typedefs
 //-----------------------------------------------------------------------------
 
 /**
  * @import { ESQueryParsedSelector } from "./esquery.js";
+ * @import { Language, SourceCode } from "@eslint/core";
  */
 
 //-----------------------------------------------------------------------------
 // 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.
@@ -33,69 +38,10 @@ function compareSpecificity(a, b) {
 	return a.compare(b);
 }
 
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
 /**
- * The event generator for AST nodes.
- * This implements below interface.
- *
- * ```ts
- * interface EventGenerator {
- *     emitter: SafeEmitter;
- *     enterNode(node: ASTNode): void;
- *     leaveNode(node: ASTNode): void;
- * }
- * ```
+ * Helper to wrap ESQuery operations.
  */
-class NodeEventGenerator {
-	/**
-	 * The emitter to use during traversal.
-	 * @type {SafeEmitter}
-	 */
-	emitter;
-
-	/**
-	 * The options for `esquery` to use during matching.
-	 * @type {ESQueryOptions}
-	 */
-	esqueryOptions;
-
-	/**
-	 * The ancestry of the currently visited node.
-	 * @type {ASTNode[]}
-	 */
-	currentAncestry = [];
-
-	/**
-	 * A map of node type to selectors targeting that node type on the
-	 * enter phase of traversal.
-	 * @type {Map<string, ESQueryParsedSelector[]>}
-	 */
-	enterSelectorsByNodeType = new Map();
-
-	/**
-	 * A map of node type to selectors targeting that node type on the
-	 * exit phase of traversal.
-	 * @type {Map<string, ESQueryParsedSelector[]>}
-	 */
-	exitSelectorsByNodeType = new Map();
-
-	/**
-	 * An array of selectors that match any node type on the
-	 * enter phase of traversal.
-	 * @type {ESQueryParsedSelector[]}
-	 */
-	anyTypeEnterSelectors = [];
-
-	/**
-	 * An array of selectors that match any node type on the
-	 * exit phase of traversal.
-	 * @type {ESQueryParsedSelector[]}
-	 */
-	anyTypeExitSelectors = [];
-
+class ESQueryHelper {
 	/**
 	 * @param {SafeEmitter} emitter
 	 * An SafeEmitter which is the destination of events. This emitter must already
@@ -105,9 +51,46 @@ class NodeEventGenerator {
 	 * @returns {NodeEventGenerator} new instance
 	 */
 	constructor(emitter, esqueryOptions) {
+		/**
+		 * The emitter to use during traversal.
+		 * @type {SafeEmitter}
+		 */
 		this.emitter = emitter;
+
+		/**
+		 * 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 = [];
+
 		emitter.eventNames().forEach(rawSelector => {
 			const selector = parse(rawSelector);
 
@@ -156,29 +139,24 @@ class NodeEventGenerator {
 	/**
 	 * Checks a selector against a node, and emits it if it matches
 	 * @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 {void}
 	 */
-	applySelector(node, selector) {
-		if (
-			matches(
-				node,
-				selector.root,
-				this.currentAncestry,
-				this.esqueryOptions,
-			)
-		) {
+	#applySelector(node, ancestry, selector) {
+		if (matches(node, selector.root, ancestry, this.esqueryOptions)) {
 			this.emitter.emit(selector.source, node);
 		}
 	}
 
 	/**
 	 * Applies 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 {void}
 	 */
-	applySelectors(node, isExit) {
+	applySelectors(node, ancestry, isExit) {
 		const nodeTypeKey = this.esqueryOptions?.nodeTypeKey || "type";
 
 		/*
@@ -218,39 +196,117 @@ class NodeEventGenerator {
 						selectorsByNodeType[selectorsByNodeTypeIndex],
 					) < 0)
 			) {
-				this.applySelector(
+				this.#applySelector(
 					node,
+					ancestry,
 					anyTypeSelectors[anyTypeSelectorsIndex++],
 				);
 			} else {
 				// otherwise apply the node type selector
-				this.applySelector(
+				this.#applySelector(
 					node,
+					ancestry,
 					selectorsByNodeType[selectorsByNodeTypeIndex++],
 				);
 			}
 		}
 	}
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
 
+/**
+ * Traverses source code and ensures that visitor methods are called when
+ * entering and leaving each node.
+ */
+class SourceCodeTraverser {
 	/**
-	 * Emits an event of entering AST node.
-	 * @param {ASTNode} node A node which was entered.
-	 * @returns {void}
+	 * 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.
 	 */
-	enterNode(node) {
-		this.applySelectors(node, false);
-		this.currentAncestry.unshift(node);
+	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);
 	}
 
 	/**
-	 * Emits an event of leaving AST node.
-	 * @param {ASTNode} node A node which was left.
+	 * Traverses the given source code synchronously.
+	 * @param {SourceCode} sourceCode The source code to traverse.
+	 * @param {SafeEmitter} emitter 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.
 	 */
-	leaveNode(node) {
-		this.currentAncestry.shift();
-		this.applySelectors(node, true);
+	traverseSync(sourceCode, emitter, { steps } = {}) {
+		const esquery = new ESQueryHelper(emitter, {
+			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.applySelectors(
+								step.target,
+								currentAncestry,
+								false,
+							);
+							currentAncestry.unshift(step.target);
+						} else {
+							currentAncestry.shift();
+							esquery.applySelectors(
+								step.target,
+								currentAncestry,
+								true,
+							);
+						}
+					} catch (err) {
+						err.currentNode = step.target;
+						throw err;
+					}
+					break;
+				}
+
+				case STEP_KIND_CALL: {
+					emitter.emit(step.target, ...step.args);
+					break;
+				}
+
+				default:
+					throw new Error(
+						`Invalid traversal step found: "${step.kind}".`,
+					);
+			}
+		}
 	}
 }
 
-module.exports = NodeEventGenerator;
+module.exports = { SourceCodeTraverser };