eslint 8.57.1 → 9.39.1

package/lib/rules/no-promise-executor-return.js

@@ -9,55 +9,33 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-const functionTypesToCheck = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
-
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-    const variable = findVariable(scope, node);
-
-    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
-}
-
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-    const upper = scope.upper;
-
-    if (upper.type === "function-expression-name") {
-        return upper.upper;
-    }
-    return upper;
-}
+const functionTypesToCheck = new Set([
+	"ArrowFunctionExpression",
+	"FunctionExpression",
+]);
 
 /**
  * Determines whether the given function node is used as a Promise executor.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Function's own scope.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a Promise executor.
  */
-function isPromiseExecutor(node, scope) {
-    const parent = node.parent;
-
-    return parent.type === "NewExpression" &&
-        parent.arguments[0] === node &&
-        parent.callee.type === "Identifier" &&
-        parent.callee.name === "Promise" &&
-        isGlobalReference(parent.callee, getOuterScope(scope));
+function isPromiseExecutor(node, sourceCode) {
+	const parent = node.parent;
+
+	return (
+		parent.type === "NewExpression" &&
+		parent.arguments[0] === node &&
+		parent.callee.type === "Identifier" &&
+		parent.callee.name === "Promise" &&
+		sourceCode.isGlobalReference(parent.callee)
+	);
 }
 
 /**
@@ -66,7 +44,7 @@ function isPromiseExecutor(node, scope) {
  * @returns {boolean} - `true` if the node is a void expression
  */
 function expressionIsVoid(node) {
-    return node.type === "UnaryExpression" && node.operator === "void";
+	return node.type === "UnaryExpression" && node.operator === "void";
 }
 
 /**
@@ -77,39 +55,40 @@ function expressionIsVoid(node) {
  * @returns {Array<Object>} - An array of fix objects to apply to the node.
  */
 function voidPrependFixer(sourceCode, node, fixer) {
-
-    const requiresParens =
-
-        // prepending `void ` will fail if the node has a lower precedence than void
-        astUtils.getPrecedence(node) < astUtils.getPrecedence({ type: "UnaryExpression", operator: "void" }) &&
-
-        // check if there are parentheses around the node to avoid redundant parentheses
-        !astUtils.isParenthesised(sourceCode, node);
-
-    // avoid parentheses issues
-    const returnOrArrowToken = sourceCode.getTokenBefore(
-        node,
-        node.parent.type === "ArrowFunctionExpression"
-            ? astUtils.isArrowToken
-
-            // isReturnToken
-            : token => token.type === "Keyword" && token.value === "return"
-    );
-
-    const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
-
-    const prependSpace =
-
-        // is return token, as => allows void to be adjacent
-        returnOrArrowToken.value === "return" &&
-
-        // If two tokens (return and "(") are adjacent
-        returnOrArrowToken.range[1] === firstToken.range[0];
-
-    return [
-        fixer.insertTextBefore(firstToken, `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`),
-        fixer.insertTextAfter(node, requiresParens ? ")" : "")
-    ];
+	const requiresParens =
+		// prepending `void ` will fail if the node has a lower precedence than void
+		astUtils.getPrecedence(node) <
+			astUtils.getPrecedence({
+				type: "UnaryExpression",
+				operator: "void",
+			}) &&
+		// check if there are parentheses around the node to avoid redundant parentheses
+		!astUtils.isParenthesised(sourceCode, node);
+
+	// avoid parentheses issues
+	const returnOrArrowToken = sourceCode.getTokenBefore(
+		node,
+		node.parent.type === "ArrowFunctionExpression"
+			? astUtils.isArrowToken
+			: // isReturnToken
+				token => token.type === "Keyword" && token.value === "return",
+	);
+
+	const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
+
+	const prependSpace =
+		// is return token, as => allows void to be adjacent
+		returnOrArrowToken.value === "return" &&
+		// If two tokens (return and "(") are adjacent
+		returnOrArrowToken.range[1] === firstToken.range[0];
+
+	return [
+		fixer.insertTextBefore(
+			firstToken,
+			`${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`,
+		),
+		fixer.insertTextAfter(node, requiresParens ? ")" : ""),
+	];
 }
 
 /**
@@ -120,144 +99,166 @@ function voidPrependFixer(sourceCode, node, fixer) {
  * @returns {Array<Object>} - An array of fix objects to apply to the node.
  */
 function curlyWrapFixer(sourceCode, node, fixer) {
-
-    // https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
-    const arrowToken = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
-    const firstToken = sourceCode.getTokenAfter(arrowToken);
-    const lastToken = sourceCode.getLastToken(node);
-
-    return [
-        fixer.insertTextBefore(firstToken, "{"),
-        fixer.insertTextAfter(lastToken, "}")
-    ];
+	// https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
+	const arrowToken = sourceCode.getTokenBefore(
+		node.body,
+		astUtils.isArrowToken,
+	);
+	const firstToken = sourceCode.getTokenAfter(arrowToken);
+	const lastToken = sourceCode.getLastToken(node);
+
+	return [
+		fixer.insertTextBefore(firstToken, "{"),
+		fixer.insertTextAfter(lastToken, "}"),
+	];
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow returning values from Promise executor functions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-promise-executor-return"
-        },
-
-        hasSuggestions: true,
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowVoid: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            returnsValue: "Return values from promise executor functions cannot be read.",
-
-            // arrow and function suggestions
-            prependVoid: "Prepend `void` to the expression.",
-
-            // only arrow suggestions
-            wrapBraces: "Wrap the expression in `{}`."
-        }
-    },
-
-    create(context) {
-
-        let funcInfo = null;
-        const sourceCode = context.sourceCode;
-        const {
-            allowVoid = false
-        } = context.options[0] || {};
-
-        return {
-
-            onCodePathStart(_, node) {
-                funcInfo = {
-                    upper: funcInfo,
-                    shouldCheck:
-                        functionTypesToCheck.has(node.type) &&
-                        isPromiseExecutor(node, sourceCode.getScope(node))
-                };
-
-                if (// Is a Promise executor
-                    funcInfo.shouldCheck &&
-                    node.type === "ArrowFunctionExpression" &&
-                    node.expression &&
-
-                    // Except void
-                    !(allowVoid && expressionIsVoid(node.body))
-                ) {
-                    const suggest = [];
-
-                    // prevent useless refactors
-                    if (allowVoid) {
-                        suggest.push({
-                            messageId: "prependVoid",
-                            fix(fixer) {
-                                return voidPrependFixer(sourceCode, node.body, fixer);
-                            }
-                        });
-                    }
-
-                    // Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
-                    if (!(node.body.type === "FunctionExpression" && !node.body.id)) {
-                        suggest.push({
-                            messageId: "wrapBraces",
-                            fix(fixer) {
-                                return curlyWrapFixer(sourceCode, node, fixer);
-                            }
-                        });
-                    }
-
-                    context.report({
-                        node: node.body,
-                        messageId: "returnsValue",
-                        suggest
-                    });
-                }
-            },
-
-            onCodePathEnd() {
-                funcInfo = funcInfo.upper;
-            },
-
-            ReturnStatement(node) {
-                if (!(funcInfo.shouldCheck && node.argument)) {
-                    return;
-                }
-
-                // node is `return <expression>`
-                if (!allowVoid) {
-                    context.report({ node, messageId: "returnsValue" });
-                    return;
-                }
-
-                if (expressionIsVoid(node.argument)) {
-                    return;
-                }
-
-                // allowVoid && !expressionIsVoid
-                context.report({
-                    node,
-                    messageId: "returnsValue",
-                    suggest: [{
-                        messageId: "prependVoid",
-                        fix(fixer) {
-                            return voidPrependFixer(sourceCode, node.argument, fixer);
-                        }
-                    }]
-                });
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		defaultOptions: [
+			{
+				allowVoid: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Disallow returning values from Promise executor functions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-promise-executor-return",
+		},
+
+		hasSuggestions: true,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowVoid: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			returnsValue:
+				"Return values from promise executor functions cannot be read.",
+
+			// arrow and function suggestions
+			prependVoid: "Prepend `void` to the expression.",
+
+			// only arrow suggestions
+			wrapBraces: "Wrap the expression in `{}`.",
+		},
+	},
+
+	create(context) {
+		let funcInfo = null;
+		const sourceCode = context.sourceCode;
+		const [{ allowVoid }] = context.options;
+
+		return {
+			onCodePathStart(_, node) {
+				funcInfo = {
+					upper: funcInfo,
+					shouldCheck:
+						functionTypesToCheck.has(node.type) &&
+						isPromiseExecutor(node, sourceCode),
+				};
+
+				if (
+					// Is a Promise executor
+					funcInfo.shouldCheck &&
+					node.type === "ArrowFunctionExpression" &&
+					node.expression &&
+					// Except void
+					!(allowVoid && expressionIsVoid(node.body))
+				) {
+					const suggest = [];
+
+					// prevent useless refactors
+					if (allowVoid) {
+						suggest.push({
+							messageId: "prependVoid",
+							fix(fixer) {
+								return voidPrependFixer(
+									sourceCode,
+									node.body,
+									fixer,
+								);
+							},
+						});
+					}
+
+					// Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
+					if (
+						!(
+							node.body.type === "FunctionExpression" &&
+							!node.body.id
+						)
+					) {
+						suggest.push({
+							messageId: "wrapBraces",
+							fix(fixer) {
+								return curlyWrapFixer(sourceCode, node, fixer);
+							},
+						});
+					}
+
+					context.report({
+						node: node.body,
+						messageId: "returnsValue",
+						suggest,
+					});
+				}
+			},
+
+			onCodePathEnd() {
+				funcInfo = funcInfo.upper;
+			},
+
+			ReturnStatement(node) {
+				if (!(funcInfo.shouldCheck && node.argument)) {
+					return;
+				}
+
+				// node is `return <expression>`
+				if (!allowVoid) {
+					context.report({ node, messageId: "returnsValue" });
+					return;
+				}
+
+				if (expressionIsVoid(node.argument)) {
+					return;
+				}
+
+				// allowVoid && !expressionIsVoid
+				context.report({
+					node,
+					messageId: "returnsValue",
+					suggest: [
+						{
+							messageId: "prependVoid",
+							fix(fixer) {
+								return voidPrependFixer(
+									sourceCode,
+									node.argument,
+									fixer,
+								);
+							},
+						},
+					],
+				});
+			},
+		};
+	},
 };

package/lib/rules/no-proto.js

@@ -15,34 +15,31 @@ const { getStaticPropertyName } = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of the `__proto__` property",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-proto"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedProto: "The '__proto__' property is deprecated."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            MemberExpression(node) {
-                if (getStaticPropertyName(node) === "__proto__") {
-                    context.report({ node, messageId: "unexpectedProto" });
-                }
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow the use of the `__proto__` property",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-proto",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpectedProto: "The '__proto__' property is deprecated.",
+		},
+	},
+
+	create(context) {
+		return {
+			MemberExpression(node) {
+				if (getStaticPropertyName(node) === "__proto__") {
+					context.report({ node, messageId: "unexpectedProto" });
+				}
+			},
+		};
+	},
 };