eslint 9.23.0 → 9.25.0

package/lib/rules/no-redeclare.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-regex-spaces.js

@@ -33,7 +33,7 @@ function isString(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-restricted-exports.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-restricted-globals.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-restricted-imports.js

@@ -133,7 +133,7 @@ const arrayOfStringsOrObjectPatterns = {
 	],
 };
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-restricted-modules.js

@@ -45,7 +45,7 @@ const arrayOfStringsOrObjects = {
 	uniqueItems: true,
 };
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		deprecated: {

package/lib/rules/no-restricted-properties.js

@@ -11,7 +11,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",
@@ -25,41 +25,37 @@ module.exports = {
 		schema: {
 			type: "array",
 			items: {
+				type: "object",
+				properties: {
+					object: {
+						type: "string",
+					},
+					property: {
+						type: "string",
+					},
+					allowObjects: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
+					message: {
+						type: "string",
+					},
+				},
 				anyOf: [
-					// `object` and `property` are both optional, but at least one of them must be provided.
 					{
-						type: "object",
-						properties: {
-							object: {
-								type: "string",
-							},
-							property: {
-								type: "string",
-							},
-							message: {
-								type: "string",
-							},
-						},
-						additionalProperties: false,
 						required: ["object"],
 					},
 					{
-						type: "object",
-						properties: {
-							object: {
-								type: "string",
-							},
-							property: {
-								type: "string",
-							},
-							message: {
-								type: "string",
-							},
-						},
-						additionalProperties: false,
 						required: ["property"],
 					},
 				],
+				not: {
+					required: ["allowObjects", "object"],
+				},
+				additionalProperties: false,
 			},
 			uniqueItems: true,
 		},
@@ -91,6 +87,7 @@ module.exports = {
 
 			if (typeof objectName === "undefined") {
 				globallyRestrictedProperties.set(propertyName, {
+					allowObjects: option.allowObjects,
 					message: option.message,
 				});
 			} else if (typeof propertyName === "undefined") {
@@ -108,6 +105,20 @@ module.exports = {
 			}
 		});
 
+		/**
+		 * Checks if an object name is in the allowed objects list.
+		 * @param {string} objectName The name of the object to check
+		 * @param {string[]} [allowObjects] The list of objects to allow
+		 * @returns {boolean} True if the object is allowed, false otherwise
+		 */
+		function isAllowedObject(objectName, allowObjects) {
+			if (!allowObjects) {
+				return false;
+			}
+
+			return allowObjects.includes(objectName);
+		}
+
 		/**
 		 * Checks to see whether a property access is restricted, and reports it if so.
 		 * @param {ASTNode} node The node to report
@@ -140,7 +151,10 @@ module.exports = {
 						message,
 					},
 				});
-			} else if (globalMatchedProperty) {
+			} else if (
+				globalMatchedProperty &&
+				!isAllowedObject(objectName, globalMatchedProperty.allowObjects)
+			) {
 				const message = globalMatchedProperty.message
 					? ` ${globalMatchedProperty.message}`
 					: "";

package/lib/rules/no-restricted-syntax.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-return-assign.js

@@ -21,7 +21,7 @@ const SENTINEL_TYPE =
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-return-await.js

@@ -11,7 +11,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		hasSuggestions: true,
@@ -30,7 +30,6 @@ module.exports = {
 		deprecated: {
 			message:
 				"The original assumption of the rule no longer holds true because of engine optimization.",
-			url: "https://eslint.org/docs/latest/rules/no-return-await",
 			deprecatedSince: "8.46.0",
 			availableUntil: null,
 			replacedBy: [],

package/lib/rules/no-script-url.js

@@ -12,7 +12,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-self-assign.js

@@ -125,7 +125,7 @@ function eachSelfAssignment(left, right, props, report) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-self-compare.js

@@ -10,7 +10,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-sequences.js

@@ -19,7 +19,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-setter-return.js

@@ -172,7 +172,7 @@ function getOuterScope(scope) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

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

@@ -27,7 +27,7 @@ function safelyShadowsUndefined(variable) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-shadow.js

@@ -28,7 +28,7 @@ const SENTINEL_TYPE =
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-spaced-func.js

@@ -10,7 +10,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "layout",

package/lib/rules/no-sparse-arrays.js

@@ -10,7 +10,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-sync.js

@@ -10,7 +10,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		deprecated: {

package/lib/rules/no-tabs.js

@@ -17,7 +17,7 @@ const anyNonWhitespaceRegex = /\S/u;
 // Public Interface
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		deprecated: {

package/lib/rules/no-template-curly-in-string.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-ternary.js

@@ -9,7 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-this-before-super.js

@@ -56,7 +56,7 @@ class SegmentInfo {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-throw-literal.js

@@ -11,7 +11,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-trailing-spaces.js

@@ -5,6 +5,14 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * @import { SourceLocation, SourceRange } from "@eslint/core";
+ */
+
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
@@ -15,7 +23,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		deprecated: {
@@ -85,8 +93,8 @@ module.exports = {
 		/**
 		 * Report the error message
 		 * @param {ASTNode} node node to report
-		 * @param {int[]} location range information
-		 * @param {int[]} fixRange Range based on the whole program
+		 * @param {SourceLocation} location range information
+		 * @param {SourceRange} fixRange Range based on the whole program
 		 * @returns {void}
 		 */
 		function report(node, location, fixRange) {

package/lib/rules/no-undef-init.js

@@ -11,7 +11,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-undef.js

@@ -23,7 +23,7 @@ function hasTypeOfOperator(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-undefined.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-underscore-dangle.js

@@ -9,7 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-unexpected-multiline.js

@@ -14,7 +14,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unmodified-loop-condition.js

@@ -161,7 +161,7 @@ function updateModifiedFlag(conditions, modifiers) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unneeded-ternary.js

@@ -37,7 +37,7 @@ const OR_PRECEDENCE = astUtils.getPrecedence({
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-unreachable-loop.js

@@ -74,7 +74,7 @@ function getDifference(arrA, arrB) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unreachable.js

@@ -111,7 +111,7 @@ class ConsecutiveRange {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unsafe-finally.js

@@ -20,7 +20,7 @@ const SENTINEL_NODE_TYPE_CONTINUE =
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unsafe-negation.js

@@ -46,7 +46,7 @@ function isNegation(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

package/lib/rules/no-unsafe-optional-chaining.js

@@ -25,7 +25,7 @@ function isDestructuringPattern(node) {
 	return node.type === "ObjectPattern" || node.type === "ArrayPattern";
 }
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",

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

@@ -26,7 +26,7 @@ function alwaysFalse() {
 	return false;
 }
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",
@@ -83,61 +83,6 @@ module.exports = {
 			},
 		] = 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.
@@ -190,13 +135,26 @@ module.exports = {
 			UnaryExpression(node) {
 				return node.operator !== "void" && node.operator !== "delete";
 			},
+			// TypeScript-specific node types
+			TSAsExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSTypeAssertion(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSNonNullExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSInstantiationExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
 		});
 
 		return {
 			ExpressionStatement(node) {
 				if (
 					Checker.isDisallowed(node.expression) &&
-					!isDirective(node)
+					!astUtils.isDirective(node)
 				) {
 					context.report({ node, messageId: "unusedExpression" });
 				}

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

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

package/lib/rules/no-unused-private-class-members.js

@@ -9,7 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "problem",