@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-assignment.js

@@ -1,654 +0,0 @@
-/**
- * @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],
-					});
-				}
-			},
-		};
-	},
-};