eslint 8.57.1 → 9.39.1

package/lib/rules/no-catch-shadow.js

@@ -16,67 +16,81 @@ 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: "Disallow `catch` clause parameters from shadowing variables in the outer scope",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-catch-shadow"
-        },
-
-        replacedBy: ["no-shadow"],
-
-        deprecated: true,
-        schema: [],
-
-        messages: {
-            mutable: "Value of '{{name}}' may be overwritten in IE 8 and earlier."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Check if the parameters are been shadowed
-         * @param {Object} scope current scope
-         * @param {string} name parameter name
-         * @returns {boolean} True is its been shadowed
-         */
-        function paramIsShadowing(scope, name) {
-            return astUtils.getVariableByName(scope, name) !== null;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            "CatchClause[param!=null]"(node) {
-                let scope = sourceCode.getScope(node);
-
-                /*
-                 * When ecmaVersion >= 6, CatchClause creates its own scope
-                 * so start from one upper scope to exclude the current node
-                 */
-                if (scope.block === node) {
-                    scope = scope.upper;
-                }
-
-                if (paramIsShadowing(scope, node.param.name)) {
-                    context.report({ node, messageId: "mutable", data: { name: node.param.name } });
-                }
-            }
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `catch` clause parameters from shadowing variables in the outer scope",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-catch-shadow",
+		},
+
+		deprecated: {
+			message: "This rule was renamed.",
+			url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/",
+			deprecatedSince: "5.1.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-shadow",
+						url: "https://eslint.org/docs/rules/no-shadow",
+					},
+				},
+			],
+		},
+		schema: [],
+
+		messages: {
+			mutable:
+				"Value of '{{name}}' may be overwritten in IE 8 and earlier.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Check if the parameters are been shadowed
+		 * @param {Object} scope current scope
+		 * @param {string} name parameter name
+		 * @returns {boolean} True is its been shadowed
+		 */
+		function paramIsShadowing(scope, name) {
+			return astUtils.getVariableByName(scope, name) !== null;
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			"CatchClause[param!=null]"(node) {
+				let scope = sourceCode.getScope(node);
+
+				/*
+				 * When ecmaVersion >= 6, CatchClause creates its own scope
+				 * so start from one upper scope to exclude the current node
+				 */
+				if (scope.block === node) {
+					scope = scope.upper;
+				}
+
+				if (paramIsShadowing(scope, node.param.name)) {
+					context.report({
+						node,
+						messageId: "mutable",
+						data: { name: node.param.name },
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-class-assign.js

@@ -11,53 +11,56 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow reassigning class members",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-class-assign"
-        },
-
-        schema: [],
-
-        messages: {
-            class: "'{{name}}' is a class."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable A variable to check.
-         * @returns {void}
-         */
-        function checkVariable(variable) {
-            astUtils.getModifyingReferences(variable.references).forEach(reference => {
-                context.report({ node: reference.identifier, messageId: "class", data: { name: reference.identifier.name } });
-
-            });
-        }
-
-        /**
-         * Finds and reports references that are non initializer and writable.
-         * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
-         * @returns {void}
-         */
-        function checkForClass(node) {
-            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-        }
-
-        return {
-            ClassDeclaration: checkForClass,
-            ClassExpression: checkForClass
-        };
-
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow reassigning class members",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-class-assign",
+		},
+
+		schema: [],
+
+		messages: {
+			class: "'{{name}}' is a class.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {Variable} variable A variable to check.
+		 * @returns {void}
+		 */
+		function checkVariable(variable) {
+			astUtils
+				.getModifyingReferences(variable.references)
+				.forEach(reference => {
+					context.report({
+						node: reference.identifier,
+						messageId: "class",
+						data: { name: reference.identifier.name },
+					});
+				});
+		}
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
+		 * @returns {void}
+		 */
+		function checkForClass(node) {
+			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+		}
+
+		return {
+			ClassDeclaration: checkForClass,
+			ClassExpression: checkForClass,
+		};
+	},
 };

package/lib/rules/no-compare-neg-zero.js

@@ -8,53 +8,67 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow comparing against -0",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero"
-        },
-
-        fixable: null,
-        schema: [],
-
-        messages: {
-            unexpected: "Do not use the '{{operator}}' operator to compare against -0."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Checks a given node is -0
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} `true` if the node is -0.
-         */
-        function isNegZero(node) {
-            return node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && node.argument.value === 0;
-        }
-        const OPERATORS_TO_CHECK = new Set([">", ">=", "<", "<=", "==", "===", "!=", "!=="]);
-
-        return {
-            BinaryExpression(node) {
-                if (OPERATORS_TO_CHECK.has(node.operator)) {
-                    if (isNegZero(node.left) || isNegZero(node.right)) {
-                        context.report({
-                            node,
-                            messageId: "unexpected",
-                            data: { operator: node.operator }
-                        });
-                    }
-                }
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow comparing against `-0`",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero",
+		},
+
+		fixable: null,
+		schema: [],
+
+		messages: {
+			unexpected:
+				"Do not use the '{{operator}}' operator to compare against -0.",
+		},
+	},
+
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks a given node is -0
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} `true` if the node is -0.
+		 */
+		function isNegZero(node) {
+			return (
+				node.type === "UnaryExpression" &&
+				node.operator === "-" &&
+				node.argument.type === "Literal" &&
+				node.argument.value === 0
+			);
+		}
+		const OPERATORS_TO_CHECK = new Set([
+			">",
+			">=",
+			"<",
+			"<=",
+			"==",
+			"===",
+			"!=",
+			"!==",
+		]);
+
+		return {
+			BinaryExpression(node) {
+				if (OPERATORS_TO_CHECK.has(node.operator)) {
+					if (isNegZero(node.left) || isNegZero(node.right)) {
+						context.report({
+							node,
+							messageId: "unexpected",
+							data: { operator: node.operator },
+						});
+					}
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-cond-assign.js

@@ -15,145 +15,161 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const TEST_CONDITION_PARENT_TYPES = new Set(["IfStatement", "WhileStatement", "DoWhileStatement", "ForStatement", "ConditionalExpression"]);
+const TEST_CONDITION_PARENT_TYPES = new Set([
+	"IfStatement",
+	"WhileStatement",
+	"DoWhileStatement",
+	"ForStatement",
+	"ConditionalExpression",
+]);
 
 const NODE_DESCRIPTIONS = {
-    DoWhileStatement: "a 'do...while' statement",
-    ForStatement: "a 'for' statement",
-    IfStatement: "an 'if' statement",
-    WhileStatement: "a 'while' statement"
+	DoWhileStatement: "a 'do...while' statement",
+	ForStatement: "a 'for' statement",
+	IfStatement: "an 'if' statement",
+	WhileStatement: "a 'while' statement",
 };
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow assignment operators in conditional expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-cond-assign"
-        },
-
-        schema: [
-            {
-                enum: ["except-parens", "always"]
-            }
-        ],
-
-        messages: {
-            unexpected: "Unexpected assignment within {{type}}.",
-
-            // must match JSHint's error message
-            missing: "Expected a conditional expression and instead saw an assignment."
-        }
-    },
-
-    create(context) {
-
-        const prohibitAssign = (context.options[0] || "except-parens");
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Check whether an AST node is the test expression for a conditional statement.
-         * @param {!Object} node The node to test.
-         * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
-         */
-        function isConditionalTestExpression(node) {
-            return node.parent &&
-                TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
-                node === node.parent.test;
-        }
-
-        /**
-         * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
-         * @param {!Object} node The node to use at the start of the search.
-         * @returns {?Object} The closest ancestor node that represents a conditional statement.
-         */
-        function findConditionalAncestor(node) {
-            let currentAncestor = node;
-
-            do {
-                if (isConditionalTestExpression(currentAncestor)) {
-                    return currentAncestor.parent;
-                }
-            } while ((currentAncestor = currentAncestor.parent) && !astUtils.isFunction(currentAncestor));
-
-            return null;
-        }
-
-        /**
-         * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
-         * @param {!Object} node The node to test.
-         * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
-         */
-        function isParenthesisedTwice(node) {
-            const previousToken = sourceCode.getTokenBefore(node, 1),
-                nextToken = sourceCode.getTokenAfter(node, 1);
-
-            return astUtils.isParenthesised(sourceCode, node) &&
-                previousToken && astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&
-                astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
-        }
-
-        /**
-         * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
-         * @param {!Object} node The node for the conditional statement.
-         * @returns {void}
-         */
-        function testForAssign(node) {
-            if (node.test &&
-                (node.test.type === "AssignmentExpression") &&
-                (node.type === "ForStatement"
-                    ? !astUtils.isParenthesised(sourceCode, node.test)
-                    : !isParenthesisedTwice(node.test)
-                )
-            ) {
-
-                context.report({
-                    node: node.test,
-                    messageId: "missing"
-                });
-            }
-        }
-
-        /**
-         * Check whether an assignment expression is descended from a conditional statement's test expression.
-         * @param {!Object} node The node for the assignment expression.
-         * @returns {void}
-         */
-        function testForConditionalAncestor(node) {
-            const ancestor = findConditionalAncestor(node);
-
-            if (ancestor) {
-                context.report({
-                    node,
-                    messageId: "unexpected",
-                    data: {
-                        type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type
-                    }
-                });
-            }
-        }
-
-        if (prohibitAssign === "always") {
-            return {
-                AssignmentExpression: testForConditionalAncestor
-            };
-        }
-
-        return {
-            DoWhileStatement: testForAssign,
-            ForStatement: testForAssign,
-            IfStatement: testForAssign,
-            WhileStatement: testForAssign,
-            ConditionalExpression: testForAssign
-        };
-
-    }
+	meta: {
+		type: "problem",
+
+		defaultOptions: ["except-parens"],
+
+		docs: {
+			description:
+				"Disallow assignment operators in conditional expressions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-cond-assign",
+		},
+
+		schema: [
+			{
+				enum: ["except-parens", "always"],
+			},
+		],
+
+		messages: {
+			unexpected: "Unexpected assignment within {{type}}.",
+
+			// must match JSHint's error message
+			missing:
+				"Expected a conditional expression and instead saw an assignment.",
+		},
+	},
+
+	create(context) {
+		const [prohibitAssign] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Check whether an AST node is the test expression for a conditional statement.
+		 * @param {!Object} node The node to test.
+		 * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
+		 */
+		function isConditionalTestExpression(node) {
+			return (
+				node.parent &&
+				TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
+				node === node.parent.test
+			);
+		}
+
+		/**
+		 * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
+		 * @param {!Object} node The node to use at the start of the search.
+		 * @returns {?Object} The closest ancestor node that represents a conditional statement.
+		 */
+		function findConditionalAncestor(node) {
+			let currentAncestor = node;
+
+			do {
+				if (isConditionalTestExpression(currentAncestor)) {
+					return currentAncestor.parent;
+				}
+			} while (
+				(currentAncestor = currentAncestor.parent) &&
+				!astUtils.isFunction(currentAncestor)
+			);
+
+			return null;
+		}
+
+		/**
+		 * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
+		 * @param {!Object} node The node to test.
+		 * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
+		 */
+		function isParenthesisedTwice(node) {
+			const previousToken = sourceCode.getTokenBefore(node, 1),
+				nextToken = sourceCode.getTokenAfter(node, 1);
+
+			return (
+				astUtils.isParenthesised(sourceCode, node) &&
+				previousToken &&
+				astUtils.isOpeningParenToken(previousToken) &&
+				previousToken.range[1] <= node.range[0] &&
+				astUtils.isClosingParenToken(nextToken) &&
+				nextToken.range[0] >= node.range[1]
+			);
+		}
+
+		/**
+		 * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
+		 * @param {!Object} node The node for the conditional statement.
+		 * @returns {void}
+		 */
+		function testForAssign(node) {
+			if (
+				node.test &&
+				node.test.type === "AssignmentExpression" &&
+				(node.type === "ForStatement"
+					? !astUtils.isParenthesised(sourceCode, node.test)
+					: !isParenthesisedTwice(node.test))
+			) {
+				context.report({
+					node: node.test,
+					messageId: "missing",
+				});
+			}
+		}
+
+		/**
+		 * Check whether an assignment expression is descended from a conditional statement's test expression.
+		 * @param {!Object} node The node for the assignment expression.
+		 * @returns {void}
+		 */
+		function testForConditionalAncestor(node) {
+			const ancestor = findConditionalAncestor(node);
+
+			if (ancestor) {
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: {
+						type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type,
+					},
+				});
+			}
+		}
+
+		if (prohibitAssign === "always") {
+			return {
+				AssignmentExpression: testForConditionalAncestor,
+			};
+		}
+
+		return {
+			DoWhileStatement: testForAssign,
+			ForStatement: testForAssign,
+			IfStatement: testForAssign,
+			WhileStatement: testForAssign,
+			ConditionalExpression: testForAssign,
+		};
+	},
 };