Add components
This commit is contained in:
654
slider/node_modules/eslint/lib/rules/no-useless-assignment.js
generated
vendored
Normal file
654
slider/node_modules/eslint/lib/rules/no-useless-assignment.js
generated
vendored
Normal file
@@ -0,0 +1,654 @@
|
||||
/**
|
||||
* @fileoverview A rule to disallow unnecessary assignments`.
|
||||
* @author Yosuke Ota
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const { findVariable } = require("@eslint-community/eslint-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Types
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @typedef {import("estree").Node} ASTNode */
|
||||
/** @typedef {import("estree").Pattern} Pattern */
|
||||
/** @typedef {import("estree").Identifier} Identifier */
|
||||
/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
|
||||
/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
|
||||
/** @typedef {import("estree").UpdateExpression} UpdateExpression */
|
||||
/** @typedef {import("estree").Expression} Expression */
|
||||
/** @typedef {import("eslint-scope").Scope} Scope */
|
||||
/** @typedef {import("eslint-scope").Variable} Variable */
|
||||
/** @typedef {import("../linter/code-path-analysis/code-path")} CodePath */
|
||||
/** @typedef {import("../linter/code-path-analysis/code-path-segment")} CodePathSegment */
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extract identifier from the given pattern node used on the left-hand side of the assignment.
|
||||
* @param {Pattern} pattern The pattern node to extract identifier
|
||||
* @returns {Iterable<Identifier>} The extracted identifier
|
||||
*/
|
||||
function* extractIdentifiersFromPattern(pattern) {
|
||||
switch (pattern.type) {
|
||||
case "Identifier":
|
||||
yield pattern;
|
||||
return;
|
||||
case "ObjectPattern":
|
||||
for (const property of pattern.properties) {
|
||||
yield* extractIdentifiersFromPattern(
|
||||
property.type === "Property" ? property.value : property,
|
||||
);
|
||||
}
|
||||
return;
|
||||
case "ArrayPattern":
|
||||
for (const element of pattern.elements) {
|
||||
if (!element) {
|
||||
continue;
|
||||
}
|
||||
yield* extractIdentifiersFromPattern(element);
|
||||
}
|
||||
return;
|
||||
case "RestElement":
|
||||
yield* extractIdentifiersFromPattern(pattern.argument);
|
||||
return;
|
||||
case "AssignmentPattern":
|
||||
yield* extractIdentifiersFromPattern(pattern.left);
|
||||
|
||||
// no default
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given identifier node is evaluated after the assignment identifier.
|
||||
* @param {AssignmentInfo} assignment The assignment info.
|
||||
* @param {Identifier} identifier The identifier to check.
|
||||
* @returns {boolean} `true` if the given identifier node is evaluated after the assignment identifier.
|
||||
*/
|
||||
function isIdentifierEvaluatedAfterAssignment(assignment, identifier) {
|
||||
if (identifier.range[0] < assignment.identifier.range[1]) {
|
||||
return false;
|
||||
}
|
||||
if (
|
||||
assignment.expression &&
|
||||
assignment.expression.range[0] <= identifier.range[0] &&
|
||||
identifier.range[1] <= assignment.expression.range[1]
|
||||
) {
|
||||
/*
|
||||
* The identifier node is in an expression that is evaluated before the assignment.
|
||||
* e.g. x = id;
|
||||
* ^^ identifier to check
|
||||
* ^ assignment identifier
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* e.g.
|
||||
* x = 42; id;
|
||||
* ^^ identifier to check
|
||||
* ^ assignment identifier
|
||||
* let { x, y = id } = obj;
|
||||
* ^^ identifier to check
|
||||
* ^ assignment identifier
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given identifier node is used between the assigned identifier and the equal sign.
|
||||
*
|
||||
* e.g. let { x, y = x } = obj;
|
||||
* ^ identifier to check
|
||||
* ^ assigned identifier
|
||||
* @param {AssignmentInfo} assignment The assignment info.
|
||||
* @param {Identifier} identifier The identifier to check.
|
||||
* @returns {boolean} `true` if the given identifier node is used between the assigned identifier and the equal sign.
|
||||
*/
|
||||
function isIdentifierUsedBetweenAssignedAndEqualSign(assignment, identifier) {
|
||||
if (!assignment.expression) {
|
||||
return false;
|
||||
}
|
||||
return (
|
||||
assignment.identifier.range[1] <= identifier.range[0] &&
|
||||
identifier.range[1] <= assignment.expression.range[0]
|
||||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow variable assignments when the value is not used",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-useless-assignment",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unnecessaryAssignment:
|
||||
"This assigned value is not used in subsequent statements.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* @typedef {Object} ScopeStack
|
||||
* @property {CodePath} codePath The code path of this scope stack.
|
||||
* @property {Scope} scope The scope of this scope stack.
|
||||
* @property {ScopeStack} upper The upper scope stack.
|
||||
* @property {Record<string, ScopeStackSegmentInfo>} segments The map of ScopeStackSegmentInfo.
|
||||
* @property {Set<CodePathSegment>} currentSegments The current CodePathSegments.
|
||||
* @property {Map<Variable, AssignmentInfo[]>} assignments The map of list of AssignmentInfo for each variable.
|
||||
* @property {Array} tryStatementBlocks The array of TryStatement block nodes in this scope stack.
|
||||
*/
|
||||
/**
|
||||
* @typedef {Object} ScopeStackSegmentInfo
|
||||
* @property {CodePathSegment} segment The code path segment.
|
||||
* @property {Identifier|null} first The first identifier that appears within the segment.
|
||||
* @property {Identifier|null} last The last identifier that appears within the segment.
|
||||
* `first` and `last` are used to determine whether an identifier exists within the segment position range.
|
||||
* Since it is used as a range of segments, we should originally hold all nodes, not just identifiers,
|
||||
* but since the only nodes to be judged are identifiers, it is sufficient to have a range of identifiers.
|
||||
*/
|
||||
/**
|
||||
* @typedef {Object} AssignmentInfo
|
||||
* @property {Variable} variable The variable that is assigned.
|
||||
* @property {Identifier} identifier The identifier that is assigned.
|
||||
* @property {VariableDeclarator|AssignmentExpression|UpdateExpression} node The node where the variable was updated.
|
||||
* @property {Expression|null} expression The expression that is evaluated before the assignment.
|
||||
* @property {CodePathSegment[]} segments The code path segments where the assignment was made.
|
||||
*/
|
||||
|
||||
/** @type {ScopeStack} */
|
||||
let scopeStack = null;
|
||||
|
||||
/** @type {Set<Scope>} */
|
||||
const codePathStartScopes = new Set();
|
||||
|
||||
/**
|
||||
* Gets the scope of code path start from given scope
|
||||
* @param {Scope} scope The initial scope
|
||||
* @returns {Scope} The scope of code path start
|
||||
* @throws {Error} Unexpected error
|
||||
*/
|
||||
function getCodePathStartScope(scope) {
|
||||
let target = scope;
|
||||
|
||||
while (target) {
|
||||
if (codePathStartScopes.has(target)) {
|
||||
return target;
|
||||
}
|
||||
target = target.upper;
|
||||
}
|
||||
|
||||
// Should be unreachable
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify the given scope stack.
|
||||
* @param {ScopeStack} target The scope stack to verify.
|
||||
* @returns {void}
|
||||
*/
|
||||
function verify(target) {
|
||||
/**
|
||||
* Checks whether the given identifier is used in the segment.
|
||||
* @param {CodePathSegment} segment The code path segment.
|
||||
* @param {Identifier} identifier The identifier to check.
|
||||
* @returns {boolean} `true` if the identifier is used in the segment.
|
||||
*/
|
||||
function isIdentifierUsedInSegment(segment, identifier) {
|
||||
const segmentInfo = target.segments[segment.id];
|
||||
|
||||
return (
|
||||
segmentInfo.first &&
|
||||
segmentInfo.last &&
|
||||
segmentInfo.first.range[0] <= identifier.range[0] &&
|
||||
identifier.range[1] <= segmentInfo.last.range[1]
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies whether the given assignment info is an used assignment.
|
||||
* Report if it is an unused assignment.
|
||||
* @param {AssignmentInfo} targetAssignment The assignment info to verify.
|
||||
* @param {AssignmentInfo[]} allAssignments The list of all assignment info for variables.
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyAssignmentIsUsed(targetAssignment, allAssignments) {
|
||||
// Skip assignment if it is in a try block.
|
||||
const isAssignmentInTryBlock = target.tryStatementBlocks.some(
|
||||
tryBlock =>
|
||||
tryBlock.range[0] <=
|
||||
targetAssignment.identifier.range[0] &&
|
||||
targetAssignment.identifier.range[1] <=
|
||||
tryBlock.range[1],
|
||||
);
|
||||
|
||||
if (isAssignmentInTryBlock) {
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* @typedef {Object} SubsequentSegmentData
|
||||
* @property {CodePathSegment} segment The code path segment
|
||||
* @property {AssignmentInfo} [assignment] The first occurrence of the assignment within the segment.
|
||||
* There is no need to check if the variable is used after this assignment,
|
||||
* as the value it was assigned will be used.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Information used in `getSubsequentSegments()`.
|
||||
* To avoid unnecessary iterations, cache information that has already been iterated over,
|
||||
* and if additional iterations are needed, start iterating from the retained position.
|
||||
*/
|
||||
const subsequentSegmentData = {
|
||||
/**
|
||||
* Cache of subsequent segment information list that have already been iterated.
|
||||
* @type {SubsequentSegmentData[]}
|
||||
*/
|
||||
results: [],
|
||||
|
||||
/**
|
||||
* Subsequent segments that have already been iterated on. Used to avoid infinite loops.
|
||||
* @type {Set<CodePathSegment>}
|
||||
*/
|
||||
subsequentSegments: new Set(),
|
||||
|
||||
/**
|
||||
* Unexplored code path segment.
|
||||
* If additional iterations are needed, consume this information and iterate.
|
||||
* @type {CodePathSegment[]}
|
||||
*/
|
||||
queueSegments: targetAssignment.segments.flatMap(
|
||||
segment => segment.nextSegments,
|
||||
),
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets the subsequent segments from the segment of
|
||||
* the assignment currently being validated (targetAssignment).
|
||||
* @returns {Iterable<SubsequentSegmentData>} the subsequent segments
|
||||
*/
|
||||
function* getSubsequentSegments() {
|
||||
yield* subsequentSegmentData.results;
|
||||
|
||||
while (subsequentSegmentData.queueSegments.length > 0) {
|
||||
const nextSegment =
|
||||
subsequentSegmentData.queueSegments.shift();
|
||||
|
||||
if (
|
||||
subsequentSegmentData.subsequentSegments.has(
|
||||
nextSegment,
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
subsequentSegmentData.subsequentSegments.add(
|
||||
nextSegment,
|
||||
);
|
||||
|
||||
const assignmentInSegment = allAssignments.find(
|
||||
otherAssignment =>
|
||||
otherAssignment.segments.includes(
|
||||
nextSegment,
|
||||
) &&
|
||||
!isIdentifierUsedBetweenAssignedAndEqualSign(
|
||||
otherAssignment,
|
||||
targetAssignment.identifier,
|
||||
),
|
||||
);
|
||||
|
||||
if (!assignmentInSegment) {
|
||||
/*
|
||||
* Stores the next segment to explore.
|
||||
* If `assignmentInSegment` exists,
|
||||
* we are guarding it because we don't need to explore the next segment.
|
||||
*/
|
||||
subsequentSegmentData.queueSegments.push(
|
||||
...nextSegment.nextSegments,
|
||||
);
|
||||
}
|
||||
|
||||
/** @type {SubsequentSegmentData} */
|
||||
const result = {
|
||||
segment: nextSegment,
|
||||
assignment: assignmentInSegment,
|
||||
};
|
||||
|
||||
subsequentSegmentData.results.push(result);
|
||||
yield result;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
targetAssignment.variable.references.some(
|
||||
ref => ref.identifier.type !== "Identifier",
|
||||
)
|
||||
) {
|
||||
/**
|
||||
* Skip checking for a variable that has at least one non-identifier reference.
|
||||
* It's generated by plugins and cannot be handled reliably in the core rule.
|
||||
*/
|
||||
return;
|
||||
}
|
||||
|
||||
const readReferences =
|
||||
targetAssignment.variable.references.filter(reference =>
|
||||
reference.isRead(),
|
||||
);
|
||||
|
||||
if (!readReferences.length) {
|
||||
/*
|
||||
* It is not just an unnecessary assignment, but an unnecessary (unused) variable
|
||||
* and thus should not be reported by this rule because it is reported by `no-unused-vars`.
|
||||
*/
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Other assignment on the current segment and after current assignment.
|
||||
*/
|
||||
const otherAssignmentAfterTargetAssignment =
|
||||
allAssignments.find(assignment => {
|
||||
if (
|
||||
assignment === targetAssignment ||
|
||||
(assignment.segments.length &&
|
||||
assignment.segments.every(
|
||||
segment =>
|
||||
!targetAssignment.segments.includes(
|
||||
segment,
|
||||
),
|
||||
))
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
if (
|
||||
isIdentifierEvaluatedAfterAssignment(
|
||||
targetAssignment,
|
||||
assignment.identifier,
|
||||
)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (
|
||||
assignment.expression &&
|
||||
assignment.expression.range[0] <=
|
||||
targetAssignment.identifier.range[0] &&
|
||||
targetAssignment.identifier.range[1] <=
|
||||
assignment.expression.range[1]
|
||||
) {
|
||||
/*
|
||||
* The target assignment is in an expression that is evaluated before the assignment.
|
||||
* e.g. x=(x=1);
|
||||
* ^^^ targetAssignment
|
||||
* ^^^^^^^ assignment
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
|
||||
for (const reference of readReferences) {
|
||||
/*
|
||||
* If the scope of the reference is outside the current code path scope,
|
||||
* we cannot track whether this assignment is not used.
|
||||
* For example, it can also be called asynchronously.
|
||||
*/
|
||||
if (
|
||||
target.scope !== getCodePathStartScope(reference.from)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Checks if it is used in the same segment as the target assignment.
|
||||
if (
|
||||
isIdentifierEvaluatedAfterAssignment(
|
||||
targetAssignment,
|
||||
reference.identifier,
|
||||
) &&
|
||||
(isIdentifierUsedBetweenAssignedAndEqualSign(
|
||||
targetAssignment,
|
||||
reference.identifier,
|
||||
) ||
|
||||
targetAssignment.segments.some(segment =>
|
||||
isIdentifierUsedInSegment(
|
||||
segment,
|
||||
reference.identifier,
|
||||
),
|
||||
))
|
||||
) {
|
||||
if (
|
||||
otherAssignmentAfterTargetAssignment &&
|
||||
isIdentifierEvaluatedAfterAssignment(
|
||||
otherAssignmentAfterTargetAssignment,
|
||||
reference.identifier,
|
||||
)
|
||||
) {
|
||||
// There was another assignment before the reference. Therefore, it has not been used yet.
|
||||
continue;
|
||||
}
|
||||
|
||||
// Uses in statements after the written identifier.
|
||||
return;
|
||||
}
|
||||
|
||||
if (otherAssignmentAfterTargetAssignment) {
|
||||
/*
|
||||
* The assignment was followed by another assignment in the same segment.
|
||||
* Therefore, there is no need to check the next segment.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check subsequent segments.
|
||||
for (const subsequentSegment of getSubsequentSegments()) {
|
||||
if (
|
||||
isIdentifierUsedInSegment(
|
||||
subsequentSegment.segment,
|
||||
reference.identifier,
|
||||
)
|
||||
) {
|
||||
if (
|
||||
subsequentSegment.assignment &&
|
||||
isIdentifierEvaluatedAfterAssignment(
|
||||
subsequentSegment.assignment,
|
||||
reference.identifier,
|
||||
)
|
||||
) {
|
||||
// There was another assignment before the reference. Therefore, it has not been used yet.
|
||||
continue;
|
||||
}
|
||||
|
||||
// It is used
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
context.report({
|
||||
node: targetAssignment.identifier,
|
||||
messageId: "unnecessaryAssignment",
|
||||
});
|
||||
}
|
||||
|
||||
// Verify that each assignment in the code path is used.
|
||||
for (const assignments of target.assignments.values()) {
|
||||
assignments.sort(
|
||||
(a, b) => a.identifier.range[0] - b.identifier.range[0],
|
||||
);
|
||||
for (const assignment of assignments) {
|
||||
verifyAssignmentIsUsed(assignment, assignments);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
onCodePathStart(codePath, node) {
|
||||
const scope = sourceCode.getScope(node);
|
||||
|
||||
scopeStack = {
|
||||
upper: scopeStack,
|
||||
codePath,
|
||||
scope,
|
||||
segments: Object.create(null),
|
||||
currentSegments: new Set(),
|
||||
assignments: new Map(),
|
||||
tryStatementBlocks: [],
|
||||
};
|
||||
codePathStartScopes.add(scopeStack.scope);
|
||||
},
|
||||
onCodePathEnd() {
|
||||
verify(scopeStack);
|
||||
|
||||
scopeStack = scopeStack.upper;
|
||||
},
|
||||
onCodePathSegmentStart(segment) {
|
||||
const segmentInfo = { segment, first: null, last: null };
|
||||
|
||||
scopeStack.segments[segment.id] = segmentInfo;
|
||||
scopeStack.currentSegments.add(segment);
|
||||
},
|
||||
onCodePathSegmentEnd(segment) {
|
||||
scopeStack.currentSegments.delete(segment);
|
||||
},
|
||||
TryStatement(node) {
|
||||
scopeStack.tryStatementBlocks.push(node.block);
|
||||
},
|
||||
Identifier(node) {
|
||||
for (const segment of scopeStack.currentSegments) {
|
||||
const segmentInfo = scopeStack.segments[segment.id];
|
||||
|
||||
if (!segmentInfo.first) {
|
||||
segmentInfo.first = node;
|
||||
}
|
||||
segmentInfo.last = node;
|
||||
}
|
||||
},
|
||||
":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(
|
||||
node,
|
||||
) {
|
||||
if (scopeStack.currentSegments.size === 0) {
|
||||
// Ignore unreachable segments
|
||||
return;
|
||||
}
|
||||
|
||||
const assignments = scopeStack.assignments;
|
||||
|
||||
let pattern;
|
||||
let expression = null;
|
||||
|
||||
if (node.type === "VariableDeclarator") {
|
||||
pattern = node.id;
|
||||
expression = node.init;
|
||||
} else if (node.type === "AssignmentExpression") {
|
||||
pattern = node.left;
|
||||
expression = node.right;
|
||||
} else {
|
||||
// UpdateExpression
|
||||
pattern = node.argument;
|
||||
}
|
||||
|
||||
for (const identifier of extractIdentifiersFromPattern(
|
||||
pattern,
|
||||
)) {
|
||||
const scope = sourceCode.getScope(identifier);
|
||||
|
||||
/** @type {Variable} */
|
||||
const variable = findVariable(scope, identifier);
|
||||
|
||||
if (!variable) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// We don't know where global variables are used.
|
||||
if (
|
||||
variable.scope.type === "global" &&
|
||||
variable.defs.length === 0
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the scope of the variable is outside the current code path scope,
|
||||
* we cannot track whether this assignment is not used.
|
||||
*/
|
||||
if (
|
||||
scopeStack.scope !==
|
||||
getCodePathStartScope(variable.scope)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Variables marked by `markVariableAsUsed()` or
|
||||
// exported by "exported" block comment.
|
||||
if (variable.eslintUsed) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Variables exported by ESM export syntax
|
||||
if (variable.scope.type === "module") {
|
||||
if (
|
||||
variable.defs.some(
|
||||
def =>
|
||||
(def.type === "Variable" &&
|
||||
def.parent.parent.type ===
|
||||
"ExportNamedDeclaration") ||
|
||||
(def.type === "FunctionName" &&
|
||||
(def.node.parent.type ===
|
||||
"ExportNamedDeclaration" ||
|
||||
def.node.parent.type ===
|
||||
"ExportDefaultDeclaration")) ||
|
||||
(def.type === "ClassName" &&
|
||||
(def.node.parent.type ===
|
||||
"ExportNamedDeclaration" ||
|
||||
def.node.parent.type ===
|
||||
"ExportDefaultDeclaration")),
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
if (
|
||||
variable.references.some(
|
||||
reference =>
|
||||
reference.identifier.parent.type ===
|
||||
"ExportSpecifier",
|
||||
)
|
||||
) {
|
||||
// It have `export { ... }` reference.
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
let list = assignments.get(variable);
|
||||
|
||||
if (!list) {
|
||||
list = [];
|
||||
assignments.set(variable, list);
|
||||
}
|
||||
list.push({
|
||||
variable,
|
||||
identifier,
|
||||
node,
|
||||
expression,
|
||||
segments: [...scopeStack.currentSegments],
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user