eslint 8.57.1 → 9.39.1

package/lib/rules/eqeqeq.js

@@ -15,160 +15,196 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require the use of `===` and `!==`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/eqeqeq"
-        },
-
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always"]
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                null: {
-                                    enum: ["always", "never", "ignore"]
-                                }
-                            },
-                            additionalProperties: false
-                        }
-                    ],
-                    additionalItems: false
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["smart", "allow-null"]
-                        }
-                    ],
-                    additionalItems: false
-                }
-            ]
-        },
-
-        fixable: "code",
-
-        messages: {
-            unexpected: "Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'."
-        }
-    },
-
-    create(context) {
-        const config = context.options[0] || "always";
-        const options = context.options[1] || {};
-        const sourceCode = context.sourceCode;
-
-        const nullOption = (config === "always")
-            ? options.null || "always"
-            : "ignore";
-        const enforceRuleForNull = (nullOption === "always");
-        const enforceInverseRuleForNull = (nullOption === "never");
-
-        /**
-         * Checks if an expression is a typeof expression
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} if the node is a typeof expression
-         */
-        function isTypeOf(node) {
-            return node.type === "UnaryExpression" && node.operator === "typeof";
-        }
-
-        /**
-         * Checks if either operand of a binary expression is a typeof operation
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} if one of the operands is typeof
-         * @private
-         */
-        function isTypeOfBinary(node) {
-            return isTypeOf(node.left) || isTypeOf(node.right);
-        }
-
-        /**
-         * Checks if operands are literals of the same type (via typeof)
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} if operands are of same type
-         * @private
-         */
-        function areLiteralsAndSameType(node) {
-            return node.left.type === "Literal" && node.right.type === "Literal" &&
-                    typeof node.left.value === typeof node.right.value;
-        }
-
-        /**
-         * Checks if one of the operands is a literal null
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} if operands are null
-         * @private
-         */
-        function isNullCheck(node) {
-            return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
-        }
-
-        /**
-         * Reports a message for this rule.
-         * @param {ASTNode} node The binary expression node that was checked
-         * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
-         * @returns {void}
-         * @private
-         */
-        function report(node, expectedOperator) {
-            const operatorToken = sourceCode.getFirstTokenBetween(
-                node.left,
-                node.right,
-                token => token.value === node.operator
-            );
-
-            context.report({
-                node,
-                loc: operatorToken.loc,
-                messageId: "unexpected",
-                data: { expectedOperator, actualOperator: node.operator },
-                fix(fixer) {
-
-                    // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
-                    if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-                        return fixer.replaceText(operatorToken, expectedOperator);
-                    }
-                    return null;
-                }
-            });
-        }
-
-        return {
-            BinaryExpression(node) {
-                const isNull = isNullCheck(node);
-
-                if (node.operator !== "==" && node.operator !== "!=") {
-                    if (enforceInverseRuleForNull && isNull) {
-                        report(node, node.operator.slice(0, -1));
-                    }
-                    return;
-                }
-
-                if (config === "smart" && (isTypeOfBinary(node) ||
-                        areLiteralsAndSameType(node) || isNull)) {
-                    return;
-                }
-
-                if (!enforceRuleForNull && isNull) {
-                    return;
-                }
-
-                report(node, `${node.operator}=`);
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+
+		docs: {
+			description: "Require the use of `===` and `!==`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/eqeqeq",
+		},
+
+		schema: {
+			anyOf: [
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["always"],
+						},
+						{
+							type: "object",
+							properties: {
+								null: {
+									enum: ["always", "never", "ignore"],
+								},
+							},
+							additionalProperties: false,
+						},
+					],
+					additionalItems: false,
+				},
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["smart", "allow-null"],
+						},
+					],
+					additionalItems: false,
+				},
+			],
+		},
+
+		fixable: "code",
+
+		messages: {
+			unexpected:
+				"Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.",
+			replaceOperator:
+				"Use '{{expectedOperator}}' instead of '{{actualOperator}}'.",
+		},
+	},
+
+	create(context) {
+		const config = context.options[0] || "always";
+		const options = context.options[1] || {};
+		const sourceCode = context.sourceCode;
+
+		const nullOption =
+			config === "always" ? options.null || "always" : "ignore";
+		const enforceRuleForNull = nullOption === "always";
+		const enforceInverseRuleForNull = nullOption === "never";
+
+		/**
+		 * Checks if an expression is a typeof expression
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if the node is a typeof expression
+		 */
+		function isTypeOf(node) {
+			return (
+				node.type === "UnaryExpression" && node.operator === "typeof"
+			);
+		}
+
+		/**
+		 * Checks if either operand of a binary expression is a typeof operation
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if one of the operands is typeof
+		 * @private
+		 */
+		function isTypeOfBinary(node) {
+			return isTypeOf(node.left) || isTypeOf(node.right);
+		}
+
+		/**
+		 * Checks if operands are literals of the same type (via typeof)
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if operands are of same type
+		 * @private
+		 */
+		function areLiteralsAndSameType(node) {
+			return (
+				node.left.type === "Literal" &&
+				node.right.type === "Literal" &&
+				typeof node.left.value === typeof node.right.value
+			);
+		}
+
+		/**
+		 * Checks if one of the operands is a literal null
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if operands are null
+		 * @private
+		 */
+		function isNullCheck(node) {
+			return (
+				astUtils.isNullLiteral(node.right) ||
+				astUtils.isNullLiteral(node.left)
+			);
+		}
+
+		/**
+		 * Reports a message for this rule.
+		 * @param {ASTNode} node The binary expression node that was checked
+		 * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
+		 * @returns {void}
+		 * @private
+		 */
+		function report(node, expectedOperator) {
+			const operatorToken = sourceCode.getFirstTokenBetween(
+				node.left,
+				node.right,
+				token => token.value === node.operator,
+			);
+
+			const commonReportParams = {
+				node,
+				loc: operatorToken.loc,
+				messageId: "unexpected",
+				data: { expectedOperator, actualOperator: node.operator },
+			};
+
+			if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
+				context.report({
+					...commonReportParams,
+					fix(fixer) {
+						return fixer.replaceText(
+							operatorToken,
+							expectedOperator,
+						);
+					},
+				});
+			} else {
+				context.report({
+					...commonReportParams,
+					suggest: [
+						{
+							messageId: "replaceOperator",
+							data: {
+								expectedOperator,
+								actualOperator: node.operator,
+							},
+							fix: fixer =>
+								fixer.replaceText(
+									operatorToken,
+									expectedOperator,
+								),
+						},
+					],
+				});
+			}
+		}
+
+		return {
+			BinaryExpression(node) {
+				const isNull = isNullCheck(node);
+
+				if (node.operator !== "==" && node.operator !== "!=") {
+					if (enforceInverseRuleForNull && isNull) {
+						report(node, node.operator.slice(0, -1));
+					}
+					return;
+				}
+
+				if (
+					config === "smart" &&
+					(isTypeOfBinary(node) ||
+						areLiteralsAndSameType(node) ||
+						isNull)
+				) {
+					return;
+				}
+
+				if (!enforceRuleForNull && isNull) {
+					return;
+				}
+
+				report(node, `${node.operator}=`);
+			},
+		};
+	},
 };

package/lib/rules/for-direction.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview enforce "for" loop update clause moving the counter in the right direction.(for-direction)
+ * @fileoverview enforce `for` loop update clause moving the counter in the right direction.(for-direction)
  * @author Aladdin-ADD<hh_2013@foxmail.com>
  */
 
@@ -15,126 +15,154 @@ const { getStaticValue } = require("@eslint-community/eslint-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Enforce \"for\" loop update clause moving the counter in the right direction",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/for-direction"
-        },
-
-        fixable: null,
-        schema: [],
-
-        messages: {
-            incorrectDirection: "The update clause in this loop moves the variable in the wrong direction."
-        }
-    },
-
-    create(context) {
-        const { sourceCode } = context;
-
-        /**
-         * report an error.
-         * @param {ASTNode} node the node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({
-                node,
-                messageId: "incorrectDirection"
-            });
-        }
-
-        /**
-         * check the right side of the assignment
-         * @param {ASTNode} update UpdateExpression to check
-         * @param {int} dir expected direction that could either be turned around or invalidated
-         * @returns {int} return dir, the negated dir, or zero if the counter does not change or the direction is not clear
-         */
-        function getRightDirection(update, dir) {
-            const staticValue = getStaticValue(update.right, sourceCode.getScope(update));
-
-            if (staticValue && ["bigint", "boolean", "number"].includes(typeof staticValue.value)) {
-                const sign = Math.sign(Number(staticValue.value)) || 0; // convert NaN to 0
-
-                return dir * sign;
-            }
-            return 0;
-        }
-
-        /**
-         * check UpdateExpression add/sub the counter
-         * @param {ASTNode} update UpdateExpression to check
-         * @param {string} counter variable name to check
-         * @returns {int} if add return 1, if sub return -1, if nochange, return 0
-         */
-        function getUpdateDirection(update, counter) {
-            if (update.argument.type === "Identifier" && update.argument.name === counter) {
-                if (update.operator === "++") {
-                    return 1;
-                }
-                if (update.operator === "--") {
-                    return -1;
-                }
-            }
-            return 0;
-        }
-
-        /**
-         * check AssignmentExpression add/sub the counter
-         * @param {ASTNode} update AssignmentExpression to check
-         * @param {string} counter variable name to check
-         * @returns {int} if add return 1, if sub return -1, if nochange, return 0
-         */
-        function getAssignmentDirection(update, counter) {
-            if (update.left.name === counter) {
-                if (update.operator === "+=") {
-                    return getRightDirection(update, 1);
-                }
-                if (update.operator === "-=") {
-                    return getRightDirection(update, -1);
-                }
-            }
-            return 0;
-        }
-
-        return {
-            ForStatement(node) {
-
-                if (node.test && node.test.type === "BinaryExpression" && node.update) {
-                    for (const counterPosition of ["left", "right"]) {
-                        if (node.test[counterPosition].type !== "Identifier") {
-                            continue;
-                        }
-
-                        const counter = node.test[counterPosition].name;
-                        const operator = node.test.operator;
-                        const update = node.update;
-
-                        let wrongDirection;
-
-                        if (operator === "<" || operator === "<=") {
-                            wrongDirection = counterPosition === "left" ? -1 : 1;
-                        } else if (operator === ">" || operator === ">=") {
-                            wrongDirection = counterPosition === "left" ? 1 : -1;
-                        } else {
-                            return;
-                        }
-
-                        if (update.type === "UpdateExpression") {
-                            if (getUpdateDirection(update, counter) === wrongDirection) {
-                                report(node);
-                            }
-                        } else if (update.type === "AssignmentExpression" && getAssignmentDirection(update, counter) === wrongDirection) {
-                            report(node);
-                        }
-                    }
-                }
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Enforce `for` loop update clause moving the counter in the right direction",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/for-direction",
+		},
+
+		fixable: null,
+		schema: [],
+
+		messages: {
+			incorrectDirection:
+				"The update clause in this loop moves the variable in the wrong direction.",
+		},
+	},
+
+	create(context) {
+		const { sourceCode } = context;
+
+		/**
+		 * report an error.
+		 * @param {ASTNode} node the node to report.
+		 * @returns {void}
+		 */
+		function report(node) {
+			context.report({
+				loc: {
+					start: node.loc.start,
+					end: sourceCode.getTokenBefore(node.body).loc.end,
+				},
+				messageId: "incorrectDirection",
+			});
+		}
+
+		/**
+		 * check the right side of the assignment
+		 * @param {ASTNode} update UpdateExpression to check
+		 * @param {number} dir expected direction that could either be turned around or invalidated
+		 * @returns {number} return dir, the negated dir, or zero if the counter does not change or the direction is not clear
+		 */
+		function getRightDirection(update, dir) {
+			const staticValue = getStaticValue(
+				update.right,
+				sourceCode.getScope(update),
+			);
+
+			if (
+				staticValue &&
+				["bigint", "boolean", "number"].includes(
+					typeof staticValue.value,
+				)
+			) {
+				const sign = Math.sign(Number(staticValue.value)) || 0; // convert NaN to 0
+
+				return dir * sign;
+			}
+			return 0;
+		}
+
+		/**
+		 * check UpdateExpression add/sub the counter
+		 * @param {ASTNode} update UpdateExpression to check
+		 * @param {string} counter variable name to check
+		 * @returns {number} if add return 1, if sub return -1, if nochange, return 0
+		 */
+		function getUpdateDirection(update, counter) {
+			if (
+				update.argument.type === "Identifier" &&
+				update.argument.name === counter
+			) {
+				if (update.operator === "++") {
+					return 1;
+				}
+				if (update.operator === "--") {
+					return -1;
+				}
+			}
+			return 0;
+		}
+
+		/**
+		 * check AssignmentExpression add/sub the counter
+		 * @param {ASTNode} update AssignmentExpression to check
+		 * @param {string} counter variable name to check
+		 * @returns {number} if add return 1, if sub return -1, if nochange, return 0
+		 */
+		function getAssignmentDirection(update, counter) {
+			if (update.left.name === counter) {
+				if (update.operator === "+=") {
+					return getRightDirection(update, 1);
+				}
+				if (update.operator === "-=") {
+					return getRightDirection(update, -1);
+				}
+			}
+			return 0;
+		}
+
+		return {
+			ForStatement(node) {
+				if (
+					node.test &&
+					node.test.type === "BinaryExpression" &&
+					node.update
+				) {
+					for (const counterPosition of ["left", "right"]) {
+						if (node.test[counterPosition].type !== "Identifier") {
+							continue;
+						}
+
+						const counter = node.test[counterPosition].name;
+						const operator = node.test.operator;
+						const update = node.update;
+
+						let wrongDirection;
+
+						if (operator === "<" || operator === "<=") {
+							wrongDirection =
+								counterPosition === "left" ? -1 : 1;
+						} else if (operator === ">" || operator === ">=") {
+							wrongDirection =
+								counterPosition === "left" ? 1 : -1;
+						} else {
+							return;
+						}
+
+						if (update.type === "UpdateExpression") {
+							if (
+								getUpdateDirection(update, counter) ===
+								wrongDirection
+							) {
+								report(node);
+							}
+						} else if (
+							update.type === "AssignmentExpression" &&
+							getAssignmentDirection(update, counter) ===
+								wrongDirection
+						) {
+							report(node);
+						}
+					}
+				}
+			},
+		};
+	},
 };