node_modules/eslint/lib/rules/no-extra-boolean-cast.js

/**
 * @fileoverview Rule to flag unnecessary double negation in Boolean contexts
 * @author Brandon Mills
 */

"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require("./utils/ast-utils");
const eslintUtils = require("@eslint-community/eslint-utils");

const precedence = astUtils.getPrecedence;

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
	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;
						},
					});
				}
			},
		};
	},
};