eslint 9.26.0 → 9.28.0

package/lib/linter/{node-event-generator.js → source-code-traverser.js}

@@ -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,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const { parse, matches } = require("./esquery");
+const vk = require("eslint-visitor-keys");
 
 //-----------------------------------------------------------------------------
 // Typedefs
@@ -17,12 +18,16 @@ const { parse, matches } = require("./esquery");
 
 /**
  * @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,18 +139,12 @@ 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);
 		}
 	}
@@ -175,10 +152,11 @@ class NodeEventGenerator {
 	/**
 	 * 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 };

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",
 			},

package/lib/rule-tester/rule-tester.js

@@ -15,7 +15,7 @@ const assert = require("node:assert"),
 	path = require("node:path"),
 	equal = require("fast-deep-equal"),
 	Traverser = require("../shared/traverser"),
-	{ getRuleOptionsSchema } = require("../config/flat-config-helpers"),
+	{ Config } = require("../config/config"),
 	{ Linter, SourceCodeFixer } = require("../linter"),
 	{ interpolate, getPlaceholderMatcher } = require("../linter/interpolate"),
 	stringify = require("json-stable-stringify-without-jsonify");
@@ -41,7 +41,7 @@ const { SourceCode } = require("../languages/js/source-code");
 
 /** @import { LanguageOptions, RuleDefinition } from "@eslint/core" */
 
-/** @typedef {import("../shared/types").Parser} Parser */
+/** @typedef {import("../types").Linter.Parser} Parser */
 
 /**
  * A test case that is expected to pass lint.
@@ -767,7 +767,7 @@ class RuleTester {
 			let schema;
 
 			try {
-				schema = getRuleOptionsSchema(rule);
+				schema = Config.getRuleOptionsSchema(rule);
 			} catch (err) {
 				err.message += metaSchemaDescription;
 				throw err;

package/lib/rules/func-style.js

@@ -11,12 +11,15 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		defaultOptions: [
 			"expression",
 			{
 				allowArrowFunctions: false,
+				allowTypeAnnotation: false,
 				overrides: {},
 			},
 		],
@@ -39,6 +42,9 @@ module.exports = {
 					allowArrowFunctions: {
 						type: "boolean",
 					},
+					allowTypeAnnotation: {
+						type: "boolean",
+					},
 					overrides: {
 						type: "object",
 						properties: {
@@ -60,11 +66,49 @@ module.exports = {
 	},
 
 	create(context) {
-		const [style, { allowArrowFunctions, overrides }] = context.options;
+		const [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] =
+			context.options;
 		const enforceDeclarations = style === "declaration";
 		const { namedExports: exportFunctionStyle } = overrides;
 		const stack = [];
 
+		/**
+		 * Checks if a function declaration is part of an overloaded function
+		 * @param {ASTNode} node The function declaration node to check
+		 * @returns {boolean} True if the function is overloaded
+		 */
+		function isOverloadedFunction(node) {
+			const functionName = node.id.name;
+
+			if (node.parent.type === "ExportNamedDeclaration") {
+				return node.parent.parent.body.some(
+					member =>
+						member.type === "ExportNamedDeclaration" &&
+						member.declaration?.type === "TSDeclareFunction" &&
+						member.declaration.id.name === functionName,
+				);
+			}
+
+			if (node.parent.type === "SwitchCase") {
+				return node.parent.parent.cases.some(switchCase =>
+					switchCase.consequent.some(
+						member =>
+							member.type === "TSDeclareFunction" &&
+							member.id.name === functionName,
+					),
+				);
+			}
+
+			return (
+				Array.isArray(node.parent.body) &&
+				node.parent.body.some(
+					member =>
+						member.type === "TSDeclareFunction" &&
+						member.id.name === functionName,
+				)
+			);
+		}
+
 		const nodesToCheck = {
 			FunctionDeclaration(node) {
 				stack.push(false);
@@ -73,14 +117,16 @@ module.exports = {
 					!enforceDeclarations &&
 					node.parent.type !== "ExportDefaultDeclaration" &&
 					(typeof exportFunctionStyle === "undefined" ||
-						node.parent.type !== "ExportNamedDeclaration")
+						node.parent.type !== "ExportNamedDeclaration") &&
+					!isOverloadedFunction(node)
 				) {
 					context.report({ node, messageId: "expression" });
 				}
 
 				if (
 					node.parent.type === "ExportNamedDeclaration" &&
-					exportFunctionStyle === "expression"
+					exportFunctionStyle === "expression" &&
+					!isOverloadedFunction(node)
 				) {
 					context.report({ node, messageId: "expression" });
 				}
@@ -97,7 +143,8 @@ module.exports = {
 					node.parent.type === "VariableDeclarator" &&
 					(typeof exportFunctionStyle === "undefined" ||
 						node.parent.parent.parent.type !==
-							"ExportNamedDeclaration")
+							"ExportNamedDeclaration") &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 				) {
 					context.report({
 						node: node.parent,
@@ -109,7 +156,8 @@ module.exports = {
 					node.parent.type === "VariableDeclarator" &&
 					node.parent.parent.parent.type ===
 						"ExportNamedDeclaration" &&
-					exportFunctionStyle === "declaration"
+					exportFunctionStyle === "declaration" &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 				) {
 					context.report({
 						node: node.parent,
@@ -144,7 +192,8 @@ module.exports = {
 						enforceDeclarations &&
 						(typeof exportFunctionStyle === "undefined" ||
 							node.parent.parent.parent.type !==
-								"ExportNamedDeclaration")
+								"ExportNamedDeclaration") &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 					) {
 						context.report({
 							node: node.parent,
@@ -155,7 +204,8 @@ module.exports = {
 					if (
 						node.parent.parent.parent.type ===
 							"ExportNamedDeclaration" &&
-						exportFunctionStyle === "declaration"
+						exportFunctionStyle === "declaration" &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
 					) {
 						context.report({
 							node: node.parent,

package/lib/rules/index.js

@@ -225,6 +225,7 @@ module.exports = new LazyLoadingRuleMap(
 		"no-this-before-super": () => require("./no-this-before-super"),
 		"no-throw-literal": () => require("./no-throw-literal"),
 		"no-trailing-spaces": () => require("./no-trailing-spaces"),
+		"no-unassigned-vars": () => require("./no-unassigned-vars"),
 		"no-undef": () => require("./no-undef"),
 		"no-undef-init": () => require("./no-undef-init"),
 		"no-undefined": () => require("./no-undefined"),

package/lib/rules/max-params.js

@@ -20,6 +20,8 @@ const { upperCaseFirst } = require("../shared/string-utils");
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description:
@@ -46,6 +48,11 @@ module.exports = {
 								type: "integer",
 								minimum: 0,
 							},
+							countVoidThis: {
+								type: "boolean",
+								description:
+									"Whether to count a `this` declaration when the type is `void`.",
+							},
 						},
 						additionalProperties: false,
 					},
@@ -61,12 +68,16 @@ module.exports = {
 		const sourceCode = context.sourceCode;
 		const option = context.options[0];
 		let numParams = 3;
+		let countVoidThis = false;
 
-		if (
-			typeof option === "object" &&
-			(Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
-		) {
-			numParams = option.maximum || option.max;
+		if (typeof option === "object") {
+			if (
+				Object.hasOwn(option, "maximum") ||
+				Object.hasOwn(option, "max")
+			) {
+				numParams = option.maximum || option.max;
+			}
+			countVoidThis = option.countVoidThis;
 		}
 		if (typeof option === "number") {
 			numParams = option;
@@ -79,7 +90,19 @@ module.exports = {
 		 * @private
 		 */
 		function checkFunction(node) {
-			if (node.params.length > numParams) {
+			const hasVoidThisParam =
+				node.params.length > 0 &&
+				node.params[0].type === "Identifier" &&
+				node.params[0].name === "this" &&
+				node.params[0].typeAnnotation?.typeAnnotation.type ===
+					"TSVoidKeyword";
+
+			const effectiveParamCount =
+				hasVoidThisParam && !countVoidThis
+					? node.params.length - 1
+					: node.params.length;
+
+			if (effectiveParamCount > numParams) {
 				context.report({
 					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
 					node,
@@ -88,7 +111,7 @@ module.exports = {
 						name: upperCaseFirst(
 							astUtils.getFunctionNameWithKind(node),
 						),
-						count: node.params.length,
+						count: effectiveParamCount,
 						max: numParams,
 					},
 				});
@@ -99,6 +122,8 @@ module.exports = {
 			FunctionDeclaration: checkFunction,
 			ArrowFunctionExpression: checkFunction,
 			FunctionExpression: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSFunctionType: checkFunction,
 		};
 	},
 };

package/lib/rules/no-array-constructor.js

@@ -34,6 +34,8 @@ module.exports = {
 			url: "https://eslint.org/docs/latest/rules/no-array-constructor",
 		},
 
+		fixable: "code",
+
 		hasSuggestions: true,
 
 		schema: [],
@@ -49,6 +51,30 @@ module.exports = {
 	create(context) {
 		const sourceCode = context.sourceCode;
 
+		/**
+		 * Checks if there are comments in Array constructor expressions.
+		 * @param {ASTNode} node A CallExpression or NewExpression node.
+		 * @returns {boolean} True if there are comments, false otherwise.
+		 */
+		function hasCommentsInArrayConstructor(node) {
+			const firstToken = sourceCode.getFirstToken(node);
+			const lastToken = sourceCode.getLastToken(node);
+
+			let lastRelevantToken = sourceCode.getLastToken(node.callee);
+
+			while (
+				lastRelevantToken !== lastToken &&
+				!isOpeningParenToken(lastRelevantToken)
+			) {
+				lastRelevantToken = sourceCode.getTokenAfter(lastRelevantToken);
+			}
+
+			return sourceCode.commentsExistBetween(
+				firstToken,
+				lastRelevantToken,
+			);
+		}
+
 		/**
 		 * Gets the text between the calling parentheses of a CallExpression or NewExpression.
 		 * @param {ASTNode} node A CallExpression or NewExpression node.
@@ -107,6 +133,17 @@ module.exports = {
 				let fixText;
 				let messageId;
 
+				const nonSpreadCount = node.arguments.reduce(
+					(count, arg) =>
+						arg.type !== "SpreadElement" ? count + 1 : count,
+					0,
+				);
+
+				const shouldSuggest =
+					node.optional ||
+					(node.arguments.length > 0 && nonSpreadCount < 2) ||
+					hasCommentsInArrayConstructor(node);
+
 				/*
 				 * Check if the suggested change should include a preceding semicolon or not.
 				 * Due to JavaScript's ASI rules, a missing semicolon may be inserted automatically
@@ -127,10 +164,23 @@ module.exports = {
 				context.report({
 					node,
 					messageId: "preferLiteral",
+					fix(fixer) {
+						if (shouldSuggest) {
+							return null;
+						}
+
+						return fixer.replaceText(node, fixText);
+					},
 					suggest: [
 						{
 							messageId,
-							fix: fixer => fixer.replaceText(node, fixText),
+							fix(fixer) {
+								if (shouldSuggest) {
+									return fixer.replaceText(node, fixText);
+								}
+
+								return null;
+							},
 						},
 					],
 				});