Add components

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

@@ -0,0 +1,420 @@
+/**
+ * @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;
+						},
+					});
+				}
+			},
+		};
+	},
+};