diff --git a/‎lib/cli-engine/formatters/stylish.js‎
Lines changed: 36 additions & 4 deletions b/‎lib/cli-engine/formatters/stylish.js‎
Lines changed: 36 additions & 4 deletions
diff --git a/‎lib/config/config.js‎
Lines changed: 40 additions & 6 deletions b/‎lib/config/config.js‎
Lines changed: 40 additions & 6 deletions
diff --git a/‎lib/linter/apply-disable-directives.js‎
Lines changed: 8 additions & 0 deletions b/‎lib/linter/apply-disable-directives.js‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎lib/linter/esquery.js‎
Lines changed: 123 additions & 0 deletions b/‎lib/linter/esquery.js‎
Lines changed: 123 additions & 0 deletions
@@ -28,6 +28,25 @@ function getStyleText(color) {
 	return (_, text) => text;
 }
 
+/**
+ * Computes the visible width of a string, avoiding the cost of stripping
+ * VT control characters when the string doesn't contain any.
+ *
+ * VT sequences can be introduced either by the 7-bit `ESC` character or by
+ * the 8-bit `CSI` character, both of which `util.stripVTControlCharacters()`
+ * removes, so both must be checked before taking the fast path.
+ * @todo This optimization is not needed in Node.js v24+ because it's baked
+ * into util.stripVTControlCharacters(). When we update our supported
+ * Node.js versions we can remove this optimization.
+ * @param {string} str The string to measure.
+ * @returns {number} The number of visible characters.
+ */
+function stringLength(str) {
+	return str.includes("\u001b") || str.includes("\u009b")
+		? util.stripVTControlCharacters(str).length
+		: str.length;
+}
+
 /**
  * Given a word and a count, append an s if count is not one.
  * @param {string} word A word in its singular form.
@@ -77,20 +96,33 @@ module.exports = function (results, data) {
 					messageType = styleText("yellow", "warning");
 				}
 
+				/*
+				 * Strip a trailing period unless it's preceded by a space.
+				 * This is equivalent to `.replace(/([^ ])\.$/u, "$1")` but
+				 * avoids running a regex on every message.
+				 */
+				let messageText = message.message;
+
+				if (
+					messageText.length > 1 &&
+					messageText.endsWith(".") &&
+					messageText.at(-2) !== " "
+				) {
+					messageText = messageText.slice(0, -1);
+				}
+
 				return [
 					"",
 					String(message.line || 0),
 					String(message.column || 0),
 					messageType,
-					message.message.replace(/([^ ])\.$/u, "$1"),
+					messageText,
 					message.ruleId ? styleText("dim", message.ruleId) : "",
 				];
 			}),
 			{
 				align: ["", "r", "l"],
-				stringLength(str) {
-					return util.stripVTControlCharacters(str).length;
-				},
+				stringLength,
 			},
 		)
 			.split("\n")
 
@@ -12,8 +12,6 @@
 const { deepMergeArrays } = require("../shared/deep-merge-arrays");
 const { flatConfigSchema, hasMethod } = require("./flat-config-schema");
 const { ObjectSchema } = require("@eslint/config-array");
-const ajvImport = require("../shared/ajv");
-const ajv = ajvImport();
 const ruleReplacements = require("../../conf/replacements.json");
 
 //-----------------------------------------------------------------------------
@@ -52,10 +50,31 @@ const severities = new Map([
  */
 const validators = new WeakMap();
 
+/**
+ * The shared ajv instance, constructed on first use.
+ *
+ * `ajv` pulls in a large dependency graph (~40 modules) that's only needed
+ * once a rule's options actually need schema validation, so it's constructed
+ * lazily instead of eagerly at module load time.
+ * @type {import("ajv").Ajv|undefined}
+ */
+let ajv;
+
 //-----------------------------------------------------------------------------
 // Helpers
 //-----------------------------------------------------------------------------
 
+/**
+ * Gets the shared ajv instance, constructing it on first use.
+ * @returns {import("ajv").Ajv} The ajv instance.
+ */
+function getAjv() {
+	if (!ajv) {
+		ajv = require("../shared/ajv")();
+	}
+	return ajv;
+}
+
 /**
  * Throws a helpful error when a rule cannot be found.
  * @param {Object} ruleId The rule identifier.
@@ -413,7 +432,7 @@ function getOrCreateValidator(rule, ruleId) {
 			const schema = getRuleOptionsSchema(rule);
 
 			if (schema) {
-				validators.set(rule, ajv.compile(schema));
+				validators.set(rule, getAjv().compile(schema));
 			}
 		} catch (err) {
 			throw new InvalidRuleOptionsSchemaError(ruleId, err);
@@ -443,6 +462,14 @@ class Config {
 	 */
 	#processorName;
 
+	/**
+	 * Cache of rule definitions by rule ID. Rule lookups involve string
+	 * parsing and multiple property accesses, so the results are cached
+	 * because they're requested repeatedly for the same rule IDs.
+	 * @type {Map<string, RuleDefinition|undefined>}
+	 */
+	#ruleDefinitions = new Map();
+
 	/**
 	 * Creates a new instance.
 	 * @param {Object} config The configuration object.
@@ -596,7 +623,14 @@ class Config {
 	 * @returns {RuleDefinition|undefined} The rule definition from the plugin, or `undefined` if the rule is not found.
 	 */
 	getRuleDefinition(ruleId) {
-		return getRuleFromConfig(ruleId, this);
+		if (this.#ruleDefinitions.has(ruleId)) {
+			return this.#ruleDefinitions.get(ruleId);
+		}
+
+		const rule = getRuleFromConfig(ruleId, this);
+
+		this.#ruleDefinitions.set(ruleId, rule);
+		return rule;
 	}
 
 	/**
@@ -615,7 +649,7 @@ class Config {
 			// normalize severity
 			ruleConfig[0] = severities.get(ruleConfig[0]);
 
-			const rule = getRuleFromConfig(ruleId, this);
+			const rule = this.getRuleDefinition(ruleId);
 
 			// apply meta.defaultOptions
 			const slicedOptions = ruleConfig.slice(1);
@@ -685,7 +719,7 @@ class Config {
 				continue;
 			}
 
-			const rule = getRuleFromConfig(ruleId, this);
+			const rule = this.getRuleDefinition(ruleId);
 
 			if (!rule) {
 				throwRuleNotFoundError(parseRuleId(ruleId), this);
 
@@ -309,6 +309,14 @@ function collectUsedEnableDirectives(directives) {
  * of problems (including suppressed ones) and unused eslint-disable directives
  */
 function applyDirectives(options) {
+	// Fast path: without directives there's nothing to suppress or report.
+	if (options.directives.length === 0) {
+		return {
+			problems: options.problems.slice(),
+			unusedDirectives: [],
+		};
+	}
+
 	const problems = [];
 	const usedDisableDirectives = new Set();
 	const { sourceCode } = options;
 
@@ -64,6 +64,23 @@ class ESQueryParsedSelector {
 	 */
 	identifierCount;
 
+	/**
+	 * Whether this selector is guaranteed to match any node it is tested
+	 * against after node-type-based filtering, making an `esquery.matches()`
+	 * call unnecessary. This is `true` only for selectors that consist solely
+	 * of node type identifiers, wildcards, or unions thereof.
+	 * @type {boolean}
+	 */
+	alwaysMatches;
+
+	/**
+	 * A specialized matcher function that is equivalent to calling
+	 * `esquery.matches()` for this selector but faster, or `null` if no
+	 * specialized matcher is available for this selector.
+	 * @type {((node: Object, ancestry: Object[], options: ESQueryOptions) => boolean)|null}
+	 */
+	fastMatch;
+
 	/**
 	 * Creates a new parsed selector.
 	 * @param {string} source The raw selector string that was parsed
@@ -72,6 +89,8 @@ class ESQueryParsedSelector {
 	 * @param {string[]|null} nodeTypes The node types that could possibly trigger this selector, or `null` if all node types could trigger it
 	 * @param {number} attributeCount The number of class, pseudo-class, and attribute queries in this selector
 	 * @param {number} identifierCount The number of identifier queries in this selector
+	 * @param {boolean} alwaysMatches Whether this selector always matches nodes it is tested against after node-type-based filtering
+	 * @param {Function|null} fastMatch A specialized matcher function for this selector, or `null` if not available
 	 */
 	constructor(
 		source,
@@ -80,13 +99,17 @@ class ESQueryParsedSelector {
 		nodeTypes,
 		attributeCount,
 		identifierCount,
+		alwaysMatches,
+		fastMatch,
 	) {
 		this.source = source;
 		this.isExit = isExit;
 		this.root = root;
 		this.nodeTypes = nodeTypes;
 		this.attributeCount = attributeCount;
 		this.identifierCount = identifierCount;
+		this.alwaysMatches = alwaysMatches;
+		this.fastMatch = fastMatch;
 	}
 
 	/**
@@ -230,6 +253,104 @@ function analyzeParsedSelector(parsedSelector) {
 	};
 }
 
+/**
+ * Determines whether a parsed selector consists solely of node type
+ * identifiers, wildcards, or unions thereof. Such selectors are guaranteed to
+ * match any node they are tested against after node-type-based filtering, so
+ * calling `esquery.matches()` for them is unnecessary.
+ * @param {ESQuerySelector} selector The parsed selector to check.
+ * @returns {boolean} `true` if the selector always matches nodes it is tested against after node-type-based filtering.
+ */
+function isAlwaysMatchingSelector(selector) {
+	switch (selector.type) {
+		case "identifier":
+		case "wildcard":
+			return true;
+
+		case "matches":
+			return selector.selectors.every(isAlwaysMatchingSelector);
+
+		default:
+			return false;
+	}
+}
+
+/**
+ * Creates a specialized matcher function for selectors of the shape
+ * `ParentType > .field` or `ParentType > *.field`, which are common in core
+ * rules but can't be bucketed by node type. The matcher replicates `esquery`'s
+ * matching behavior for these selectors: the parent (`ancestry[0]`) must have
+ * the given node type (case-insensitively, as `esquery` matches identifiers
+ * case-insensitively), and the node must be the value of the parent's given
+ * field (or an element of it, if the field value is an array).
+ * @param {ESQuerySelector} root The parsed selector to create a matcher for.
+ * @returns {Function|null} A matcher function, or `null` if the selector doesn't have the expected shape.
+ */
+function createFastMatcher(root) {
+	if (root.type !== "child") {
+		return null;
+	}
+
+	const { left, right } = root;
+
+	/*
+	 * Subject indicators (`!`) are intentionally not checked here. `esquery`
+	 * only consults `subject` in its `sibling` and `adjacent` matchers (and in
+	 * `esquery.query()`, which ESLint doesn't use), so for the `child`
+	 * selectors handled here a subject indicator has no effect on
+	 * `esquery.matches()`.
+	 */
+	if (left.type !== "identifier") {
+		return null;
+	}
+
+	let field = null;
+
+	if (right.type === "field") {
+		field = right;
+	} else if (right.type === "compound" && right.selectors.length === 2) {
+		const [first, second] = right.selectors;
+
+		if (first.type === "wildcard" && second.type === "field") {
+			field = second;
+		}
+	}
+
+	/*
+	 * Fields with a dotted name match against `ancestry[path.length - 1]`
+	 * rather than the immediate parent, so they aren't handled here.
+	 */
+	if (!field || field.name.includes(".")) {
+		return null;
+	}
+
+	const parentType = left.value;
+	const parentTypeLowercase = parentType.toLowerCase();
+	const fieldName = field.name;
+
+	return (node, ancestry, options) => {
+		const parent = ancestry[0];
+
+		if (!parent) {
+			return false;
+		}
+
+		const parentTypeActual = parent[options?.nodeTypeKey || "type"];
+
+		if (
+			parentTypeActual !== parentType &&
+			(typeof parentTypeActual !== "string" ||
+				parentTypeActual.toLowerCase() !== parentTypeLowercase)
+		) {
+			return false;
+		}
+
+		const value = parent[fieldName];
+
+		return value === node || (Array.isArray(value) && value.includes(node));
+	};
+}
+
 /**
  * Tries to parse a simple selector string, such as a single identifier or wildcard.
  * This saves time by avoiding the overhead of esquery parsing for simple cases.
@@ -303,6 +424,8 @@ function parse(source) {
 		nodeTypes,
 		attributeCount,
 		identifierCount,
+		isAlwaysMatchingSelector(parsedSelector),
+		createFastMatcher(parsedSelector),
 	);
 
 	selectorCache.set(source, result);