eslint 9.21.0 → 9.23.0

package/lib/rules/no-unused-expressions.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} `true`.
  */
 function alwaysTrue() {
-    return true;
+	return true;
 }
 
 /**
@@ -23,168 +23,184 @@ function alwaysTrue() {
  * @returns {boolean} `false`.
  */
 function alwaysFalse() {
-    return false;
+	return false;
 }
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unused expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-unused-expressions"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowShortCircuit: {
-                        type: "boolean"
-                    },
-                    allowTernary: {
-                        type: "boolean"
-                    },
-                    allowTaggedTemplates: {
-                        type: "boolean"
-                    },
-                    enforceForJSX: {
-                        type: "boolean"
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        defaultOptions: [{
-            allowShortCircuit: false,
-            allowTernary: false,
-            allowTaggedTemplates: false,
-            enforceForJSX: false
-        }],
-
-        messages: {
-            unusedExpression: "Expected an assignment or function call and instead saw an expression."
-        }
-    },
-
-    create(context) {
-        const [{
-            allowShortCircuit,
-            allowTernary,
-            allowTaggedTemplates,
-            enforceForJSX
-        }] = context.options;
-
-        /**
-         * Has AST suggesting a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node structurally represents a directive
-         */
-        function looksLikeDirective(node) {
-            return node.type === "ExpressionStatement" &&
-                node.expression.type === "Literal" && typeof node.expression.value === "string";
-        }
-
-        /**
-         * Gets the leading sequence of members in a list that pass the predicate.
-         * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
-         * @param {a[]} list the input list
-         * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
-         */
-        function takeWhile(predicate, list) {
-            for (let i = 0; i < list.length; ++i) {
-                if (!predicate(list[i])) {
-                    return list.slice(0, i);
-                }
-            }
-            return list.slice();
-        }
-
-        /**
-         * Gets leading directives nodes in a Node body.
-         * @param {ASTNode} node a Program or BlockStatement node
-         * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
-         */
-        function directives(node) {
-            return takeWhile(looksLikeDirective, node.body);
-        }
-
-        /**
-         * Detect if a Node is a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node is considered a directive in its current position
-         */
-        function isDirective(node) {
-
-            /**
-             * https://tc39.es/ecma262/#directive-prologue
-             *
-             * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
-             * Class static blocks do not have directive prologue.
-             */
-            return astUtils.isTopLevelExpressionStatement(node) && directives(node.parent).includes(node);
-        }
-
-        /**
-         * The member functions return `true` if the type has no side-effects.
-         * Unknown nodes are handled as `false`, then this rule ignores those.
-         */
-        const Checker = Object.assign(Object.create(null), {
-            isDisallowed(node) {
-                return (Checker[node.type] || alwaysFalse)(node);
-            },
-
-            ArrayExpression: alwaysTrue,
-            ArrowFunctionExpression: alwaysTrue,
-            BinaryExpression: alwaysTrue,
-            ChainExpression(node) {
-                return Checker.isDisallowed(node.expression);
-            },
-            ClassExpression: alwaysTrue,
-            ConditionalExpression(node) {
-                if (allowTernary) {
-                    return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
-                }
-                return true;
-            },
-            FunctionExpression: alwaysTrue,
-            Identifier: alwaysTrue,
-            JSXElement() {
-                return enforceForJSX;
-            },
-            JSXFragment() {
-                return enforceForJSX;
-            },
-            Literal: alwaysTrue,
-            LogicalExpression(node) {
-                if (allowShortCircuit) {
-                    return Checker.isDisallowed(node.right);
-                }
-                return true;
-            },
-            MemberExpression: alwaysTrue,
-            MetaProperty: alwaysTrue,
-            ObjectExpression: alwaysTrue,
-            SequenceExpression: alwaysTrue,
-            TaggedTemplateExpression() {
-                return !allowTaggedTemplates;
-            },
-            TemplateLiteral: alwaysTrue,
-            ThisExpression: alwaysTrue,
-            UnaryExpression(node) {
-                return node.operator !== "void" && node.operator !== "delete";
-            }
-        });
-
-        return {
-            ExpressionStatement(node) {
-                if (Checker.isDisallowed(node.expression) && !isDirective(node)) {
-                    context.report({ node, messageId: "unusedExpression" });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow unused expressions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-unused-expressions",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowShortCircuit: {
+						type: "boolean",
+					},
+					allowTernary: {
+						type: "boolean",
+					},
+					allowTaggedTemplates: {
+						type: "boolean",
+					},
+					enforceForJSX: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [
+			{
+				allowShortCircuit: false,
+				allowTernary: false,
+				allowTaggedTemplates: false,
+				enforceForJSX: false,
+			},
+		],
+
+		messages: {
+			unusedExpression:
+				"Expected an assignment or function call and instead saw an expression.",
+		},
+	},
+
+	create(context) {
+		const [
+			{
+				allowShortCircuit,
+				allowTernary,
+				allowTaggedTemplates,
+				enforceForJSX,
+			},
+		] = context.options;
+
+		/**
+		 * Has AST suggesting a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node structurally represents a directive
+		 */
+		function looksLikeDirective(node) {
+			return (
+				node.type === "ExpressionStatement" &&
+				node.expression.type === "Literal" &&
+				typeof node.expression.value === "string"
+			);
+		}
+
+		/**
+		 * Gets the leading sequence of members in a list that pass the predicate.
+		 * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
+		 * @param {a[]} list the input list
+		 * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
+		 */
+		function takeWhile(predicate, list) {
+			for (let i = 0; i < list.length; ++i) {
+				if (!predicate(list[i])) {
+					return list.slice(0, i);
+				}
+			}
+			return list.slice();
+		}
+
+		/**
+		 * Gets leading directives nodes in a Node body.
+		 * @param {ASTNode} node a Program or BlockStatement node
+		 * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
+		 */
+		function directives(node) {
+			return takeWhile(looksLikeDirective, node.body);
+		}
+
+		/**
+		 * Detect if a Node is a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node is considered a directive in its current position
+		 */
+		function isDirective(node) {
+			/**
+			 * https://tc39.es/ecma262/#directive-prologue
+			 *
+			 * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
+			 * Class static blocks do not have directive prologue.
+			 */
+			return (
+				astUtils.isTopLevelExpressionStatement(node) &&
+				directives(node.parent).includes(node)
+			);
+		}
+
+		/**
+		 * The member functions return `true` if the type has no side-effects.
+		 * Unknown nodes are handled as `false`, then this rule ignores those.
+		 */
+		const Checker = Object.assign(Object.create(null), {
+			isDisallowed(node) {
+				return (Checker[node.type] || alwaysFalse)(node);
+			},
+
+			ArrayExpression: alwaysTrue,
+			ArrowFunctionExpression: alwaysTrue,
+			BinaryExpression: alwaysTrue,
+			ChainExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			ClassExpression: alwaysTrue,
+			ConditionalExpression(node) {
+				if (allowTernary) {
+					return (
+						Checker.isDisallowed(node.consequent) ||
+						Checker.isDisallowed(node.alternate)
+					);
+				}
+				return true;
+			},
+			FunctionExpression: alwaysTrue,
+			Identifier: alwaysTrue,
+			JSXElement() {
+				return enforceForJSX;
+			},
+			JSXFragment() {
+				return enforceForJSX;
+			},
+			Literal: alwaysTrue,
+			LogicalExpression(node) {
+				if (allowShortCircuit) {
+					return Checker.isDisallowed(node.right);
+				}
+				return true;
+			},
+			MemberExpression: alwaysTrue,
+			MetaProperty: alwaysTrue,
+			ObjectExpression: alwaysTrue,
+			SequenceExpression: alwaysTrue,
+			TaggedTemplateExpression() {
+				return !allowTaggedTemplates;
+			},
+			TemplateLiteral: alwaysTrue,
+			ThisExpression: alwaysTrue,
+			UnaryExpression(node) {
+				return node.operator !== "void" && node.operator !== "delete";
+			},
+		});
+
+		return {
+			ExpressionStatement(node) {
+				if (
+					Checker.isDisallowed(node.expression) &&
+					!isDirective(node)
+				) {
+					context.report({ node, messageId: "unusedExpression" });
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-unused-labels.js

@@ -17,127 +17,142 @@ const astUtils = require("./utils/ast-utils");
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unused labels",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-unused-labels"
-        },
-
-        schema: [],
-
-        fixable: "code",
-
-        messages: {
-            unused: "'{{name}}:' is defined but never used."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        let scopeInfo = null;
-
-        /**
-         * Adds a scope info to the stack.
-         * @param {ASTNode} node A node to add. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function enterLabeledScope(node) {
-            scopeInfo = {
-                label: node.label.name,
-                used: false,
-                upper: scopeInfo
-            };
-        }
-
-        /**
-         * Checks if a `LabeledStatement` node is fixable.
-         * For a node to be fixable, there must be no comments between the label and the body.
-         * Furthermore, is must be possible to remove the label without turning the body statement into a
-         * directive after other fixes are applied.
-         * @param {ASTNode} node The node to evaluate.
-         * @returns {boolean} Whether or not the node is fixable.
-         */
-        function isFixable(node) {
-
-            /*
-             * Only perform a fix if there are no comments between the label and the body. This will be the case
-             * when there is exactly one token/comment (the ":") between the label and the body.
-             */
-            if (sourceCode.getTokenAfter(node.label, { includeComments: true }) !==
-                sourceCode.getTokenBefore(node.body, { includeComments: true })) {
-                return false;
-            }
-
-            // Looking for the node's deepest ancestor which is not a `LabeledStatement`.
-            let ancestor = node.parent;
-
-            while (ancestor.type === "LabeledStatement") {
-                ancestor = ancestor.parent;
-            }
-
-            if (ancestor.type === "Program" ||
-                (ancestor.type === "BlockStatement" && astUtils.isFunction(ancestor.parent))) {
-                const { body } = node;
-
-                if (body.type === "ExpressionStatement" &&
-                    ((body.expression.type === "Literal" && typeof body.expression.value === "string") ||
-                    astUtils.isStaticTemplateLiteral(body.expression))) {
-                    return false; // potential directive
-                }
-            }
-            return true;
-        }
-
-        /**
-         * Removes the top of the stack.
-         * At the same time, this reports the label if it's never used.
-         * @param {ASTNode} node A node to report. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function exitLabeledScope(node) {
-            if (!scopeInfo.used) {
-                context.report({
-                    node: node.label,
-                    messageId: "unused",
-                    data: node.label,
-                    fix: isFixable(node) ? fixer => fixer.removeRange([node.range[0], node.body.range[0]]) : null
-                });
-            }
-
-            scopeInfo = scopeInfo.upper;
-        }
-
-        /**
-         * Marks the label of a given node as used.
-         * @param {ASTNode} node A node to mark. This is a BreakStatement or
-         *      ContinueStatement.
-         * @returns {void}
-         */
-        function markAsUsed(node) {
-            if (!node.label) {
-                return;
-            }
-
-            const label = node.label.name;
-            let info = scopeInfo;
-
-            while (info) {
-                if (info.label === label) {
-                    info.used = true;
-                    break;
-                }
-                info = info.upper;
-            }
-        }
-
-        return {
-            LabeledStatement: enterLabeledScope,
-            "LabeledStatement:exit": exitLabeledScope,
-            BreakStatement: markAsUsed,
-            ContinueStatement: markAsUsed
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow unused labels",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-unused-labels",
+		},
+
+		schema: [],
+
+		fixable: "code",
+
+		messages: {
+			unused: "'{{name}}:' is defined but never used.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let scopeInfo = null;
+
+		/**
+		 * Adds a scope info to the stack.
+		 * @param {ASTNode} node A node to add. This is a LabeledStatement.
+		 * @returns {void}
+		 */
+		function enterLabeledScope(node) {
+			scopeInfo = {
+				label: node.label.name,
+				used: false,
+				upper: scopeInfo,
+			};
+		}
+
+		/**
+		 * Checks if a `LabeledStatement` node is fixable.
+		 * For a node to be fixable, there must be no comments between the label and the body.
+		 * Furthermore, is must be possible to remove the label without turning the body statement into a
+		 * directive after other fixes are applied.
+		 * @param {ASTNode} node The node to evaluate.
+		 * @returns {boolean} Whether or not the node is fixable.
+		 */
+		function isFixable(node) {
+			/*
+			 * Only perform a fix if there are no comments between the label and the body. This will be the case
+			 * when there is exactly one token/comment (the ":") between the label and the body.
+			 */
+			if (
+				sourceCode.getTokenAfter(node.label, {
+					includeComments: true,
+				}) !==
+				sourceCode.getTokenBefore(node.body, { includeComments: true })
+			) {
+				return false;
+			}
+
+			// Looking for the node's deepest ancestor which is not a `LabeledStatement`.
+			let ancestor = node.parent;
+
+			while (ancestor.type === "LabeledStatement") {
+				ancestor = ancestor.parent;
+			}
+
+			if (
+				ancestor.type === "Program" ||
+				(ancestor.type === "BlockStatement" &&
+					astUtils.isFunction(ancestor.parent))
+			) {
+				const { body } = node;
+
+				if (
+					body.type === "ExpressionStatement" &&
+					((body.expression.type === "Literal" &&
+						typeof body.expression.value === "string") ||
+						astUtils.isStaticTemplateLiteral(body.expression))
+				) {
+					return false; // potential directive
+				}
+			}
+			return true;
+		}
+
+		/**
+		 * Removes the top of the stack.
+		 * At the same time, this reports the label if it's never used.
+		 * @param {ASTNode} node A node to report. This is a LabeledStatement.
+		 * @returns {void}
+		 */
+		function exitLabeledScope(node) {
+			if (!scopeInfo.used) {
+				context.report({
+					node: node.label,
+					messageId: "unused",
+					data: node.label,
+					fix: isFixable(node)
+						? fixer =>
+								fixer.removeRange([
+									node.range[0],
+									node.body.range[0],
+								])
+						: null,
+				});
+			}
+
+			scopeInfo = scopeInfo.upper;
+		}
+
+		/**
+		 * Marks the label of a given node as used.
+		 * @param {ASTNode} node A node to mark. This is a BreakStatement or
+		 *      ContinueStatement.
+		 * @returns {void}
+		 */
+		function markAsUsed(node) {
+			if (!node.label) {
+				return;
+			}
+
+			const label = node.label.name;
+			let info = scopeInfo;
+
+			while (info) {
+				if (info.label === label) {
+					info.used = true;
+					break;
+				}
+				info = info.upper;
+			}
+		}
+
+		return {
+			LabeledStatement: enterLabeledScope,
+			"LabeledStatement:exit": exitLabeledScope,
+			BreakStatement: markAsUsed,
+			ContinueStatement: markAsUsed,
+		};
+	},
 };