eslint 8.57.1 → 9.39.1

package/lib/rules/prefer-promise-reject-errors.js

@@ -10,123 +10,145 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require using Error objects as Promise rejection reasons",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors"
-        },
-
-        fixable: null,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowEmptyReject: { type: "boolean", default: false }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            rejectAnError: "Expected the Promise rejection reason to be an Error."
-        }
-    },
-
-    create(context) {
-
-        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-
-        /**
-         * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
-         * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
-         * @returns {void}
-         */
-        function checkRejectCall(callExpression) {
-            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {
-                return;
-            }
-            if (
-                !callExpression.arguments.length ||
-                !astUtils.couldBeError(callExpression.arguments[0]) ||
-                callExpression.arguments[0].type === "Identifier" && callExpression.arguments[0].name === "undefined"
-            ) {
-                context.report({
-                    node: callExpression,
-                    messageId: "rejectAnError"
-                });
-            }
-        }
-
-        /**
-         * Determines whether a function call is a Promise.reject() call
-         * @param {ASTNode} node A CallExpression node
-         * @returns {boolean} `true` if the call is a Promise.reject() call
-         */
-        function isPromiseRejectCall(node) {
-            return astUtils.isSpecificMemberAccess(node.callee, "Promise", "reject");
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-
-            // Check `Promise.reject(value)` calls.
-            CallExpression(node) {
-                if (isPromiseRejectCall(node)) {
-                    checkRejectCall(node);
-                }
-            },
-
-            /*
-             * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
-             * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
-             * the nodes in the expression already have the `parent` property.
-             */
-            "NewExpression:exit"(node) {
-                if (
-                    node.callee.type === "Identifier" && node.callee.name === "Promise" &&
-                    node.arguments.length && astUtils.isFunction(node.arguments[0]) &&
-                    node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier"
-                ) {
-                    sourceCode.getDeclaredVariables(node.arguments[0])
-
-                        /*
-                         * Find the first variable that matches the second parameter's name.
-                         * If the first parameter has the same name as the second parameter, then the variable will actually
-                         * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
-                         * by the second parameter. It's not possible for an expression with the variable to be evaluated before
-                         * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
-                         * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
-                         * this case.
-                         */
-                        .find(variable => variable.name === node.arguments[0].params[1].name)
-
-                        // Get the references to that variable.
-                        .references
-
-                        // Only check the references that read the parameter's value.
-                        .filter(ref => ref.isRead())
-
-                        // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
-                        .filter(ref => ref.identifier.parent.type === "CallExpression" && ref.identifier === ref.identifier.parent.callee)
-
-                        // Check the argument of the function call to determine whether it's an Error.
-                        .forEach(ref => checkRejectCall(ref.identifier.parent));
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowEmptyReject: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Require using Error objects as Promise rejection reasons",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors",
+		},
+
+		fixable: null,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowEmptyReject: { type: "boolean" },
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			rejectAnError:
+				"Expected the Promise rejection reason to be an Error.",
+		},
+	},
+
+	create(context) {
+		const [{ allowEmptyReject }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		//----------------------------------------------------------------------
+		// Helpers
+		//----------------------------------------------------------------------
+
+		/**
+		 * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
+		 * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
+		 * @returns {void}
+		 */
+		function checkRejectCall(callExpression) {
+			if (!callExpression.arguments.length && allowEmptyReject) {
+				return;
+			}
+			if (
+				!callExpression.arguments.length ||
+				!astUtils.couldBeError(callExpression.arguments[0]) ||
+				(callExpression.arguments[0].type === "Identifier" &&
+					callExpression.arguments[0].name === "undefined")
+			) {
+				context.report({
+					node: callExpression,
+					messageId: "rejectAnError",
+				});
+			}
+		}
+
+		/**
+		 * Determines whether a function call is a Promise.reject() call
+		 * @param {ASTNode} node A CallExpression node
+		 * @returns {boolean} `true` if the call is a Promise.reject() call
+		 */
+		function isPromiseRejectCall(node) {
+			return astUtils.isSpecificMemberAccess(
+				node.callee,
+				"Promise",
+				"reject",
+			);
+		}
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			// Check `Promise.reject(value)` calls.
+			CallExpression(node) {
+				if (isPromiseRejectCall(node)) {
+					checkRejectCall(node);
+				}
+			},
+
+			/*
+			 * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
+			 * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
+			 * the nodes in the expression already have the `parent` property.
+			 */
+			"NewExpression:exit"(node) {
+				if (
+					node.callee.type === "Identifier" &&
+					node.callee.name === "Promise" &&
+					node.arguments.length &&
+					astUtils.isFunction(node.arguments[0]) &&
+					node.arguments[0].params.length > 1 &&
+					node.arguments[0].params[1].type === "Identifier"
+				) {
+					sourceCode
+						.getDeclaredVariables(node.arguments[0])
+
+						/*
+						 * Find the first variable that matches the second parameter's name.
+						 * If the first parameter has the same name as the second parameter, then the variable will actually
+						 * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
+						 * by the second parameter. It's not possible for an expression with the variable to be evaluated before
+						 * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
+						 * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
+						 * this case.
+						 */
+						.find(
+							variable =>
+								variable.name ===
+								node.arguments[0].params[1].name,
+						)
+
+						// Get the references to that variable.
+						.references // Only check the references that read the parameter's value.
+						.filter(ref => ref.isRead())
+
+						// Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
+						.filter(
+							ref =>
+								ref.identifier.parent.type ===
+									"CallExpression" &&
+								ref.identifier === ref.identifier.parent.callee,
+						)
+
+						// Check the argument of the function call to determine whether it's an Error.
+						.forEach(ref => checkRejectCall(ref.identifier.parent));
+				}
+			},
+		};
+	},
 };

package/lib/rules/prefer-reflect.js

@@ -9,119 +9,142 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
+	meta: {
+		type: "suggestion",
 
-        docs: {
-            description: "Require `Reflect` methods where applicable",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-reflect"
-        },
+		docs: {
+			description: "Require `Reflect` methods where applicable",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-reflect",
+		},
 
-        deprecated: true,
+		deprecated: {
+			message: "The original intention of this rule was misguided.",
+			deprecatedSince: "3.9.0",
+			availableUntil: null,
+			replacedBy: [],
+		},
 
-        replacedBy: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					exceptions: {
+						type: "array",
+						items: {
+							enum: [
+								"apply",
+								"call",
+								"delete",
+								"defineProperty",
+								"getOwnPropertyDescriptor",
+								"getPrototypeOf",
+								"setPrototypeOf",
+								"isExtensible",
+								"getOwnPropertyNames",
+								"preventExtensions",
+							],
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "array",
-                        items: {
-                            enum: [
-                                "apply",
-                                "call",
-                                "delete",
-                                "defineProperty",
-                                "getOwnPropertyDescriptor",
-                                "getPrototypeOf",
-                                "setPrototypeOf",
-                                "isExtensible",
-                                "getOwnPropertyNames",
-                                "preventExtensions"
-                            ]
-                        },
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
+		messages: {
+			preferReflect:
+				"Avoid using {{existing}}, instead use {{substitute}}.",
+		},
+	},
 
-        messages: {
-            preferReflect: "Avoid using {{existing}}, instead use {{substitute}}."
-        }
-    },
+	create(context) {
+		const existingNames = {
+			apply: "Function.prototype.apply",
+			call: "Function.prototype.call",
+			defineProperty: "Object.defineProperty",
+			getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
+			getPrototypeOf: "Object.getPrototypeOf",
+			setPrototypeOf: "Object.setPrototypeOf",
+			isExtensible: "Object.isExtensible",
+			getOwnPropertyNames: "Object.getOwnPropertyNames",
+			preventExtensions: "Object.preventExtensions",
+		};
 
-    create(context) {
-        const existingNames = {
-            apply: "Function.prototype.apply",
-            call: "Function.prototype.call",
-            defineProperty: "Object.defineProperty",
-            getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
-            getPrototypeOf: "Object.getPrototypeOf",
-            setPrototypeOf: "Object.setPrototypeOf",
-            isExtensible: "Object.isExtensible",
-            getOwnPropertyNames: "Object.getOwnPropertyNames",
-            preventExtensions: "Object.preventExtensions"
-        };
+		const reflectSubstitutes = {
+			apply: "Reflect.apply",
+			call: "Reflect.apply",
+			defineProperty: "Reflect.defineProperty",
+			getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
+			getPrototypeOf: "Reflect.getPrototypeOf",
+			setPrototypeOf: "Reflect.setPrototypeOf",
+			isExtensible: "Reflect.isExtensible",
+			getOwnPropertyNames: "Reflect.getOwnPropertyNames",
+			preventExtensions: "Reflect.preventExtensions",
+		};
 
-        const reflectSubstitutes = {
-            apply: "Reflect.apply",
-            call: "Reflect.apply",
-            defineProperty: "Reflect.defineProperty",
-            getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
-            getPrototypeOf: "Reflect.getPrototypeOf",
-            setPrototypeOf: "Reflect.setPrototypeOf",
-            isExtensible: "Reflect.isExtensible",
-            getOwnPropertyNames: "Reflect.getOwnPropertyNames",
-            preventExtensions: "Reflect.preventExtensions"
-        };
+		const exceptions = (context.options[0] || {}).exceptions || [];
 
-        const exceptions = (context.options[0] || {}).exceptions || [];
+		/**
+		 * Reports the Reflect violation based on the `existing` and `substitute`
+		 * @param {Object} node The node that violates the rule.
+		 * @param {string} existing The existing method name that has been used.
+		 * @param {string} substitute The Reflect substitute that should be used.
+		 * @returns {void}
+		 */
+		function report(node, existing, substitute) {
+			context.report({
+				node,
+				messageId: "preferReflect",
+				data: {
+					existing,
+					substitute,
+				},
+			});
+		}
 
-        /**
-         * Reports the Reflect violation based on the `existing` and `substitute`
-         * @param {Object} node The node that violates the rule.
-         * @param {string} existing The existing method name that has been used.
-         * @param {string} substitute The Reflect substitute that should be used.
-         * @returns {void}
-         */
-        function report(node, existing, substitute) {
-            context.report({
-                node,
-                messageId: "preferReflect",
-                data: {
-                    existing,
-                    substitute
-                }
-            });
-        }
+		return {
+			CallExpression(node) {
+				const methodName = (node.callee.property || {}).name;
+				const isReflectCall =
+					(node.callee.object || {}).name === "Reflect";
+				const hasReflectSubstitute = Object.hasOwn(
+					reflectSubstitutes,
+					methodName,
+				);
+				const userConfiguredException = exceptions.includes(methodName);
 
-        return {
-            CallExpression(node) {
-                const methodName = (node.callee.property || {}).name;
-                const isReflectCall = (node.callee.object || {}).name === "Reflect";
-                const hasReflectSubstitute = Object.prototype.hasOwnProperty.call(reflectSubstitutes, methodName);
-                const userConfiguredException = exceptions.includes(methodName);
+				if (
+					hasReflectSubstitute &&
+					!isReflectCall &&
+					!userConfiguredException
+				) {
+					report(
+						node,
+						existingNames[methodName],
+						reflectSubstitutes[methodName],
+					);
+				}
+			},
+			UnaryExpression(node) {
+				const isDeleteOperator = node.operator === "delete";
+				const targetsIdentifier = node.argument.type === "Identifier";
+				const userConfiguredException = exceptions.includes("delete");
 
-                if (hasReflectSubstitute && !isReflectCall && !userConfiguredException) {
-                    report(node, existingNames[methodName], reflectSubstitutes[methodName]);
-                }
-            },
-            UnaryExpression(node) {
-                const isDeleteOperator = node.operator === "delete";
-                const targetsIdentifier = node.argument.type === "Identifier";
-                const userConfiguredException = exceptions.includes("delete");
-
-                if (isDeleteOperator && !targetsIdentifier && !userConfiguredException) {
-                    report(node, "the delete keyword", "Reflect.deleteProperty");
-                }
-            }
-        };
-
-    }
+				if (
+					isDeleteOperator &&
+					!targetsIdentifier &&
+					!userConfiguredException
+				) {
+					report(
+						node,
+						"the delete keyword",
+						"Reflect.deleteProperty",
+					);
+				}
+			},
+		};
+	},
 };