eslint 8.57.1 → 9.39.1

package/lib/rules/no-extra-boolean-cast.js

@@ -18,300 +18,403 @@ const precedence = astUtils.getPrecedence;
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary boolean casts",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-extra-boolean-cast"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                enforceForLogicalOperands: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-        fixable: "code",
-
-        messages: {
-            unexpectedCall: "Redundant Boolean call.",
-            unexpectedNegation: "Redundant double negation."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        // Node types which have a test which will coerce values to booleans.
-        const BOOLEAN_NODE_TYPES = new Set([
-            "IfStatement",
-            "DoWhileStatement",
-            "WhileStatement",
-            "ConditionalExpression",
-            "ForStatement"
-        ]);
-
-        /**
-         * Check if a node is a Boolean function or constructor.
-         * @param {ASTNode} node the node
-         * @returns {boolean} If the node is Boolean function or constructor
-         */
-        function isBooleanFunctionOrConstructorCall(node) {
-
-            // Boolean(<bool>) and new Boolean(<bool>)
-            return (node.type === "CallExpression" || node.type === "NewExpression") &&
-                    node.callee.type === "Identifier" &&
-                        node.callee.name === "Boolean";
-        }
-
-        /**
-         * Checks whether the node is a logical expression and that the option is enabled
-         * @param {ASTNode} node the node
-         * @returns {boolean} if the node is a logical expression and option is enabled
-         */
-        function isLogicalContext(node) {
-            return node.type === "LogicalExpression" &&
-            (node.operator === "||" || node.operator === "&&") &&
-            (context.options.length && context.options[0].enforceForLogicalOperands === true);
-
-        }
-
-
-        /**
-         * Check if a node is in a context where its value would be coerced to a boolean at runtime.
-         * @param {ASTNode} node The node
-         * @returns {boolean} If it is in a boolean context
-         */
-        function isInBooleanContext(node) {
-            return (
-                (isBooleanFunctionOrConstructorCall(node.parent) &&
-                node === node.parent.arguments[0]) ||
-
-                (BOOLEAN_NODE_TYPES.has(node.parent.type) &&
-                    node === node.parent.test) ||
-
-                // !<bool>
-                (node.parent.type === "UnaryExpression" &&
-                    node.parent.operator === "!")
-            );
-        }
-
-        /**
-         * Checks whether the node is a context that should report an error
-         * Acts recursively if it is in a logical context
-         * @param {ASTNode} node the node
-         * @returns {boolean} If the node is in one of the flagged contexts
-         */
-        function isInFlaggedContext(node) {
-            if (node.parent.type === "ChainExpression") {
-                return isInFlaggedContext(node.parent);
-            }
-
-            return isInBooleanContext(node) ||
-            (isLogicalContext(node.parent) &&
-
-            // For nested logical statements
-            isInFlaggedContext(node.parent)
-            );
-        }
-
-
-        /**
-         * Check if a node has comments inside.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if it has comments inside.
-         */
-        function hasCommentsInside(node) {
-            return Boolean(sourceCode.getCommentsInside(node).length);
-        }
-
-        /**
-         * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if the node is parenthesized.
-         * @private
-         */
-        function isParenthesized(node) {
-            return eslintUtils.isParenthesized(1, node, sourceCode);
-        }
-
-        /**
-         * Determines whether the given node needs to be parenthesized when replacing the previous node.
-         * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
-         * of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
-         * For example, if the parent is `ConditionalExpression`, `previousNode` must be its `test` child.
-         * @param {ASTNode} previousNode Previous node.
-         * @param {ASTNode} node The node to check.
-         * @throws {Error} (Unreachable.)
-         * @returns {boolean} `true` if the node needs to be parenthesized.
-         */
-        function needsParens(previousNode, node) {
-            if (previousNode.parent.type === "ChainExpression") {
-                return needsParens(previousNode.parent, node);
-            }
-            if (isParenthesized(previousNode)) {
-
-                // parentheses around the previous node will stay, so there is no need for an additional pair
-                return false;
-            }
-
-            // parent of the previous node will become parent of the replacement node
-            const parent = previousNode.parent;
-
-            switch (parent.type) {
-                case "CallExpression":
-                case "NewExpression":
-                    return node.type === "SequenceExpression";
-                case "IfStatement":
-                case "DoWhileStatement":
-                case "WhileStatement":
-                case "ForStatement":
-                    return false;
-                case "ConditionalExpression":
-                    return precedence(node) <= precedence(parent);
-                case "UnaryExpression":
-                    return precedence(node) < precedence(parent);
-                case "LogicalExpression":
-                    if (astUtils.isMixedLogicalAndCoalesceExpressions(node, parent)) {
-                        return true;
-                    }
-                    if (previousNode === parent.left) {
-                        return precedence(node) < precedence(parent);
-                    }
-                    return precedence(node) <= precedence(parent);
-
-                /* c8 ignore next */
-                default:
-                    throw new Error(`Unexpected parent type: ${parent.type}`);
-            }
-        }
-
-        return {
-            UnaryExpression(node) {
-                const parent = node.parent;
-
-
-                // Exit early if it's guaranteed not to match
-                if (node.operator !== "!" ||
-                          parent.type !== "UnaryExpression" ||
-                          parent.operator !== "!") {
-                    return;
-                }
-
-
-                if (isInFlaggedContext(parent)) {
-                    context.report({
-                        node: parent,
-                        messageId: "unexpectedNegation",
-                        fix(fixer) {
-                            if (hasCommentsInside(parent)) {
-                                return null;
-                            }
-
-                            if (needsParens(parent, node.argument)) {
-                                return fixer.replaceText(parent, `(${sourceCode.getText(node.argument)})`);
-                            }
-
-                            let prefix = "";
-                            const tokenBefore = sourceCode.getTokenBefore(parent);
-                            const firstReplacementToken = sourceCode.getFirstToken(node.argument);
-
-                            if (
-                                tokenBefore &&
-                                tokenBefore.range[1] === parent.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)
-                            ) {
-                                prefix = " ";
-                            }
-
-                            return fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));
-                        }
-                    });
-                }
-            },
-
-            CallExpression(node) {
-                if (node.callee.type !== "Identifier" || node.callee.name !== "Boolean") {
-                    return;
-                }
-
-                if (isInFlaggedContext(node)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedCall",
-                        fix(fixer) {
-                            const parent = node.parent;
-
-                            if (node.arguments.length === 0) {
-                                if (parent.type === "UnaryExpression" && parent.operator === "!") {
-
-                                    /*
-                                     * !Boolean() -> true
-                                     */
-
-                                    if (hasCommentsInside(parent)) {
-                                        return null;
-                                    }
-
-                                    const replacement = "true";
-                                    let prefix = "";
-                                    const tokenBefore = sourceCode.getTokenBefore(parent);
-
-                                    if (
-                                        tokenBefore &&
-                                        tokenBefore.range[1] === parent.range[0] &&
-                                        !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
-                                    ) {
-                                        prefix = " ";
-                                    }
-
-                                    return fixer.replaceText(parent, prefix + replacement);
-                                }
-
-                                /*
-                                 * Boolean() -> false
-                                 */
-
-                                if (hasCommentsInside(node)) {
-                                    return null;
-                                }
-
-                                return fixer.replaceText(node, "false");
-                            }
-
-                            if (node.arguments.length === 1) {
-                                const argument = node.arguments[0];
-
-                                if (argument.type === "SpreadElement" || hasCommentsInside(node)) {
-                                    return null;
-                                }
-
-                                /*
-                                 * Boolean(expression) -> expression
-                                 */
-
-                                if (needsParens(node, argument)) {
-                                    return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
-                                }
-
-                                return fixer.replaceText(node, sourceCode.getText(argument));
-                            }
-
-                            // two or more arguments
-                            return null;
-                        }
-                    });
-                }
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [{}],
+
+		docs: {
+			description: "Disallow unnecessary boolean casts",
+			recommended: true,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-extra-boolean-cast",
+		},
+
+		schema: [
+			{
+				anyOf: [
+					{
+						type: "object",
+						properties: {
+							enforceForInnerExpressions: {
+								type: "boolean",
+							},
+						},
+						additionalProperties: false,
+					},
+
+					// deprecated
+					{
+						type: "object",
+						properties: {
+							enforceForLogicalOperands: {
+								type: "boolean",
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+		],
+		fixable: "code",
+
+		messages: {
+			unexpectedCall: "Redundant Boolean call.",
+			unexpectedNegation: "Redundant double negation.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ enforceForLogicalOperands, enforceForInnerExpressions }] =
+			context.options;
+
+		// Node types which have a test which will coerce values to booleans.
+		const BOOLEAN_NODE_TYPES = new Set([
+			"IfStatement",
+			"DoWhileStatement",
+			"WhileStatement",
+			"ConditionalExpression",
+			"ForStatement",
+		]);
+
+		/**
+		 * Check if a node is a Boolean function or constructor.
+		 * @param {ASTNode} node the node
+		 * @returns {boolean} If the node is Boolean function or constructor
+		 */
+		function isBooleanFunctionOrConstructorCall(node) {
+			// Boolean(<bool>) and new Boolean(<bool>)
+			return (
+				(node.type === "CallExpression" ||
+					node.type === "NewExpression") &&
+				node.callee.type === "Identifier" &&
+				node.callee.name === "Boolean"
+			);
+		}
+
+		/**
+		 * Check if a node is in a context where its value would be coerced to a boolean at runtime.
+		 * @param {ASTNode} node The node
+		 * @returns {boolean} If it is in a boolean context
+		 */
+		function isInBooleanContext(node) {
+			return (
+				(isBooleanFunctionOrConstructorCall(node.parent) &&
+					node === node.parent.arguments[0]) ||
+				(BOOLEAN_NODE_TYPES.has(node.parent.type) &&
+					node === node.parent.test) ||
+				// !<bool>
+				(node.parent.type === "UnaryExpression" &&
+					node.parent.operator === "!")
+			);
+		}
+
+		/**
+		 * Checks whether the node is a context that should report an error
+		 * Acts recursively if it is in a logical context
+		 * @param {ASTNode} node the node
+		 * @returns {boolean} If the node is in one of the flagged contexts
+		 */
+		function isInFlaggedContext(node) {
+			if (node.parent.type === "ChainExpression") {
+				return isInFlaggedContext(node.parent);
+			}
+
+			/*
+			 * legacy behavior - enforceForLogicalOperands will only recurse on
+			 * logical expressions, not on other contexts.
+			 * enforceForInnerExpressions will recurse on logical expressions
+			 * as well as the other recursive syntaxes.
+			 */
+
+			if (enforceForLogicalOperands || enforceForInnerExpressions) {
+				if (node.parent.type === "LogicalExpression") {
+					if (
+						node.parent.operator === "||" ||
+						node.parent.operator === "&&"
+					) {
+						return isInFlaggedContext(node.parent);
+					}
+
+					// Check the right hand side of a `??` operator.
+					if (
+						enforceForInnerExpressions &&
+						node.parent.operator === "??" &&
+						node.parent.right === node
+					) {
+						return isInFlaggedContext(node.parent);
+					}
+				}
+			}
+
+			if (enforceForInnerExpressions) {
+				if (
+					node.parent.type === "ConditionalExpression" &&
+					(node.parent.consequent === node ||
+						node.parent.alternate === node)
+				) {
+					return isInFlaggedContext(node.parent);
+				}
+
+				/*
+				 * Check last expression only in a sequence, i.e. if ((1, 2, Boolean(3))) {}, since
+				 * the others don't affect the result of the expression.
+				 */
+				if (
+					node.parent.type === "SequenceExpression" &&
+					node.parent.expressions.at(-1) === node
+				) {
+					return isInFlaggedContext(node.parent);
+				}
+			}
+
+			return isInBooleanContext(node);
+		}
+
+		/**
+		 * Check if a node has comments inside.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} `true` if it has comments inside.
+		 */
+		function hasCommentsInside(node) {
+			return Boolean(sourceCode.getCommentsInside(node).length);
+		}
+
+		/**
+		 * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} `true` if the node is parenthesized.
+		 * @private
+		 */
+		function isParenthesized(node) {
+			return eslintUtils.isParenthesized(1, node, sourceCode);
+		}
+
+		/**
+		 * Determines whether the given node needs to be parenthesized when replacing the previous node.
+		 * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
+		 * of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
+		 * @param {ASTNode} previousNode Previous node.
+		 * @param {ASTNode} node The node to check.
+		 * @throws {Error} (Unreachable.)
+		 * @returns {boolean} `true` if the node needs to be parenthesized.
+		 */
+		function needsParens(previousNode, node) {
+			if (previousNode.parent.type === "ChainExpression") {
+				return needsParens(previousNode.parent, node);
+			}
+
+			if (isParenthesized(previousNode)) {
+				// parentheses around the previous node will stay, so there is no need for an additional pair
+				return false;
+			}
+
+			// parent of the previous node will become parent of the replacement node
+			const parent = previousNode.parent;
+
+			switch (parent.type) {
+				case "CallExpression":
+				case "NewExpression":
+					return node.type === "SequenceExpression";
+				case "IfStatement":
+				case "DoWhileStatement":
+				case "WhileStatement":
+				case "ForStatement":
+				case "SequenceExpression":
+					return false;
+				case "ConditionalExpression":
+					if (previousNode === parent.test) {
+						return precedence(node) <= precedence(parent);
+					}
+					if (
+						previousNode === parent.consequent ||
+						previousNode === parent.alternate
+					) {
+						return (
+							precedence(node) <
+							precedence({ type: "AssignmentExpression" })
+						);
+					}
+
+					/* c8 ignore next */
+					throw new Error(
+						"Ternary child must be test, consequent, or alternate.",
+					);
+				case "UnaryExpression":
+					return precedence(node) < precedence(parent);
+				case "LogicalExpression":
+					if (
+						astUtils.isMixedLogicalAndCoalesceExpressions(
+							node,
+							parent,
+						)
+					) {
+						return true;
+					}
+					if (previousNode === parent.left) {
+						return precedence(node) < precedence(parent);
+					}
+					return precedence(node) <= precedence(parent);
+
+				/* c8 ignore next */
+				default:
+					throw new Error(`Unexpected parent type: ${parent.type}`);
+			}
+		}
+
+		return {
+			UnaryExpression(node) {
+				const parent = node.parent;
+
+				// Exit early if it's guaranteed not to match
+				if (
+					node.operator !== "!" ||
+					parent.type !== "UnaryExpression" ||
+					parent.operator !== "!"
+				) {
+					return;
+				}
+
+				if (isInFlaggedContext(parent)) {
+					context.report({
+						node: parent,
+						messageId: "unexpectedNegation",
+						fix(fixer) {
+							if (hasCommentsInside(parent)) {
+								return null;
+							}
+
+							if (needsParens(parent, node.argument)) {
+								return fixer.replaceText(
+									parent,
+									`(${sourceCode.getText(node.argument)})`,
+								);
+							}
+
+							let prefix = "";
+							const tokenBefore =
+								sourceCode.getTokenBefore(parent);
+							const firstReplacementToken =
+								sourceCode.getFirstToken(node.argument);
+
+							if (
+								tokenBefore &&
+								tokenBefore.range[1] === parent.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									tokenBefore,
+									firstReplacementToken,
+								)
+							) {
+								prefix = " ";
+							}
+
+							return fixer.replaceText(
+								parent,
+								prefix + sourceCode.getText(node.argument),
+							);
+						},
+					});
+				}
+			},
+
+			CallExpression(node) {
+				if (
+					node.callee.type !== "Identifier" ||
+					node.callee.name !== "Boolean"
+				) {
+					return;
+				}
+
+				if (isInFlaggedContext(node)) {
+					context.report({
+						node,
+						messageId: "unexpectedCall",
+						fix(fixer) {
+							const parent = node.parent;
+
+							if (node.arguments.length === 0) {
+								if (
+									parent.type === "UnaryExpression" &&
+									parent.operator === "!"
+								) {
+									/*
+									 * !Boolean() -> true
+									 */
+
+									if (hasCommentsInside(parent)) {
+										return null;
+									}
+
+									const replacement = "true";
+									let prefix = "";
+									const tokenBefore =
+										sourceCode.getTokenBefore(parent);
+
+									if (
+										tokenBefore &&
+										tokenBefore.range[1] ===
+											parent.range[0] &&
+										!astUtils.canTokensBeAdjacent(
+											tokenBefore,
+											replacement,
+										)
+									) {
+										prefix = " ";
+									}
+
+									return fixer.replaceText(
+										parent,
+										prefix + replacement,
+									);
+								}
+
+								/*
+								 * Boolean() -> false
+								 */
+
+								if (hasCommentsInside(node)) {
+									return null;
+								}
+
+								return fixer.replaceText(node, "false");
+							}
+
+							if (node.arguments.length === 1) {
+								const argument = node.arguments[0];
+
+								if (
+									argument.type === "SpreadElement" ||
+									hasCommentsInside(node)
+								) {
+									return null;
+								}
+
+								/*
+								 * Boolean(expression) -> expression
+								 */
+
+								if (needsParens(node, argument)) {
+									return fixer.replaceText(
+										node,
+										`(${sourceCode.getText(argument)})`,
+									);
+								}
+
+								return fixer.replaceText(
+									node,
+									sourceCode.getText(argument),
+								);
+							}
+
+							// two or more arguments
+							return null;
+						},
+					});
+				}
+			},
+		};
+	},
 };