eslint 9.25.0 → 9.26.0

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-unused-expressions.js

@@ -29,6 +29,8 @@ function alwaysFalse() {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		docs: {
@@ -53,6 +55,9 @@ module.exports = {
 					enforceForJSX: {
 						type: "boolean",
 					},
+					ignoreDirectives: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -64,6 +69,7 @@ module.exports = {
 				allowTernary: false,
 				allowTaggedTemplates: false,
 				enforceForJSX: false,
+				ignoreDirectives: false,
 			},
 		],
 
@@ -80,9 +86,65 @@ module.exports = {
 				allowTernary,
 				allowTaggedTemplates,
 				enforceForJSX,
+				ignoreDirectives,
 			},
 		] = context.options;
 
+		/**
+		 * Has AST suggesting a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node structurally represents a directive
+		 */
+		function looksLikeDirective(node) {
+			return (
+				node.type === "ExpressionStatement" &&
+				node.expression.type === "Literal" &&
+				typeof node.expression.value === "string"
+			);
+		}
+
+		/**
+		 * Gets the leading sequence of members in a list that pass the predicate.
+		 * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
+		 * @param {a[]} list the input list
+		 * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
+		 */
+		function takeWhile(predicate, list) {
+			for (let i = 0; i < list.length; ++i) {
+				if (!predicate(list[i])) {
+					return list.slice(0, i);
+				}
+			}
+			return list.slice();
+		}
+
+		/**
+		 * Gets leading directives nodes in a Node body.
+		 * @param {ASTNode} node a Program or BlockStatement node
+		 * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
+		 */
+		function directives(node) {
+			return takeWhile(looksLikeDirective, node.body);
+		}
+
+		/**
+		 * Detect if a Node is a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node is considered a directive in its current position
+		 */
+		function isDirective(node) {
+			/**
+			 * https://tc39.es/ecma262/#directive-prologue
+			 *
+			 * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
+			 * Class static blocks do not have directive prologue.
+			 */
+			return (
+				astUtils.isTopLevelExpressionStatement(node) &&
+				directives(node.parent).includes(node)
+			);
+		}
+
 		/**
 		 * The member functions return `true` if the type has no side-effects.
 		 * Unknown nodes are handled as `false`, then this rule ignores those.
@@ -154,7 +216,8 @@ module.exports = {
 			ExpressionStatement(node) {
 				if (
 					Checker.isDisallowed(node.expression) &&
-					!astUtils.isDirective(node)
+					!astUtils.isDirective(node) &&
+					!(ignoreDirectives && isDirective(node))
 				) {
 					context.report({ node, messageId: "unusedExpression" });
 				}

package/lib/rules/utils/ast-utils.js

@@ -1088,13 +1088,13 @@ function isConstant(scope, node, inBooleanPosition) {
 }
 
 /**
- * Checks whether a node is an ExpressionStatement at the top level of a file or function body.
+ * Checks whether a node is an ExpressionStatement at the top level of a file, function body, or TypeScript module block.
  * A top-level ExpressionStatement node is a directive if it contains a single unparenthesized
  * string literal and if it occurs either as the first sibling or immediately after another
  * directive.
  * @param {ASTNode} node The node to check.
  * @returns {boolean} Whether or not the node is an ExpressionStatement at the top level of a
- * file or function body.
+ * file, function body, or TypeScript module block.
  */
 function isTopLevelExpressionStatement(node) {
 	if (node.type !== "ExpressionStatement") {
@@ -1104,6 +1104,7 @@ function isTopLevelExpressionStatement(node) {
 
 	return (
 		parent.type === "Program" ||
+		parent.type === "TSModuleBlock" ||
 		(parent.type === "BlockStatement" && isFunction(parent.parent))
 	);
 }

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

@@ -20,7 +20,6 @@ const { VFile } = require("../linter/vfile.js");
 /** @typedef {import("../shared/types.js").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/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;
 					}
 				}

package/lib/shared/types.js

@@ -26,15 +26,6 @@ module.exports = {};
  * @property {boolean} [allowReserved] Allowing the use of reserved words as identifiers in ES3.
  */
 
-/**
- * @typedef {Object} LanguageOptions
- * @property {number|"latest"} [ecmaVersion] The ECMAScript version (or revision number).
- * @property {Record<string, GlobalConf>} [globals] The global variable settings.
- * @property {"script"|"module"|"commonjs"} [sourceType] The source code type.
- * @property {string|Object} [parser] The parser to use.
- * @property {Object} [parserOptions] The parser options to use.
- */
-
 /**
  * @typedef {Object} ConfigData
  * @property {Record<string, boolean>} [env] The environment settings.
@@ -166,14 +157,6 @@ module.exports = {};
  * @property {{ name?: string, url?: string }} [rule] Name and information of the replacement rule
  */
 
-/**
- * @typedef {Object} Plugin
- * @property {Record<string, ConfigData>} [configs] The definition of plugin configs.
- * @property {Record<string, Environment>} [environments] The definition of plugin environments.
- * @property {Record<string, Processor>} [processors] The definition of plugin processors.
- * @property {Record<string, Rule>} [rules] The definition of plugin rules.
- */
-
 /**
  * Information of deprecated rules.
  * @typedef {Object} DeprecatedRuleInfo

package/lib/types/index.d.ts

@@ -35,7 +35,6 @@ import type {
 	LanguageOptions as GenericLanguageOptions,
 	RuleDefinition,
 	RuleContext as CoreRuleContext,
-	RuleContextTypeOptions,
 	DeprecatedInfo,
 } from "@eslint/core";
 import { JSONSchema4 } from "json-schema";
@@ -1934,6 +1933,9 @@ export namespace ESLint {
 	}
 
 	interface Plugin extends ObjectMetaProperties {
+		meta?: ObjectMetaProperties["meta"] & {
+			namespace?: string | undefined;
+		};
 		configs?:
 			| Record<
 					string,
@@ -2121,7 +2123,7 @@ export class RuleTester {
 
 	run(
 		name: string,
-		rule: Rule.RuleModule,
+		rule: RuleDefinition,
 		tests: {
 			valid: Array<string | RuleTester.ValidTestCase>;
 			invalid: RuleTester.InvalidTestCase[];

package/lib/types/rules.d.ts

@@ -3578,7 +3578,16 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 0.1.4
 	 * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names
 	 */
-	"no-shadow-restricted-names": Linter.RuleEntry<[]>;
+	"no-shadow-restricted-names": Linter.RuleEntry<
+		[
+			Partial<{
+				/**
+				 * @default false
+				 */
+				reportGlobalThis: boolean;
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow spacing between function identifiers and their applications (deprecated).
@@ -3935,6 +3944,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 * @default false
 				 */
 				enforceForJSX: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreDirectives: boolean;
 			}>,
 		]
 	>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.25.0",
+  "version": "9.26.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -110,11 +110,12 @@
     "@eslint/config-helpers": "^0.2.1",
     "@eslint/core": "^0.13.0",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "9.25.0",
+    "@eslint/js": "9.26.0",
     "@eslint/plugin-kit": "^0.2.8",
     "@humanfs/node": "^0.16.6",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.4.2",
+    "@modelcontextprotocol/sdk": "^1.8.0",
     "@types/estree": "^1.0.6",
     "@types/json-schema": "^7.0.15",
     "ajv": "^6.12.4",
@@ -138,15 +139,17 @@
     "lodash.merge": "^4.6.2",
     "minimatch": "^3.1.2",
     "natural-compare": "^1.4.0",
-    "optionator": "^0.9.3"
+    "optionator": "^0.9.3",
+    "zod": "^3.24.2"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.0",
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "@cypress/webpack-preprocessor": "^6.0.2",
-    "@eslint/json": "^0.11.0",
+    "@eslint/json": "^0.12.0",
     "@trunkio/launcher": "^1.3.4",
+    "@types/esquery": "^1.5.4",
     "@types/node": "^22.13.14",
     "@typescript-eslint/parser": "^8.4.0",
     "babel-loader": "^8.0.5",