@alexlit/lint-kit 166.1.0 → 167.0.0

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

@@ -1,158 +0,0 @@
-/**
- * @fileoverview Rule to disallow unused labels.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unused labels",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unused-labels",
-		},
-
-		schema: [],
-
-		fixable: "code",
-
-		messages: {
-			unused: "'{{name}}:' is defined but never used.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		let scopeInfo = null;
-
-		/**
-		 * Adds a scope info to the stack.
-		 * @param {ASTNode} node A node to add. This is a LabeledStatement.
-		 * @returns {void}
-		 */
-		function enterLabeledScope(node) {
-			scopeInfo = {
-				label: node.label.name,
-				used: false,
-				upper: scopeInfo,
-			};
-		}
-
-		/**
-		 * Checks if a `LabeledStatement` node is fixable.
-		 * For a node to be fixable, there must be no comments between the label and the body.
-		 * Furthermore, is must be possible to remove the label without turning the body statement into a
-		 * directive after other fixes are applied.
-		 * @param {ASTNode} node The node to evaluate.
-		 * @returns {boolean} Whether or not the node is fixable.
-		 */
-		function isFixable(node) {
-			/*
-			 * Only perform a fix if there are no comments between the label and the body. This will be the case
-			 * when there is exactly one token/comment (the ":") between the label and the body.
-			 */
-			if (
-				sourceCode.getTokenAfter(node.label, {
-					includeComments: true,
-				}) !==
-				sourceCode.getTokenBefore(node.body, { includeComments: true })
-			) {
-				return false;
-			}
-
-			// Looking for the node's deepest ancestor which is not a `LabeledStatement`.
-			let ancestor = node.parent;
-
-			while (ancestor.type === "LabeledStatement") {
-				ancestor = ancestor.parent;
-			}
-
-			if (
-				ancestor.type === "Program" ||
-				(ancestor.type === "BlockStatement" &&
-					astUtils.isFunction(ancestor.parent))
-			) {
-				const { body } = node;
-
-				if (
-					body.type === "ExpressionStatement" &&
-					((body.expression.type === "Literal" &&
-						typeof body.expression.value === "string") ||
-						astUtils.isStaticTemplateLiteral(body.expression))
-				) {
-					return false; // potential directive
-				}
-			}
-			return true;
-		}
-
-		/**
-		 * Removes the top of the stack.
-		 * At the same time, this reports the label if it's never used.
-		 * @param {ASTNode} node A node to report. This is a LabeledStatement.
-		 * @returns {void}
-		 */
-		function exitLabeledScope(node) {
-			if (!scopeInfo.used) {
-				context.report({
-					node: node.label,
-					messageId: "unused",
-					data: node.label,
-					fix: isFixable(node)
-						? fixer =>
-								fixer.removeRange([
-									node.range[0],
-									node.body.range[0],
-								])
-						: null,
-				});
-			}
-
-			scopeInfo = scopeInfo.upper;
-		}
-
-		/**
-		 * Marks the label of a given node as used.
-		 * @param {ASTNode} node A node to mark. This is a BreakStatement or
-		 *      ContinueStatement.
-		 * @returns {void}
-		 */
-		function markAsUsed(node) {
-			if (!node.label) {
-				return;
-			}
-
-			const label = node.label.name;
-			let info = scopeInfo;
-
-			while (info) {
-				if (info.label === label) {
-					info.used = true;
-					break;
-				}
-				info = info.upper;
-			}
-		}
-
-		return {
-			LabeledStatement: enterLabeledScope,
-			"LabeledStatement:exit": exitLabeledScope,
-			BreakStatement: markAsUsed,
-			ContinueStatement: markAsUsed,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unused-private-class-members.js

@@ -1,219 +0,0 @@
-/**
- * @fileoverview Rule to flag declared but unused private class members
- * @author Tim van der Lippe
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow unused private class members",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members",
-		},
-
-		schema: [],
-
-		messages: {
-			unusedPrivateClassMember:
-				"'{{classMemberName}}' is defined but never used.",
-		},
-	},
-
-	create(context) {
-		const trackedClasses = [];
-
-		/**
-		 * Check whether the current node is in a write only assignment.
-		 * @param {ASTNode} privateIdentifierNode Node referring to a private identifier
-		 * @returns {boolean} Whether the node is in a write only assignment
-		 * @private
-		 */
-		function isWriteOnlyAssignment(privateIdentifierNode) {
-			const parentStatement = privateIdentifierNode.parent.parent;
-			const isAssignmentExpression =
-				parentStatement.type === "AssignmentExpression";
-
-			if (
-				!isAssignmentExpression &&
-				parentStatement.type !== "ForInStatement" &&
-				parentStatement.type !== "ForOfStatement" &&
-				parentStatement.type !== "AssignmentPattern"
-			) {
-				return false;
-			}
-
-			// It is a write-only usage, since we still allow usages on the right for reads
-			if (parentStatement.left !== privateIdentifierNode.parent) {
-				return false;
-			}
-
-			// For any other operator (such as '+=') we still consider it a read operation
-			if (isAssignmentExpression && parentStatement.operator !== "=") {
-				/*
-				 * However, if the read operation is "discarded" in an empty statement, then
-				 * we consider it write only.
-				 */
-				return parentStatement.parent.type === "ExpressionStatement";
-			}
-
-			return true;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			// Collect all declared members up front and assume they are all unused
-			ClassBody(classBodyNode) {
-				const privateMembers = new Map();
-
-				trackedClasses.unshift(privateMembers);
-				for (const bodyMember of classBodyNode.body) {
-					if (
-						bodyMember.type === "PropertyDefinition" ||
-						bodyMember.type === "MethodDefinition"
-					) {
-						if (bodyMember.key.type === "PrivateIdentifier") {
-							privateMembers.set(bodyMember.key.name, {
-								declaredNode: bodyMember,
-								isAccessor:
-									bodyMember.type === "MethodDefinition" &&
-									(bodyMember.kind === "set" ||
-										bodyMember.kind === "get"),
-							});
-						}
-					}
-				}
-			},
-
-			/*
-			 * Process all usages of the private identifier and remove a member from
-			 * `declaredAndUnusedPrivateMembers` if we deem it used.
-			 */
-			PrivateIdentifier(privateIdentifierNode) {
-				const classBody = trackedClasses.find(classProperties =>
-					classProperties.has(privateIdentifierNode.name),
-				);
-
-				// Can't happen, as it is a parser to have a missing class body, but let's code defensively here.
-				if (!classBody) {
-					return;
-				}
-
-				// In case any other usage was already detected, we can short circuit the logic here.
-				const memberDefinition = classBody.get(
-					privateIdentifierNode.name,
-				);
-
-				if (memberDefinition.isUsed) {
-					return;
-				}
-
-				// The definition of the class member itself
-				if (
-					privateIdentifierNode.parent.type ===
-						"PropertyDefinition" ||
-					privateIdentifierNode.parent.type === "MethodDefinition"
-				) {
-					return;
-				}
-
-				/*
-				 * Any usage of an accessor is considered a read, as the getter/setter can have
-				 * side-effects in its definition.
-				 */
-				if (memberDefinition.isAccessor) {
-					memberDefinition.isUsed = true;
-					return;
-				}
-
-				// Any assignments to this member, except for assignments that also read
-				if (isWriteOnlyAssignment(privateIdentifierNode)) {
-					return;
-				}
-
-				const wrappingExpressionType =
-					privateIdentifierNode.parent.parent.type;
-				const parentOfWrappingExpressionType =
-					privateIdentifierNode.parent.parent.parent.type;
-
-				// A statement which only increments (`this.#x++;`)
-				if (
-					wrappingExpressionType === "UpdateExpression" &&
-					parentOfWrappingExpressionType === "ExpressionStatement"
-				) {
-					return;
-				}
-
-				/*
-				 * ({ x: this.#usedInDestructuring } = bar);
-				 *
-				 * But should treat the following as a read:
-				 * ({ [this.#x]: a } = foo);
-				 */
-				if (
-					wrappingExpressionType === "Property" &&
-					parentOfWrappingExpressionType === "ObjectPattern" &&
-					privateIdentifierNode.parent.parent.value ===
-						privateIdentifierNode.parent
-				) {
-					return;
-				}
-
-				// [...this.#unusedInRestPattern] = bar;
-				if (wrappingExpressionType === "RestElement") {
-					return;
-				}
-
-				// [this.#unusedInAssignmentPattern] = bar;
-				if (wrappingExpressionType === "ArrayPattern") {
-					return;
-				}
-
-				/*
-				 * We can't delete the memberDefinition, as we need to keep track of which member we are marking as used.
-				 * In the case of nested classes, we only mark the first member we encounter as used. If you were to delete
-				 * the member, then any subsequent usage could incorrectly mark the member of an encapsulating parent class
-				 * as used, which is incorrect.
-				 */
-				memberDefinition.isUsed = true;
-			},
-
-			/*
-			 * Post-process the class members and report any remaining members.
-			 * Since private members can only be accessed in the current class context,
-			 * we can safely assume that all usages are within the current class body.
-			 */
-			"ClassBody:exit"() {
-				const unusedPrivateMembers = trackedClasses.shift();
-
-				for (const [
-					classMemberName,
-					{ declaredNode, isUsed },
-				] of unusedPrivateMembers.entries()) {
-					if (isUsed) {
-						continue;
-					}
-					context.report({
-						node: declaredNode,
-						loc: declaredNode.key.loc,
-						messageId: "unusedPrivateClassMember",
-						data: {
-							classMemberName: `#${classMemberName}`,
-						},
-					});
-				}
-			},
-		};
-	},
-};