eslint 9.25.1 → 9.27.0

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;
+							},
 						},
 					],
 				});

package/lib/rules/no-shadow-restricted-names.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)
+ * @fileoverview Disallow shadowing of globalThis, NaN, undefined, and Infinity (ES2020 section 18.1)
  * @author Michael Ficarra
  */
 "use strict";
@@ -32,13 +32,29 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
+		defaultOptions: [
+			{
+				reportGlobalThis: false,
+			},
+		],
+
 		docs: {
 			description: "Disallow identifiers from shadowing restricted names",
 			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/no-shadow-restricted-names",
 		},
 
-		schema: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					reportGlobalThis: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 
 		messages: {
 			shadowingRestrictedName: "Shadowing of global property '{{name}}'.",
@@ -46,6 +62,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const [{ reportGlobalThis }] = context.options;
+
 		const RESTRICTED = new Set([
 			"undefined",
 			"NaN",
@@ -53,6 +71,11 @@ module.exports = {
 			"arguments",
 			"eval",
 		]);
+
+		if (reportGlobalThis) {
+			RESTRICTED.add("globalThis");
+		}
+
 		const sourceCode = context.sourceCode;
 
 		// Track reported nodes to avoid duplicate reports. For example, on class declarations.

package/lib/rules/no-unassigned-vars.js

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Rule to flag variables that are never assigned
+ * @author Jacob Bandes-Storch <https://github.com/jtbandes>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
+
+		docs: {
+			description:
+				"Disallow `let` or `var` variables that are read but never assigned",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-unassigned-vars",
+		},
+
+		schema: [],
+		messages: {
+			unassigned:
+				"'{{name}}' is always 'undefined' because it's never assigned.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			VariableDeclarator(node) {
+				/** @type {import('estree').VariableDeclaration} */
+				const declaration = node.parent;
+				const shouldCheck =
+					!node.init &&
+					node.id.type === "Identifier" &&
+					declaration.kind !== "const" &&
+					!declaration.declare;
+				if (!shouldCheck) {
+					return;
+				}
+				const [variable] = sourceCode.getDeclaredVariables(node);
+				if (!variable) {
+					return;
+				}
+				let hasRead = false;
+				for (const reference of variable.references) {
+					if (reference.isWrite()) {
+						return;
+					}
+					if (reference.isRead()) {
+						hasRead = true;
+					}
+				}
+				if (!hasRead) {
+					// Variables that are never read should be flagged by no-unused-vars instead
+					return;
+				}
+				context.report({
+					node,
+					messageId: "unassigned",
+					data: { name: node.id.name },
+				});
+			},
+		};
+	},
+};

package/lib/rules/no-unused-expressions.js

@@ -55,6 +55,9 @@ module.exports = {
 					enforceForJSX: {
 						type: "boolean",
 					},
+					ignoreDirectives: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -66,6 +69,7 @@ module.exports = {
 				allowTernary: false,
 				allowTaggedTemplates: false,
 				enforceForJSX: false,
+				ignoreDirectives: false,
 			},
 		],
 
@@ -82,6 +86,7 @@ module.exports = {
 				allowTernary,
 				allowTaggedTemplates,
 				enforceForJSX,
+				ignoreDirectives,
 			},
 		] = context.options;
 
@@ -211,7 +216,8 @@ module.exports = {
 			ExpressionStatement(node) {
 				if (
 					Checker.isDisallowed(node.expression) &&
-					!isDirective(node)
+					!astUtils.isDirective(node) &&
+					!(ignoreDirectives && isDirective(node))
 				) {
 					context.report({ node, messageId: "unusedExpression" });
 				}

package/lib/rules/no-useless-escape.js

@@ -60,6 +60,12 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
+		defaultOptions: [
+			{
+				allowRegexCharacters: [],
+			},
+		],
+
 		docs: {
 			description: "Disallow unnecessary escape characters",
 			recommended: true,
@@ -78,11 +84,26 @@ module.exports = {
 				"Replace the `\\` with `\\\\` to include the actual backslash character.",
 		},
 
-		schema: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowRegexCharacters: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 	},
 
 	create(context) {
 		const sourceCode = context.sourceCode;
+		const [{ allowRegexCharacters }] = context.options;
 		const parser = new RegExpParser();
 
 		/**
@@ -217,7 +238,8 @@ module.exports = {
 
 					if (
 						escapedChar !==
-						String.fromCodePoint(characterNode.value)
+							String.fromCodePoint(characterNode.value) ||
+						allowRegexCharacters.includes(escapedChar)
 					) {
 						// It's a valid escape.
 						return;

package/lib/rules/prefer-named-capture-group.js

@@ -17,6 +17,12 @@ const {
 } = require("@eslint-community/eslint-utils");
 const regexpp = require("@eslint-community/regexpp");
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @import { SuggestedEdit } from "@eslint/core"; */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -29,7 +35,7 @@ const parser = new regexpp.RegExpParser();
  * @param {string} pattern The regular expression pattern to be checked.
  * @param {string} rawText Source text of the regexNode.
  * @param {ASTNode} regexNode AST node which contains the regular expression.
- * @returns {Array<SuggestionResult>} Fixer suggestions for the regex, if statically determinable.
+ * @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
  */
 function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
 	switch (regexNode.type) {

package/lib/rules/utils/lazy-loading-rule-map.js

@@ -6,7 +6,7 @@
 
 const debug = require("debug")("eslint:rules");
 
-/** @typedef {import("../../shared/types").Rule} Rule */
+/** @typedef {import("../../types").Rule.RuleModule} Rule */
 
 /**
  * The `Map` object that loads each rule when it's accessed.
@@ -19,7 +19,7 @@ const debug = require("debug")("eslint:rules");
  *
  * rules.get("semi"); // call `() => require("semi")` here.
  *
- * @extends {Map<string, () => Rule>}
+ * @extends {Map<string, Rule>}
  */
 class LazyLoadingRuleMap extends Map {
 	/**

package/lib/services/processor-service.js

@@ -17,10 +17,9 @@ const { VFile } = require("../linter/vfile.js");
 // Types
 //-----------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types.js").LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("../linter/vfile.js").VFile} VFile */
 /** @typedef {import("@eslint/core").Language} Language */
-/** @typedef {import("@eslint/core").LanguageOptions} LanguageOptions */
 /** @typedef {import("eslint").Linter.Processor} Processor */
 
 //-----------------------------------------------------------------------------

package/lib/services/suppressions-service.js

@@ -12,14 +12,16 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const { calculateStatsPerFile } = require("../eslint/eslint-helpers");
+const stringify = require("json-stable-stringify-without-jsonify");
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
 // For VSCode IntelliSense
-/** @typedef {import("../shared/types").LintResult} LintResult */
-/** @typedef {import("../shared/types").SuppressedViolations} SuppressedViolations */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {Record<string, Record<string, { count: number; }>>} SuppressedViolations */
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -224,7 +226,7 @@ class SuppressionsService {
 	save(suppressions) {
 		return fs.promises.writeFile(
 			this.filePath,
-			JSON.stringify(suppressions, null, 2),
+			stringify(suppressions, { space: 2 }),
 		);
 	}
 

package/lib/shared/flags.js

@@ -27,6 +27,7 @@
  */
 const activeFlags = new Map([
 	["test_only", "Used only for testing."],
+	["test_only_2", "Used only for testing."],
 	[
 		"unstable_config_lookup_from_file",
 		"Look up `eslint.config.js` from the file being linted.",

package/lib/shared/serialization.js

@@ -26,21 +26,44 @@ function isSerializablePrimitiveOrPlainObject(val) {
  * Check if a value is serializable.
  * Functions or objects like RegExp cannot be serialized by JSON.stringify().
  * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
- * @param {any} val the value
- * @returns {boolean} true if the value is serializable
+ * @param {any} val The value
+ * @param {Set<Object>} seenObjects Objects already seen in this path from the root object.
+ * @returns {boolean} `true` if the value is serializable
  */
-function isSerializable(val) {
+function isSerializable(val, seenObjects = new Set()) {
 	if (!isSerializablePrimitiveOrPlainObject(val)) {
 		return false;
 	}
-	if (typeof val === "object") {
+	if (typeof val === "object" && val !== null) {
+		if (seenObjects.has(val)) {
+			/*
+			 * Since this is a depth-first traversal, encountering
+			 * the same object again means there is a circular reference.
+			 * Objects with circular references are not serializable.
+			 */
+			return false;
+		}
 		for (const property in val) {
 			if (Object.hasOwn(val, property)) {
 				if (!isSerializablePrimitiveOrPlainObject(val[property])) {
 					return false;
 				}
-				if (typeof val[property] === "object") {
-					if (!isSerializable(val[property])) {
+				if (
+					typeof val[property] === "object" &&
+					val[property] !== null
+				) {
+					if (
+						/*
+						 * We're creating a new Set of seen objects because we want to
+						 * ensure that `val` doesn't appear again in this path, but it can appear
+						 * in other paths. This allows for resuing objects in the graph, as long as
+						 * there are no cycles.
+						 */
+						!isSerializable(
+							val[property],
+							new Set([...seenObjects, val]),
+						)
+					) {
 						return false;
 					}
 				}