@alexlit/lint-kit 126.6.0 → 126.7.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unused-vars.js

@@ -0,0 +1,881 @@
+/**
+ * @fileoverview Rule to flag declared but unused variables
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * A simple name for the types of variables that this rule supports
+ * @typedef {'array-destructure'|'catch-clause'|'parameter'|'variable'} VariableType
+ */
+
+/**
+ * Bag of data used for formatting the `unusedVar` lint message.
+ * @typedef {Object} UnusedVarMessageData
+ * @property {string} varName The name of the unused var.
+ * @property {'defined'|'assigned a value'} action Description of the vars state.
+ * @property {string} additional Any additional info to be appended at the end.
+ */
+
+/**
+ * Bag of data used for formatting the `usedIgnoredVar` lint message.
+ * @typedef {Object} UsedIgnoredVarMessageData
+ * @property {string} varName The name of the unused var.
+ * @property {string} additional Any additional info to be appended at the end.
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow unused variables",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-unused-vars"
+        },
+
+        schema: [
+            {
+                oneOf: [
+                    {
+                        enum: ["all", "local"]
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            vars: {
+                                enum: ["all", "local"]
+                            },
+                            varsIgnorePattern: {
+                                type: "string"
+                            },
+                            args: {
+                                enum: ["all", "after-used", "none"]
+                            },
+                            ignoreRestSiblings: {
+                                type: "boolean"
+                            },
+                            argsIgnorePattern: {
+                                type: "string"
+                            },
+                            caughtErrors: {
+                                enum: ["all", "none"]
+                            },
+                            caughtErrorsIgnorePattern: {
+                                type: "string"
+                            },
+                            destructuredArrayIgnorePattern: {
+                                type: "string"
+                            },
+                            ignoreClassWithStaticInitBlock: {
+                                type: "boolean"
+                            },
+                            reportUsedIgnorePattern: {
+                                type: "boolean"
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                ]
+            }
+        ],
+
+        messages: {
+            unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
+            usedIgnoredVar: "'{{varName}}' is marked as ignored but is used{{additional}}."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        const REST_PROPERTY_TYPE = /^(?:RestElement|(?:Experimental)?RestProperty)$/u;
+
+        const config = {
+            vars: "all",
+            args: "after-used",
+            ignoreRestSiblings: false,
+            caughtErrors: "all",
+            ignoreClassWithStaticInitBlock: false,
+            reportUsedIgnorePattern: false
+        };
+
+        const firstOption = context.options[0];
+
+        if (firstOption) {
+            if (typeof firstOption === "string") {
+                config.vars = firstOption;
+            } else {
+                config.vars = firstOption.vars || config.vars;
+                config.args = firstOption.args || config.args;
+                config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
+                config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
+                config.ignoreClassWithStaticInitBlock = firstOption.ignoreClassWithStaticInitBlock || config.ignoreClassWithStaticInitBlock;
+                config.reportUsedIgnorePattern = firstOption.reportUsedIgnorePattern || config.reportUsedIgnorePattern;
+
+                if (firstOption.varsIgnorePattern) {
+                    config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, "u");
+                }
+
+                if (firstOption.argsIgnorePattern) {
+                    config.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern, "u");
+                }
+
+                if (firstOption.caughtErrorsIgnorePattern) {
+                    config.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern, "u");
+                }
+
+                if (firstOption.destructuredArrayIgnorePattern) {
+                    config.destructuredArrayIgnorePattern = new RegExp(firstOption.destructuredArrayIgnorePattern, "u");
+                }
+            }
+        }
+
+        /**
+         * Determines what variable type a def is.
+         * @param  {Object} def the declaration to check
+         * @returns {VariableType} a simple name for the types of variables that this rule supports
+         */
+        function defToVariableType(def) {
+
+            /*
+             * This `destructuredArrayIgnorePattern` error report works differently from the catch
+             * clause and parameter error reports. _Both_ the `varsIgnorePattern` and the
+             * `destructuredArrayIgnorePattern` will be checked for array destructuring. However,
+             * for the purposes of the report, the currently defined behavior is to only inform the
+             * user of the `destructuredArrayIgnorePattern` if it's present (regardless of the fact
+             * that the `varsIgnorePattern` would also apply). If it's not present, the user will be
+             * informed of the `varsIgnorePattern`, assuming that's present.
+             */
+            if (config.destructuredArrayIgnorePattern && def.name.parent.type === "ArrayPattern") {
+                return "array-destructure";
+            }
+
+            switch (def.type) {
+                case "CatchClause":
+                    return "catch-clause";
+                case "Parameter":
+                    return "parameter";
+                default:
+                    return "variable";
+            }
+        }
+
+        /**
+         * Gets a given variable's description and configured ignore pattern
+         * based on the provided variableType
+         * @param {VariableType} variableType a simple name for the types of variables that this rule supports
+         * @throws {Error} (Unreachable)
+         * @returns {[string | undefined, string | undefined]} the given variable's description and
+         * ignore pattern
+         */
+        function getVariableDescription(variableType) {
+            let pattern;
+            let variableDescription;
+
+            switch (variableType) {
+                case "array-destructure":
+                    pattern = config.destructuredArrayIgnorePattern;
+                    variableDescription = "elements of array destructuring";
+                    break;
+
+                case "catch-clause":
+                    pattern = config.caughtErrorsIgnorePattern;
+                    variableDescription = "caught errors";
+                    break;
+
+                case "parameter":
+                    pattern = config.argsIgnorePattern;
+                    variableDescription = "args";
+                    break;
+
+                case "variable":
+                    pattern = config.varsIgnorePattern;
+                    variableDescription = "vars";
+                    break;
+
+                default:
+                    throw new Error(`Unexpected variable type: ${variableType}`);
+            }
+
+            if (pattern) {
+                pattern = pattern.toString();
+            }
+
+            return [variableDescription, pattern];
+        }
+
+        /**
+         * Generates the message data about the variable being defined and unused,
+         * including the ignore pattern if configured.
+         * @param {Variable} unusedVar eslint-scope variable object.
+         * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
+         */
+        function getDefinedMessageData(unusedVar) {
+            const def = unusedVar.defs && unusedVar.defs[0];
+            let additionalMessageData = "";
+
+            if (def) {
+                const [variableDescription, pattern] = getVariableDescription(defToVariableType(def));
+
+                if (pattern && variableDescription) {
+                    additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
+                }
+            }
+
+            return {
+                varName: unusedVar.name,
+                action: "defined",
+                additional: additionalMessageData
+            };
+        }
+
+        /**
+         * Generate the warning message about the variable being
+         * assigned and unused, including the ignore pattern if configured.
+         * @param {Variable} unusedVar eslint-scope variable object.
+         * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
+         */
+        function getAssignedMessageData(unusedVar) {
+            const def = unusedVar.defs && unusedVar.defs[0];
+            let additionalMessageData = "";
+
+            if (def) {
+                const [variableDescription, pattern] = getVariableDescription(defToVariableType(def));
+
+                if (pattern && variableDescription) {
+                    additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
+                }
+            }
+
+            return {
+                varName: unusedVar.name,
+                action: "assigned a value",
+                additional: additionalMessageData
+            };
+        }
+
+        /**
+         * Generate the warning message about a variable being used even though
+         * it is marked as being ignored.
+         * @param {Variable} variable eslint-scope variable object
+         * @param {VariableType} variableType a simple name for the types of variables that this rule supports
+         * @returns {UsedIgnoredVarMessageData} The message data to be used with
+         * this used ignored variable.
+         */
+        function getUsedIgnoredMessageData(variable, variableType) {
+            const [variableDescription, pattern] = getVariableDescription(variableType);
+
+            let additionalMessageData = "";
+
+            if (pattern && variableDescription) {
+                additionalMessageData = `. Used ${variableDescription} must not match ${pattern}`;
+            }
+
+            return {
+                varName: variable.name,
+                additional: additionalMessageData
+            };
+        }
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        const STATEMENT_TYPE = /(?:Statement|Declaration)$/u;
+
+        /**
+         * Determines if a given variable is being exported from a module.
+         * @param {Variable} variable eslint-scope variable object.
+         * @returns {boolean} True if the variable is exported, false if not.
+         * @private
+         */
+        function isExported(variable) {
+
+            const definition = variable.defs[0];
+
+            if (definition) {
+
+                let node = definition.node;
+
+                if (node.type === "VariableDeclarator") {
+                    node = node.parent;
+                } else if (definition.type === "Parameter") {
+                    return false;
+                }
+
+                return node.parent.type.indexOf("Export") === 0;
+            }
+            return false;
+
+        }
+
+        /**
+         * Checks whether a node is a sibling of the rest property or not.
+         * @param {ASTNode} node a node to check
+         * @returns {boolean} True if the node is a sibling of the rest property, otherwise false.
+         */
+        function hasRestSibling(node) {
+            return node.type === "Property" &&
+                node.parent.type === "ObjectPattern" &&
+                REST_PROPERTY_TYPE.test(node.parent.properties.at(-1).type);
+        }
+
+        /**
+         * Determines if a variable has a sibling rest property
+         * @param {Variable} variable eslint-scope variable object.
+         * @returns {boolean} True if the variable has a sibling rest property, false if not.
+         * @private
+         */
+        function hasRestSpreadSibling(variable) {
+            if (config.ignoreRestSiblings) {
+                const hasRestSiblingDefinition = variable.defs.some(def => hasRestSibling(def.name.parent));
+                const hasRestSiblingReference = variable.references.some(ref => hasRestSibling(ref.identifier.parent));
+
+                return hasRestSiblingDefinition || hasRestSiblingReference;
+            }
+
+            return false;
+        }
+
+        /**
+         * Determines if a reference is a read operation.
+         * @param {Reference} ref An eslint-scope Reference
+         * @returns {boolean} whether the given reference represents a read operation
+         * @private
+         */
+        function isReadRef(ref) {
+            return ref.isRead();
+        }
+
+        /**
+         * Determine if an identifier is referencing an enclosing function name.
+         * @param {Reference} ref The reference to check.
+         * @param {ASTNode[]} nodes The candidate function nodes.
+         * @returns {boolean} True if it's a self-reference, false if not.
+         * @private
+         */
+        function isSelfReference(ref, nodes) {
+            let scope = ref.from;
+
+            while (scope) {
+                if (nodes.includes(scope.block)) {
+                    return true;
+                }
+
+                scope = scope.upper;
+            }
+
+            return false;
+        }
+
+        /**
+         * Gets a list of function definitions for a specified variable.
+         * @param {Variable} variable eslint-scope variable object.
+         * @returns {ASTNode[]} Function nodes.
+         * @private
+         */
+        function getFunctionDefinitions(variable) {
+            const functionDefinitions = [];
+
+            variable.defs.forEach(def => {
+                const { type, node } = def;
+
+                // FunctionDeclarations
+                if (type === "FunctionName") {
+                    functionDefinitions.push(node);
+                }
+
+                // FunctionExpressions
+                if (type === "Variable" && node.init &&
+                    (node.init.type === "FunctionExpression" || node.init.type === "ArrowFunctionExpression")) {
+                    functionDefinitions.push(node.init);
+                }
+            });
+            return functionDefinitions;
+        }
+
+        /**
+         * Checks the position of given nodes.
+         * @param {ASTNode} inner A node which is expected as inside.
+         * @param {ASTNode} outer A node which is expected as outside.
+         * @returns {boolean} `true` if the `inner` node exists in the `outer` node.
+         * @private
+         */
+        function isInside(inner, outer) {
+            return (
+                inner.range[0] >= outer.range[0] &&
+                inner.range[1] <= outer.range[1]
+            );
+        }
+
+        /**
+         * Checks whether a given node is unused expression or not.
+         * @param {ASTNode} node The node itself
+         * @returns {boolean} The node is an unused expression.
+         * @private
+         */
+        function isUnusedExpression(node) {
+            const parent = node.parent;
+
+            if (parent.type === "ExpressionStatement") {
+                return true;
+            }
+
+            if (parent.type === "SequenceExpression") {
+                const isLastExpression = parent.expressions.at(-1) === node;
+
+                if (!isLastExpression) {
+                    return true;
+                }
+                return isUnusedExpression(parent);
+            }
+
+            return false;
+        }
+
+        /**
+         * If a given reference is left-hand side of an assignment, this gets
+         * the right-hand side node of the assignment.
+         *
+         * In the following cases, this returns null.
+         *
+         * - The reference is not the LHS of an assignment expression.
+         * - The reference is inside of a loop.
+         * - The reference is inside of a function scope which is different from
+         *   the declaration.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} prevRhsNode The previous RHS node.
+         * @returns {ASTNode|null} The RHS node or null.
+         * @private
+         */
+        function getRhsNode(ref, prevRhsNode) {
+            const id = ref.identifier;
+            const parent = id.parent;
+            const refScope = ref.from.variableScope;
+            const varScope = ref.resolved.scope.variableScope;
+            const canBeUsedLater = refScope !== varScope || astUtils.isInLoop(id);
+
+            /*
+             * Inherits the previous node if this reference is in the node.
+             * This is for `a = a + a`-like code.
+             */
+            if (prevRhsNode && isInside(id, prevRhsNode)) {
+                return prevRhsNode;
+            }
+
+            if (parent.type === "AssignmentExpression" &&
+                isUnusedExpression(parent) &&
+                id === parent.left &&
+                !canBeUsedLater
+            ) {
+                return parent.right;
+            }
+            return null;
+        }
+
+        /**
+         * Checks whether a given function node is stored to somewhere or not.
+         * If the function node is stored, the function can be used later.
+         * @param {ASTNode} funcNode A function node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
+         * @returns {boolean} `true` if under the following conditions:
+         *      - the funcNode is assigned to a variable.
+         *      - the funcNode is bound as an argument of a function call.
+         *      - the function is bound to a property and the object satisfies above conditions.
+         * @private
+         */
+        function isStorableFunction(funcNode, rhsNode) {
+            let node = funcNode;
+            let parent = funcNode.parent;
+
+            while (parent && isInside(parent, rhsNode)) {
+                switch (parent.type) {
+                    case "SequenceExpression":
+                        if (parent.expressions.at(-1) !== node) {
+                            return false;
+                        }
+                        break;
+
+                    case "CallExpression":
+                    case "NewExpression":
+                        return parent.callee !== node;
+
+                    case "AssignmentExpression":
+                    case "TaggedTemplateExpression":
+                    case "YieldExpression":
+                        return true;
+
+                    default:
+                        if (STATEMENT_TYPE.test(parent.type)) {
+
+                            /*
+                             * If it encountered statements, this is a complex pattern.
+                             * Since analyzing complex patterns is hard, this returns `true` to avoid false positive.
+                             */
+                            return true;
+                        }
+                }
+
+                node = parent;
+                parent = parent.parent;
+            }
+
+            return false;
+        }
+
+        /**
+         * Checks whether a given Identifier node exists inside of a function node which can be used later.
+         *
+         * "can be used later" means:
+         * - the function is assigned to a variable.
+         * - the function is bound to a property and the object can be used later.
+         * - the function is bound as an argument of a function call.
+         *
+         * If a reference exists in a function which can be used later, the reference is read when the function is called.
+         * @param {ASTNode} id An Identifier node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
+         * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later.
+         * @private
+         */
+        function isInsideOfStorableFunction(id, rhsNode) {
+            const funcNode = astUtils.getUpperFunction(id);
+
+            return (
+                funcNode &&
+                isInside(funcNode, rhsNode) &&
+                isStorableFunction(funcNode, rhsNode)
+            );
+        }
+
+        /**
+         * Checks whether a given reference is a read to update itself or not.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
+         * @returns {boolean} The reference is a read to update itself.
+         * @private
+         */
+        function isReadForItself(ref, rhsNode) {
+            const id = ref.identifier;
+            const parent = id.parent;
+
+            return ref.isRead() && (
+
+                // self update. e.g. `a += 1`, `a++`
+                (
+                    (
+                        parent.type === "AssignmentExpression" &&
+                        parent.left === id &&
+                        isUnusedExpression(parent) &&
+                        !astUtils.isLogicalAssignmentOperator(parent.operator)
+                    ) ||
+                    (
+                        parent.type === "UpdateExpression" &&
+                        isUnusedExpression(parent)
+                    )
+                ) ||
+
+                // in RHS of an assignment for itself. e.g. `a = a + 1`
+                (
+                    rhsNode &&
+                    isInside(id, rhsNode) &&
+                    !isInsideOfStorableFunction(id, rhsNode)
+                )
+            );
+        }
+
+        /**
+         * Determine if an identifier is used either in for-in or for-of loops.
+         * @param {Reference} ref The reference to check.
+         * @returns {boolean} whether reference is used in the for-in loops
+         * @private
+         */
+        function isForInOfRef(ref) {
+            let target = ref.identifier.parent;
+
+
+            // "for (var ...) { return; }"
+            if (target.type === "VariableDeclarator") {
+                target = target.parent.parent;
+            }
+
+            if (target.type !== "ForInStatement" && target.type !== "ForOfStatement") {
+                return false;
+            }
+
+            // "for (...) { return; }"
+            if (target.body.type === "BlockStatement") {
+                target = target.body.body[0];
+
+            // "for (...) return;"
+            } else {
+                target = target.body;
+            }
+
+            // For empty loop body
+            if (!target) {
+                return false;
+            }
+
+            return target.type === "ReturnStatement";
+        }
+
+        /**
+         * Determines if the variable is used.
+         * @param {Variable} variable The variable to check.
+         * @returns {boolean} True if the variable is used
+         * @private
+         */
+        function isUsedVariable(variable) {
+            if (variable.eslintUsed) {
+                return true;
+            }
+
+            const functionNodes = getFunctionDefinitions(variable);
+            const isFunctionDefinition = functionNodes.length > 0;
+
+            let rhsNode = null;
+
+            return variable.references.some(ref => {
+                if (isForInOfRef(ref)) {
+                    return true;
+                }
+
+                const forItself = isReadForItself(ref, rhsNode);
+
+                rhsNode = getRhsNode(ref, rhsNode);
+
+                return (
+                    isReadRef(ref) &&
+                    !forItself &&
+                    !(isFunctionDefinition && isSelfReference(ref, functionNodes))
+                );
+            });
+        }
+
+        /**
+         * Checks whether the given variable is after the last used parameter.
+         * @param {eslint-scope.Variable} variable The variable to check.
+         * @returns {boolean} `true` if the variable is defined after the last
+         * used parameter.
+         */
+        function isAfterLastUsedArg(variable) {
+            const def = variable.defs[0];
+            const params = sourceCode.getDeclaredVariables(def.node);
+            const posteriorParams = params.slice(params.indexOf(variable) + 1);
+
+            // If any used parameters occur after this parameter, do not report.
+            return !posteriorParams.some(v => v.references.length > 0 || v.eslintUsed);
+        }
+
+        /**
+         * Gets an array of variables without read references.
+         * @param {Scope} scope an eslint-scope Scope object.
+         * @param {Variable[]} unusedVars an array that saving result.
+         * @returns {Variable[]} unused variables of the scope and descendant scopes.
+         * @private
+         */
+        function collectUnusedVariables(scope, unusedVars) {
+            const variables = scope.variables;
+            const childScopes = scope.childScopes;
+            let i, l;
+
+            if (scope.type !== "global" || config.vars === "all") {
+                for (i = 0, l = variables.length; i < l; ++i) {
+                    const variable = variables[i];
+
+                    // skip a variable of class itself name in the class scope
+                    if (scope.type === "class" && scope.block.id === variable.identifiers[0]) {
+                        continue;
+                    }
+
+                    // skip function expression names
+                    if (scope.functionExpressionScope) {
+                        continue;
+                    }
+
+                    // skip variables marked with markVariableAsUsed()
+                    if (!config.reportUsedIgnorePattern && variable.eslintUsed) {
+                        continue;
+                    }
+
+                    // skip implicit "arguments" variable
+                    if (scope.type === "function" && variable.name === "arguments" && variable.identifiers.length === 0) {
+                        continue;
+                    }
+
+                    // explicit global variables don't have definitions.
+                    const def = variable.defs[0];
+
+                    if (def) {
+                        const type = def.type;
+                        const refUsedInArrayPatterns = variable.references.some(ref => ref.identifier.parent.type === "ArrayPattern");
+
+                        // skip elements of array destructuring patterns
+                        if (
+                            (
+                                def.name.parent.type === "ArrayPattern" ||
+                                refUsedInArrayPatterns
+                            ) &&
+                            config.destructuredArrayIgnorePattern &&
+                            config.destructuredArrayIgnorePattern.test(def.name.name)
+                        ) {
+                            if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                context.report({
+                                    node: def.name,
+                                    messageId: "usedIgnoredVar",
+                                    data: getUsedIgnoredMessageData(variable, "array-destructure")
+                                });
+                            }
+
+                            continue;
+                        }
+
+                        if (type === "ClassName") {
+                            const hasStaticBlock = def.node.body.body.some(node => node.type === "StaticBlock");
+
+                            if (config.ignoreClassWithStaticInitBlock && hasStaticBlock) {
+                                continue;
+                            }
+                        }
+
+                        // skip catch variables
+                        if (type === "CatchClause") {
+                            if (config.caughtErrors === "none") {
+                                continue;
+                            }
+
+                            // skip ignored parameters
+                            if (config.caughtErrorsIgnorePattern && config.caughtErrorsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "catch-clause")
+                                    });
+                                }
+
+                                continue;
+                            }
+                        } else if (type === "Parameter") {
+
+                            // skip any setter argument
+                            if ((def.node.parent.type === "Property" || def.node.parent.type === "MethodDefinition") && def.node.parent.kind === "set") {
+                                continue;
+                            }
+
+                            // if "args" option is "none", skip any parameter
+                            if (config.args === "none") {
+                                continue;
+                            }
+
+                            // skip ignored parameters
+                            if (config.argsIgnorePattern && config.argsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "parameter")
+                                    });
+                                }
+
+                                continue;
+                            }
+
+                            // if "args" option is "after-used", skip used variables
+                            if (config.args === "after-used" && astUtils.isFunction(def.name.parent) && !isAfterLastUsedArg(variable)) {
+                                continue;
+                            }
+                        } else {
+
+                            // skip ignored variables
+                            if (config.varsIgnorePattern && config.varsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "variable")
+                                    });
+                                }
+
+                                continue;
+                            }
+                        }
+                    }
+
+                    if (!isUsedVariable(variable) && !isExported(variable) && !hasRestSpreadSibling(variable)) {
+                        unusedVars.push(variable);
+                    }
+                }
+            }
+
+            for (i = 0, l = childScopes.length; i < l; ++i) {
+                collectUnusedVariables(childScopes[i], unusedVars);
+            }
+
+            return unusedVars;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            "Program:exit"(programNode) {
+                const unusedVars = collectUnusedVariables(sourceCode.getScope(programNode), []);
+
+                for (let i = 0, l = unusedVars.length; i < l; ++i) {
+                    const unusedVar = unusedVars[i];
+
+                    // Report the first declaration.
+                    if (unusedVar.defs.length > 0) {
+
+                        // report last write reference, https://github.com/eslint/eslint/issues/14324
+                        const writeReferences = unusedVar.references.filter(ref => ref.isWrite() && ref.from.variableScope === unusedVar.scope.variableScope);
+
+                        let referenceToReport;
+
+                        if (writeReferences.length > 0) {
+                            referenceToReport = writeReferences.at(-1);
+                        }
+
+                        context.report({
+                            node: referenceToReport ? referenceToReport.identifier : unusedVar.identifiers[0],
+                            messageId: "unusedVar",
+                            data: unusedVar.references.some(ref => ref.isWrite())
+                                ? getAssignedMessageData(unusedVar)
+                                : getDefinedMessageData(unusedVar)
+                        });
+
+                    // If there are no regular declaration, report the first `/*globals*/` comment directive.
+                    } else if (unusedVar.eslintExplicitGlobalComments) {
+                        const directiveComment = unusedVar.eslintExplicitGlobalComments[0];
+
+                        context.report({
+                            node: programNode,
+                            loc: astUtils.getNameLocationInGlobalDirectiveComment(sourceCode, directiveComment, unusedVar.name),
+                            messageId: "unusedVar",
+                            data: getDefinedMessageData(unusedVar)
+                        });
+                    }
+                }
+            }
+        };
+    }
+};