Software: Apache. PHP/8.1.30 uname -a: Linux server1.tuhinhossain.com 5.15.0-151-generic #161-Ubuntu SMP Tue Jul 22 14:25:40 UTC uid=1002(picotech) gid=1003(picotech) groups=1003(picotech),0(root) Safe-mode: OFF (not secure) /home/picotech/domains/rentals.picotech.app/public_html/node_modules/eslint/lib/rules/ drwxr-xr-x | |
| Viewing file: Select action/file-type: /**
* @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('../shared/types').Rule} */
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.
*/
/**
* @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) {
/**
* @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;
}
}
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()
};
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);
},
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]
});
}
}
};
}
};
|
:: Command execute :: | |
--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0055 ]-- |