eslint 8.57.1 → 9.39.1

package/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-    return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
+	return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-    return /^(==|===)$/u.test(operator);
+	return /^(?:==|===)$/u.test(operator);
 }
 
 /**
@@ -39,7 +39,7 @@ function isEqualityOperator(operator) {
  * @returns {boolean} Whether the operator is used in range tests.
  */
 function isRangeTestOperator(operator) {
-    return ["<", "<="].includes(operator);
+	return ["<", "<="].includes(operator);
 }
 
 /**
@@ -50,12 +50,12 @@ function isRangeTestOperator(operator) {
  *                    real literal and should be treated as such.
  */
 function isNegativeNumericLiteral(node) {
-    return (
-        node.type === "UnaryExpression" &&
-        node.operator === "-" &&
-        node.prefix &&
-        astUtils.isNumericLiteral(node.argument)
-    );
+	return (
+		node.type === "UnaryExpression" &&
+		node.operator === "-" &&
+		node.prefix &&
+		astUtils.isNumericLiteral(node.argument)
+	);
 }
 
 /**
@@ -64,7 +64,9 @@ function isNegativeNumericLiteral(node) {
  * @returns {boolean} True if the node should be treated as a single Literal node.
  */
 function looksLikeLiteral(node) {
-    return isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node);
+	return (
+		isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node)
+	);
 }
 
 /**
@@ -79,275 +81,282 @@ function looksLikeLiteral(node) {
  *  4. Otherwise `null`.
  */
 function getNormalizedLiteral(node) {
-    if (node.type === "Literal") {
-        return node;
-    }
-
-    if (isNegativeNumericLiteral(node)) {
-        return {
-            type: "Literal",
-            value: -node.argument.value,
-            raw: `-${node.argument.value}`
-        };
-    }
-
-    if (astUtils.isStaticTemplateLiteral(node)) {
-        return {
-            type: "Literal",
-            value: node.quasis[0].value.cooked,
-            raw: node.quasis[0].value.raw
-        };
-    }
-
-    return null;
+	if (node.type === "Literal") {
+		return node;
+	}
+
+	if (isNegativeNumericLiteral(node)) {
+		return {
+			type: "Literal",
+			value: -node.argument.value,
+			raw: `-${node.argument.value}`,
+		};
+	}
+
+	if (astUtils.isStaticTemplateLiteral(node)) {
+		return {
+			type: "Literal",
+			value: node.quasis[0].value.cooked,
+			raw: node.quasis[0].value.raw,
+		};
+	}
+
+	return null;
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: 'Require or disallow "Yoda" conditions',
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/yoda"
-        },
-
-        schema: [
-            {
-                enum: ["always", "never"]
-            },
-            {
-                type: "object",
-                properties: {
-                    exceptRange: {
-                        type: "boolean",
-                        default: false
-                    },
-                    onlyEquality: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-        messages: {
-            expected:
-                "Expected literal to be on the {{expectedSide}} side of {{operator}}."
-        }
-    },
-
-    create(context) {
-
-        // Default to "never" (!always) if no option
-        const always = context.options[0] === "always";
-        const exceptRange =
-            context.options[1] && context.options[1].exceptRange;
-        const onlyEquality =
-            context.options[1] && context.options[1].onlyEquality;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether node represents a range test.
-         * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside"
-         * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and
-         * both operators must be `<` or `<=`. Finally, the literal on the left side
-         * must be less than or equal to the literal on the right side so that the
-         * test makes any sense.
-         * @param {ASTNode} node LogicalExpression node to test.
-         * @returns {boolean} Whether node is a range test.
-         */
-        function isRangeTest(node) {
-            const left = node.left,
-                right = node.right;
-
-            /**
-             * Determines whether node is of the form `0 <= x && x < 1`.
-             * @returns {boolean} Whether node is a "between" range test.
-             */
-            function isBetweenTest() {
-                if (node.operator === "&&" && astUtils.isSameReference(left.right, right.left)) {
-                    const leftLiteral = getNormalizedLiteral(left.left);
-                    const rightLiteral = getNormalizedLiteral(right.right);
-
-                    if (leftLiteral === null && rightLiteral === null) {
-                        return false;
-                    }
-
-                    if (rightLiteral === null || leftLiteral === null) {
-                        return true;
-                    }
-
-                    if (leftLiteral.value <= rightLiteral.value) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            /**
-             * Determines whether node is of the form `x < 0 || 1 <= x`.
-             * @returns {boolean} Whether node is an "outside" range test.
-             */
-            function isOutsideTest() {
-                if (node.operator === "||" && astUtils.isSameReference(left.left, right.right)) {
-                    const leftLiteral = getNormalizedLiteral(left.right);
-                    const rightLiteral = getNormalizedLiteral(right.left);
-
-                    if (leftLiteral === null && rightLiteral === null) {
-                        return false;
-                    }
-
-                    if (rightLiteral === null || leftLiteral === null) {
-                        return true;
-                    }
-
-                    if (leftLiteral.value <= rightLiteral.value) {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            /**
-             * Determines whether node is wrapped in parentheses.
-             * @returns {boolean} Whether node is preceded immediately by an open
-             *                    paren token and followed immediately by a close
-             *                    paren token.
-             */
-            function isParenWrapped() {
-                return astUtils.isParenthesised(sourceCode, node);
-            }
-
-            return (
-                node.type === "LogicalExpression" &&
-                left.type === "BinaryExpression" &&
-                right.type === "BinaryExpression" &&
-                isRangeTestOperator(left.operator) &&
-                isRangeTestOperator(right.operator) &&
-                (isBetweenTest() || isOutsideTest()) &&
-                isParenWrapped()
-            );
-        }
-
-        const OPERATOR_FLIP_MAP = {
-            "===": "===",
-            "!==": "!==",
-            "==": "==",
-            "!=": "!=",
-            "<": ">",
-            ">": "<",
-            "<=": ">=",
-            ">=": "<="
-        };
-
-        /**
-         * Returns a string representation of a BinaryExpression node with its sides/operator flipped around.
-         * @param {ASTNode} node The BinaryExpression node
-         * @returns {string} A string representation of the node with the sides and operator flipped
-         */
-        function getFlippedString(node) {
-            const operatorToken = sourceCode.getFirstTokenBetween(
-                node.left,
-                node.right,
-                token => token.value === node.operator
-            );
-            const lastLeftToken = sourceCode.getTokenBefore(operatorToken);
-            const firstRightToken = sourceCode.getTokenAfter(operatorToken);
-
-            const source = sourceCode.getText();
-
-            const leftText = source.slice(
-                node.range[0],
-                lastLeftToken.range[1]
-            );
-            const textBeforeOperator = source.slice(
-                lastLeftToken.range[1],
-                operatorToken.range[0]
-            );
-            const textAfterOperator = source.slice(
-                operatorToken.range[1],
-                firstRightToken.range[0]
-            );
-            const rightText = source.slice(
-                firstRightToken.range[0],
-                node.range[1]
-            );
-
-            const tokenBefore = sourceCode.getTokenBefore(node);
-            const tokenAfter = sourceCode.getTokenAfter(node);
-            let prefix = "";
-            let suffix = "";
-
-            if (
-                tokenBefore &&
-                tokenBefore.range[1] === node.range[0] &&
-                !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)
-            ) {
-                prefix = " ";
-            }
-
-            if (
-                tokenAfter &&
-                node.range[1] === tokenAfter.range[0] &&
-                !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter)
-            ) {
-                suffix = " ";
-            }
-
-            return (
-                prefix +
-                rightText +
-                textBeforeOperator +
-                OPERATOR_FLIP_MAP[operatorToken.value] +
-                textAfterOperator +
-                leftText +
-                suffix
-            );
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            BinaryExpression(node) {
-                const expectedLiteral = always ? node.left : node.right;
-                const expectedNonLiteral = always ? node.right : node.left;
-
-                // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.
-                if (
-                    (expectedNonLiteral.type === "Literal" ||
-                        looksLikeLiteral(expectedNonLiteral)) &&
-                    !(
-                        expectedLiteral.type === "Literal" ||
-                        looksLikeLiteral(expectedLiteral)
-                    ) &&
-                    !(!isEqualityOperator(node.operator) && onlyEquality) &&
-                    isComparisonOperator(node.operator) &&
-                    !(exceptRange && isRangeTest(node.parent))
-                ) {
-                    context.report({
-                        node,
-                        messageId: "expected",
-                        data: {
-                            operator: node.operator,
-                            expectedSide: always ? "left" : "right"
-                        },
-                        fix: fixer =>
-                            fixer.replaceText(node, getFlippedString(node))
-                    });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			"never",
+			{
+				exceptRange: false,
+				onlyEquality: false,
+			},
+		],
+
+		docs: {
+			description: 'Require or disallow "Yoda" conditions',
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/yoda",
+		},
+
+		schema: [
+			{
+				enum: ["always", "never"],
+			},
+			{
+				type: "object",
+				properties: {
+					exceptRange: {
+						type: "boolean",
+					},
+					onlyEquality: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+		messages: {
+			expected:
+				"Expected literal to be on the {{expectedSide}} side of {{operator}}.",
+		},
+	},
+
+	create(context) {
+		const [when, { exceptRange, onlyEquality }] = context.options;
+		const always = when === "always";
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether node represents a range test.
+		 * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside"
+		 * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and
+		 * both operators must be `<` or `<=`. Finally, the literal on the left side
+		 * must be less than or equal to the literal on the right side so that the
+		 * test makes any sense.
+		 * @param {ASTNode} node LogicalExpression node to test.
+		 * @returns {boolean} Whether node is a range test.
+		 */
+		function isRangeTest(node) {
+			const left = node.left,
+				right = node.right;
+
+			/**
+			 * Determines whether node is of the form `0 <= x && x < 1`.
+			 * @returns {boolean} Whether node is a "between" range test.
+			 */
+			function isBetweenTest() {
+				if (
+					node.operator === "&&" &&
+					astUtils.isSameReference(left.right, right.left)
+				) {
+					const leftLiteral = getNormalizedLiteral(left.left);
+					const rightLiteral = getNormalizedLiteral(right.right);
+
+					if (leftLiteral === null && rightLiteral === null) {
+						return false;
+					}
+
+					if (rightLiteral === null || leftLiteral === null) {
+						return true;
+					}
+
+					if (leftLiteral.value <= rightLiteral.value) {
+						return true;
+					}
+				}
+				return false;
+			}
+
+			/**
+			 * Determines whether node is of the form `x < 0 || 1 <= x`.
+			 * @returns {boolean} Whether node is an "outside" range test.
+			 */
+			function isOutsideTest() {
+				if (
+					node.operator === "||" &&
+					astUtils.isSameReference(left.left, right.right)
+				) {
+					const leftLiteral = getNormalizedLiteral(left.right);
+					const rightLiteral = getNormalizedLiteral(right.left);
+
+					if (leftLiteral === null && rightLiteral === null) {
+						return false;
+					}
+
+					if (rightLiteral === null || leftLiteral === null) {
+						return true;
+					}
+
+					if (leftLiteral.value <= rightLiteral.value) {
+						return true;
+					}
+				}
+
+				return false;
+			}
+
+			/**
+			 * Determines whether node is wrapped in parentheses.
+			 * @returns {boolean} Whether node is preceded immediately by an open
+			 *                    paren token and followed immediately by a close
+			 *                    paren token.
+			 */
+			function isParenWrapped() {
+				return astUtils.isParenthesised(sourceCode, node);
+			}
+
+			return (
+				node.type === "LogicalExpression" &&
+				left.type === "BinaryExpression" &&
+				right.type === "BinaryExpression" &&
+				isRangeTestOperator(left.operator) &&
+				isRangeTestOperator(right.operator) &&
+				(isBetweenTest() || isOutsideTest()) &&
+				isParenWrapped()
+			);
+		}
+
+		const OPERATOR_FLIP_MAP = {
+			"===": "===",
+			"!==": "!==",
+			"==": "==",
+			"!=": "!=",
+			"<": ">",
+			">": "<",
+			"<=": ">=",
+			">=": "<=",
+		};
+
+		/**
+		 * Returns a string representation of a BinaryExpression node with its sides/operator flipped around.
+		 * @param {ASTNode} node The BinaryExpression node
+		 * @returns {string} A string representation of the node with the sides and operator flipped
+		 */
+		function getFlippedString(node) {
+			const operatorToken = sourceCode.getFirstTokenBetween(
+				node.left,
+				node.right,
+				token => token.value === node.operator,
+			);
+			const lastLeftToken = sourceCode.getTokenBefore(operatorToken);
+			const firstRightToken = sourceCode.getTokenAfter(operatorToken);
+
+			const source = sourceCode.getText();
+
+			const leftText = source.slice(
+				node.range[0],
+				lastLeftToken.range[1],
+			);
+			const textBeforeOperator = source.slice(
+				lastLeftToken.range[1],
+				operatorToken.range[0],
+			);
+			const textAfterOperator = source.slice(
+				operatorToken.range[1],
+				firstRightToken.range[0],
+			);
+			const rightText = source.slice(
+				firstRightToken.range[0],
+				node.range[1],
+			);
+
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			const tokenAfter = sourceCode.getTokenAfter(node);
+			let prefix = "";
+			let suffix = "";
+
+			if (
+				tokenBefore &&
+				tokenBefore.range[1] === node.range[0] &&
+				!astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)
+			) {
+				prefix = " ";
+			}
+
+			if (
+				tokenAfter &&
+				node.range[1] === tokenAfter.range[0] &&
+				!astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter)
+			) {
+				suffix = " ";
+			}
+
+			return (
+				prefix +
+				rightText +
+				textBeforeOperator +
+				OPERATOR_FLIP_MAP[operatorToken.value] +
+				textAfterOperator +
+				leftText +
+				suffix
+			);
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			BinaryExpression(node) {
+				const expectedLiteral = always ? node.left : node.right;
+				const expectedNonLiteral = always ? node.right : node.left;
+
+				// If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.
+				if (
+					(expectedNonLiteral.type === "Literal" ||
+						looksLikeLiteral(expectedNonLiteral)) &&
+					!(
+						expectedLiteral.type === "Literal" ||
+						looksLikeLiteral(expectedLiteral)
+					) &&
+					!(!isEqualityOperator(node.operator) && onlyEquality) &&
+					isComparisonOperator(node.operator) &&
+					!(exceptRange && isRangeTest(node.parent))
+				) {
+					context.report({
+						node,
+						messageId: "expected",
+						data: {
+							operator: node.operator,
+							expectedSide: always ? "left" : "right",
+						},
+						fix: fixer =>
+							fixer.replaceText(node, getFlippedString(node)),
+					});
+				}
+			},
+		};
+	},
 };