1493 lines
59 KiB
JavaScript
1493 lines
59 KiB
JavaScript
|
/**
|
||
|
|
* @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"
|
||
|
|
},
|
||
|
|
|
||
|
|
hasSuggestions: true,
|
||
|
|
|
||
|
|
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}}.",
|
||
|
|
removeVar: "Remove unused variable '{{varName}}'."
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fixes unused variables
|
||
|
|
* @param {Object} fixer fixer object
|
||
|
|
* @param {Object} unusedVar unused variable to fix
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function handleFixes(fixer, unusedVar) {
|
||
|
|
const id = unusedVar.identifiers[0];
|
||
|
|
const parent = id.parent;
|
||
|
|
const parentType = parent.type;
|
||
|
|
const tokenBefore = sourceCode.getTokenBefore(id);
|
||
|
|
const tokenAfter = sourceCode.getTokenAfter(id);
|
||
|
|
const isFunction = astUtils.isFunction;
|
||
|
|
const isLoop = astUtils.isLoop;
|
||
|
|
const allWriteReferences = unusedVar.references.filter(ref => ref.isWrite());
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get range from token before of a given node
|
||
|
|
* @param {ASTNode} node node of identifier
|
||
|
|
* @param {number} skips number of token to skip
|
||
|
|
* @returns {number} start range of token before the identifier
|
||
|
|
*/
|
||
|
|
function getPreviousTokenStart(node, skips) {
|
||
|
|
return sourceCode.getTokenBefore(node, skips).range[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get range to token after of a given node
|
||
|
|
* @param {ASTNode} node node of identifier
|
||
|
|
* @param {number} skips number of token to skip
|
||
|
|
* @returns {number} end range of token after the identifier
|
||
|
|
*/
|
||
|
|
function getNextTokenEnd(node, skips) {
|
||
|
|
return sourceCode.getTokenAfter(node, skips).range[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the value of token before of a given node
|
||
|
|
* @param {ASTNode} node node of identifier
|
||
|
|
* @returns {string} value of token before the identifier
|
||
|
|
*/
|
||
|
|
function getTokenBeforeValue(node) {
|
||
|
|
return sourceCode.getTokenBefore(node).value;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the value of token after of a given node
|
||
|
|
* @param {ASTNode} node node of identifier
|
||
|
|
* @returns {string} value of token after the identifier
|
||
|
|
*/
|
||
|
|
function getTokenAfterValue(node) {
|
||
|
|
return sourceCode.getTokenAfter(node).value;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if an array has a single element with null as other element.
|
||
|
|
* @param {ASTNode} node ArrayPattern node
|
||
|
|
* @returns {boolean} true if array has single element with other null elements
|
||
|
|
*/
|
||
|
|
function hasSingleElement(node) {
|
||
|
|
return node.elements.filter(e => e !== null).length === 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* check whether import specifier has an import of particular type
|
||
|
|
* @param {ASTNode} node ImportDeclaration node
|
||
|
|
* @param {string} type type of import to check
|
||
|
|
* @returns {boolean} true if import specifier has import of specified type
|
||
|
|
*/
|
||
|
|
function hasImportOfCertainType(node, type) {
|
||
|
|
return node.specifiers.some(e => e.type === type);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether declaration is safe to remove or not
|
||
|
|
* @param {ASTNode} nextToken next token of unused variable
|
||
|
|
* @param {ASTNode} prevToken previous token of unused variable
|
||
|
|
* @returns {boolean} true if declaration is not safe to remove
|
||
|
|
*/
|
||
|
|
function isDeclarationNotSafeToRemove(nextToken, prevToken) {
|
||
|
|
return (
|
||
|
|
(nextToken.type === "String") ||
|
||
|
|
(
|
||
|
|
prevToken &&
|
||
|
|
!astUtils.isSemicolonToken(prevToken) &&
|
||
|
|
!astUtils.isOpeningBraceToken(prevToken)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* give fixes for unused variables in function parameters
|
||
|
|
* @param {ASTNode} node node to check
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixFunctionParameters(node) {
|
||
|
|
const parentNode = node.parent;
|
||
|
|
|
||
|
|
if (isFunction(parentNode)) {
|
||
|
|
|
||
|
|
// remove unused function parameter if there is only a single parameter
|
||
|
|
if (parentNode.params.length === 1) {
|
||
|
|
return fixer.removeRange(node.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove first unused function parameter when there are multiple parameters
|
||
|
|
if (getTokenBeforeValue(node) === "(" && getTokenAfterValue(node) === ",") {
|
||
|
|
return fixer.removeRange([node.range[0], getNextTokenEnd(node)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused function parameters except first one when there are multiple parameters
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(node), node.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fix unused variable declarations and function parameters
|
||
|
|
* @param {ASTNode} node parent node to identifier
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixVariables(node) {
|
||
|
|
const parentNode = node.parent;
|
||
|
|
|
||
|
|
// remove unused declared variables such as var a = b; or var a = b, c;
|
||
|
|
if (parentNode.type === "VariableDeclarator") {
|
||
|
|
|
||
|
|
// skip variable in for (const [ foo ] of bar);
|
||
|
|
if (isLoop(parentNode.parent.parent)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* remove unused declared variable with single declaration such as 'var a = b;'
|
||
|
|
* remove complete declaration when there is an unused variable in 'const { a } = foo;', same for arrays.
|
||
|
|
*/
|
||
|
|
if (parentNode.parent.declarations.length === 1) {
|
||
|
|
|
||
|
|
// if next token is a string it could become a directive if node is removed -> no suggestion.
|
||
|
|
const nextToken = sourceCode.getTokenAfter(parentNode.parent);
|
||
|
|
|
||
|
|
// if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion.
|
||
|
|
const prevToken = sourceCode.getTokenBefore(parentNode.parent);
|
||
|
|
|
||
|
|
if (nextToken && isDeclarationNotSafeToRemove(nextToken, prevToken)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
return fixer.removeRange(parentNode.parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* remove unused declared variable with multiple declaration except first one such as 'var a = b, c = d;'
|
||
|
|
* fix 'let bar = "hello", { a } = foo;' to 'let bar = "hello";' if 'a' is unused, same for arrays.
|
||
|
|
*/
|
||
|
|
if (getTokenBeforeValue(parentNode) === ",") {
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parentNode), parentNode.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* remove first unused declared variable when there are multiple declarations
|
||
|
|
* fix 'let { a } = foo, bar = "hello";' to 'let bar = "hello";' if 'a' is unused, same for arrays.
|
||
|
|
*/
|
||
|
|
return fixer.removeRange([parentNode.range[0], getNextTokenEnd(parentNode)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fixes [{a: {k}}], [{a: [k]}]
|
||
|
|
if (getTokenBeforeValue(node) === ":") {
|
||
|
|
if (parentNode.parent.type === "ObjectPattern") {
|
||
|
|
// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
|
||
|
|
return fixObjectWithValueSeparator(node);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix unused function parameters
|
||
|
|
return fixFunctionParameters(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fix nested object like { a: { b } }
|
||
|
|
* @param {ASTNode} node parent node to check
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixNestedObjectVariable(node) {
|
||
|
|
const parentNode = node.parent;
|
||
|
|
|
||
|
|
// fix for { a: { b: { c: { d } } } }
|
||
|
|
if (
|
||
|
|
parentNode.parent.parent.parent.type === "ObjectPattern" &&
|
||
|
|
parentNode.parent.properties.length === 1
|
||
|
|
) {
|
||
|
|
return fixNestedObjectVariable(parentNode.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix for { a: { b } }
|
||
|
|
if (parentNode.parent.type === "ObjectPattern") {
|
||
|
|
|
||
|
|
// fix for unused variables in dectructured object with single property in variable decalartion and function parameter
|
||
|
|
if (parentNode.parent.properties.length === 1) {
|
||
|
|
return fixVariables(parentNode.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix for first unused property when there are multiple properties such as '{ a: { b }, c }'
|
||
|
|
if (getTokenBeforeValue(parentNode) === "{") {
|
||
|
|
return fixer.removeRange(
|
||
|
|
[parentNode.range[0], getNextTokenEnd(parentNode)]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix for unused property except first one when there are multiple properties such as '{ k, a: { b } }'
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parentNode), parentNode.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fix unused variables in array and nested array
|
||
|
|
* @param {ASTNode} node parent node to check
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixNestedArrayVariable(node) {
|
||
|
|
const parentNode = node.parent;
|
||
|
|
|
||
|
|
// fix for nested arrays [[ a ]]
|
||
|
|
if (parentNode.parent.type === "ArrayPattern" && hasSingleElement(parentNode)) {
|
||
|
|
return fixNestedArrayVariable(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hasSingleElement(parentNode)) {
|
||
|
|
|
||
|
|
// fixes { a: [{ b }] } or { a: [[ b ]] }
|
||
|
|
if (getTokenBeforeValue(parentNode) === ":") {
|
||
|
|
return fixVariables(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fixes [a, ...[[ b ]]] or [a, ...[{ b }]]
|
||
|
|
if (parentNode.parent.type === "RestElement") {
|
||
|
|
// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
|
||
|
|
return fixRestInPattern(parentNode.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix unused variables in destructured array in variable declaration or function parameter
|
||
|
|
return fixVariables(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove last unused array element
|
||
|
|
if (
|
||
|
|
getTokenBeforeValue(node) === "," &&
|
||
|
|
getTokenAfterValue(node) === "]"
|
||
|
|
) {
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(node), node.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused array element
|
||
|
|
return fixer.removeRange(node.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fix cases like {a: {k}} or {a: [k]}
|
||
|
|
* @param {ASTNode} node parent node to check
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixObjectWithValueSeparator(node) {
|
||
|
|
const parentNode = node.parent.parent;
|
||
|
|
|
||
|
|
// fix cases like [{a : { b }}] or [{a : [ b ]}]
|
||
|
|
if (
|
||
|
|
parentNode.parent.type === "ArrayPattern" &&
|
||
|
|
parentNode.properties.length === 1
|
||
|
|
) {
|
||
|
|
return fixNestedArrayVariable(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix cases like {a: {k}} or {a: [k]}
|
||
|
|
return fixNestedObjectVariable(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* fix ...[[a]] or ...[{a}] like patterns
|
||
|
|
* @param {ASTNode} node parent node to check
|
||
|
|
* @returns {Object} fixer object
|
||
|
|
*/
|
||
|
|
function fixRestInPattern(node) {
|
||
|
|
const parentNode = node.parent;
|
||
|
|
|
||
|
|
// fix ...[[a]] or ...[{a}] in function parameters
|
||
|
|
if (isFunction(parentNode)) {
|
||
|
|
if (parentNode.params.length === 1) {
|
||
|
|
return fixer.removeRange(node.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(node), node.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix rest in nested array pattern like [[a, ...[b]]]
|
||
|
|
if (parentNode.type === "ArrayPattern") {
|
||
|
|
|
||
|
|
// fix [[...[b]]]
|
||
|
|
if (hasSingleElement(parentNode)) {
|
||
|
|
if (parentNode.parent.type === "ArrayPattern") {
|
||
|
|
return fixNestedArrayVariable(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix 'const [...[b]] = foo; and function foo([...[b]]) {}
|
||
|
|
return fixVariables(parentNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix [[a, ...[b]]]
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(node), node.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// skip fix when variable has references that would be left behind
|
||
|
|
if (allWriteReferences.some(ref => ref.identifier.range[0] !== id.range[0])) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove declared variables such as var a; or var a, b;
|
||
|
|
if (parentType === "VariableDeclarator") {
|
||
|
|
if (parent.parent.declarations.length === 1) {
|
||
|
|
|
||
|
|
// prevent fix of variable in forOf and forIn loops.
|
||
|
|
if (isLoop(parent.parent.parent) && parent.parent.parent.body !== parent.parent) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// removes only variable not semicolon in 'if (foo()) var bar;' or in 'loops' or in 'with' statement.
|
||
|
|
if (
|
||
|
|
parent.parent.parent.type === "IfStatement" ||
|
||
|
|
isLoop(parent.parent.parent) ||
|
||
|
|
(parent.parent.parent.type === "WithStatement" && parent.parent.parent.body === parent.parent)
|
||
|
|
) {
|
||
|
|
return fixer.replaceText(parent.parent, ";");
|
||
|
|
}
|
||
|
|
|
||
|
|
// if next token is a string it could become a directive if node is removed -> no suggestion.
|
||
|
|
const nextToken = sourceCode.getTokenAfter(parent.parent);
|
||
|
|
|
||
|
|
// if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion.
|
||
|
|
const prevToken = sourceCode.getTokenBefore(parent.parent);
|
||
|
|
|
||
|
|
if (nextToken && isDeclarationNotSafeToRemove(nextToken, prevToken)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused declared variable with single declaration like 'var a = b;'
|
||
|
|
return fixer.removeRange(parent.parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused declared variable with multiple declaration except first one like 'var a = b, c = d;'
|
||
|
|
if (tokenBefore.value === ",") {
|
||
|
|
return fixer.removeRange([tokenBefore.range[0], parent.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove first unused declared variable when there are multiple declarations
|
||
|
|
return fixer.removeRange([parent.range[0], getNextTokenEnd(parent)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove variables in object patterns
|
||
|
|
if (parent.parent.type === "ObjectPattern") {
|
||
|
|
if (parent.parent.properties.length === 1) {
|
||
|
|
|
||
|
|
// fix [a, ...{b}]
|
||
|
|
if (parent.parent.parent.type === "RestElement") {
|
||
|
|
return fixRestInPattern(parent.parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix [{ a }]
|
||
|
|
if (parent.parent.parent.type === "ArrayPattern") {
|
||
|
|
return fixNestedArrayVariable(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* var {a} = foo;
|
||
|
|
* function a({a}) {}
|
||
|
|
* fix const { a: { b } } = foo;
|
||
|
|
*/
|
||
|
|
return fixVariables(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix const { a:b } = foo;
|
||
|
|
if (tokenBefore.value === ":") {
|
||
|
|
|
||
|
|
// remove first unused variable in const { a:b } = foo;
|
||
|
|
if (getTokenBeforeValue(parent) === "{" && getTokenAfterValue(parent) === ",") {
|
||
|
|
return fixer.removeRange([parent.range[0], getNextTokenEnd(parent)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused variables in const { a: b, c: d } = foo; except first one
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent), id.range[1]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused variables inside an array
|
||
|
|
if (parentType === "ArrayPattern") {
|
||
|
|
if (hasSingleElement(parent)) {
|
||
|
|
|
||
|
|
// fix [a, ...[b]]
|
||
|
|
if (parent.parent.type === "RestElement") {
|
||
|
|
return fixRestInPattern(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix [ [a] ]
|
||
|
|
if (parent.parent.type === "ArrayPattern") {
|
||
|
|
return fixNestedArrayVariable(parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* fix var [a] = foo;
|
||
|
|
* fix function foo([a]) {}
|
||
|
|
* fix const { a: [b] } = foo;
|
||
|
|
*/
|
||
|
|
return fixVariables(parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// if "a" is unused in [a, b ,c] fixes to [, b, c]
|
||
|
|
if (tokenBefore.value === "," && tokenAfter.value === ",") {
|
||
|
|
return fixer.removeRange(id.range);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused rest elements
|
||
|
|
if (parentType === "RestElement") {
|
||
|
|
|
||
|
|
// fix [a, ...rest]
|
||
|
|
if (parent.parent.type === "ArrayPattern") {
|
||
|
|
if (hasSingleElement(parent.parent)) {
|
||
|
|
|
||
|
|
// fix [[...rest]] when there is only rest element
|
||
|
|
if (
|
||
|
|
parent.parent.parent.type === "ArrayPattern"
|
||
|
|
) {
|
||
|
|
return fixNestedArrayVariable(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix 'const [...rest] = foo;' and 'function foo([...rest]) {}'
|
||
|
|
return fixVariables(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix [a, ...rest]
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(id, 1), id.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix { a, ...rest}
|
||
|
|
if (parent.parent.type === "ObjectPattern") {
|
||
|
|
|
||
|
|
// fix 'const {...rest} = foo;' and 'function foo({...rest}) {}'
|
||
|
|
if (parent.parent.properties.length === 1) {
|
||
|
|
return fixVariables(parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix { a, ...rest} when there are multiple properties
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(id, 1), id.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix function foo(...rest) {}
|
||
|
|
if (isFunction(parent.parent)) {
|
||
|
|
|
||
|
|
// remove unused rest in function parameter if there is only single parameter
|
||
|
|
if (parent.parent.params.length === 1) {
|
||
|
|
return fixer.removeRange(parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused rest in function parameter if there multiple parameter
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent), parent.range[1]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parentType === "AssignmentPattern") {
|
||
|
|
|
||
|
|
// fix [a = aDefault]
|
||
|
|
if (parent.parent.type === "ArrayPattern") {
|
||
|
|
return fixNestedArrayVariable(parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix {a = aDefault}
|
||
|
|
if (parent.parent.parent.type === "ObjectPattern") {
|
||
|
|
if (parent.parent.parent.properties.length === 1) {
|
||
|
|
|
||
|
|
// fixes [{a = aDefault}]
|
||
|
|
if (parent.parent.parent.parent.type === "ArrayPattern") {
|
||
|
|
return fixNestedArrayVariable(parent.parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix 'const {a = aDefault} = foo;' and 'function foo({a = aDefault}) {}'
|
||
|
|
return fixVariables(parent.parent.parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix unused 'a' in {a = aDefault} if it is the first property
|
||
|
|
if (
|
||
|
|
getTokenBeforeValue(parent.parent) === "{" &&
|
||
|
|
getTokenAfterValue(parent.parent) === ","
|
||
|
|
) {
|
||
|
|
return fixer.removeRange([parent.parent.range[0], getNextTokenEnd(parent.parent)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix unused 'b' in {a, b = aDefault} if it is not the first property
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent.parent), parent.parent.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix unused assignment patterns in function parameters
|
||
|
|
if (isFunction(parent.parent)) {
|
||
|
|
return fixFunctionParameters(parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused functions
|
||
|
|
if (parentType === "FunctionDeclaration" && parent.id === id) {
|
||
|
|
return fixer.removeRange(parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused default import
|
||
|
|
if (parentType === "ImportDefaultSpecifier") {
|
||
|
|
|
||
|
|
// remove unused default import when there are not other imports
|
||
|
|
if (
|
||
|
|
!hasImportOfCertainType(parent.parent, "ImportSpecifier") &&
|
||
|
|
!hasImportOfCertainType(parent.parent, "ImportNamespaceSpecifier")
|
||
|
|
) {
|
||
|
|
return fixer.removeRange([parent.range[0], parent.parent.source.range[0]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused default import when there are other imports also
|
||
|
|
return fixer.removeRange([id.range[0], tokenAfter.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parentType === "ImportSpecifier") {
|
||
|
|
|
||
|
|
// remove unused imports when there is a single import
|
||
|
|
if (parent.parent.specifiers.filter(e => e.type === "ImportSpecifier").length === 1) {
|
||
|
|
|
||
|
|
// remove unused import when there is no default import
|
||
|
|
if (!hasImportOfCertainType(parent.parent, "ImportDefaultSpecifier")) {
|
||
|
|
return fixer.removeRange(parent.parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fixes "import foo from 'module';" to "import 'module';"
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent, 1), tokenAfter.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (getTokenBeforeValue(parent) === "{") {
|
||
|
|
return fixer.removeRange([parent.range[0], getNextTokenEnd(parent)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent), parent.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parentType === "ImportNamespaceSpecifier") {
|
||
|
|
if (hasImportOfCertainType(parent.parent, "ImportDefaultSpecifier")) {
|
||
|
|
return fixer.removeRange([getPreviousTokenStart(parent), parent.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fixes "import * as foo from 'module';" to "import 'module';"
|
||
|
|
return fixer.removeRange([parent.range[0], parent.parent.source.range[0]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// skip error in catch(error) variable
|
||
|
|
if (parentType === "CatchClause") {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused declared classes
|
||
|
|
if (parentType === "ClassDeclaration") {
|
||
|
|
return fixer.removeRange(parent.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused varible that is in a sequence [a,b] fixes to [a]
|
||
|
|
if (tokenBefore?.value === ",") {
|
||
|
|
return fixer.removeRange([tokenBefore.range[0], id.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove unused varible that is in a sequence inside function arguments and object pattern
|
||
|
|
if (tokenAfter.value === ",") {
|
||
|
|
|
||
|
|
// fix function foo(a, b) {}
|
||
|
|
if (tokenBefore.value === "(") {
|
||
|
|
return fixer.removeRange([id.range[0], tokenAfter.range[1]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// fix const {a, b} = foo;
|
||
|
|
if (tokenBefore.value === "{") {
|
||
|
|
return fixer.removeRange([id.range[0], tokenAfter.range[1]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parentType === "ArrowFunctionExpression" && parent.params.length === 1 && tokenAfter?.value !== ")") {
|
||
|
|
return fixer.replaceText(id, "()");
|
||
|
|
}
|
||
|
|
|
||
|
|
return fixer.removeRange(id.range);
|
||
|
|
}
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
// 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),
|
||
|
|
suggest: [
|
||
|
|
{
|
||
|
|
messageId: "removeVar",
|
||
|
|
data: {
|
||
|
|
varName: unusedVar.name
|
||
|
|
},
|
||
|
|
fix(fixer) {
|
||
|
|
return handleFixes(fixer, 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)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|