eslint-linter-browserify 10.2.1 → 10.3.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.2.1";
+var version = "10.3.0";
 var require$$3$1 = {
 	version: version};
 
@@ -13380,10 +13380,9 @@ function requireIdGenerator () {
 		next() {
 			this.n = (1 + this.n) | 0;
 
-			/* c8 ignore start */
 			if (this.n < 0) {
 				this.n = 1;
-			} /* c8 ignore stop */
+			}
 
 			return this.prefix + this.n;
 		}
@@ -13819,8 +13818,8 @@ function requireCodePathAnalyzer () {
 	}
 
 	/**
-	 * Checks whether or not a given logical expression node goes different path
-	 * between the `true` case and the `false` case.
+	 * Checks whether a given logical expression node takes different paths for the
+	 * `true` and `false` cases.
 	 * @param {ASTNode} node A node to check.
 	 * @returns {boolean} `true` if the node is a test of a choice statement.
 	 */
@@ -13849,8 +13848,8 @@ function requireCodePathAnalyzer () {
 	/**
 	 * Gets the boolean value of a given literal node.
 	 *
-	 * This is used to detect infinity loops (e.g. `while (true) {}`).
-	 * Statements preceded by an infinity loop are unreachable if the loop didn't
+	 * This is used to detect infinite loops (e.g. `while (true) {}`).
+	 * Statements preceded by an infinite loop are unreachable if the loop didn't
 	 * have any `break` statement.
 	 * @param {ASTNode} node A node to get.
 	 * @returns {boolean|undefined} a boolean value if the node is a Literal node,
@@ -13963,8 +13962,8 @@ function requireCodePathAnalyzer () {
 	}
 
 	/**
-	 * Updates the current segment with empty.
-	 * This is called at the last of functions or the program.
+	 * Updates the current segment with an empty array.
+	 * This is called when a code path ends.
 	 * @param {CodePathAnalyzer} analyzer The instance.
 	 * @param {ASTNode} node The current AST node.
 	 * @returns {void}
@@ -14457,7 +14456,7 @@ function requireCodePathAnalyzer () {
 		 *     a = () => {}
 		 * }
 		 *
-		 * In this case, The ArrowFunctionExpression code path is closed first
+		 * In this case, the ArrowFunctionExpression code path is closed first,
 		 * and then we need to close the code path for the PropertyDefinition
 		 * value.
 		 */
@@ -47426,12 +47425,31 @@ function requireAstUtils () {
 		}
 
 		/**
-		 * Determines whether an opening parenthesis `(`, bracket `[` or backtick ``` ` ``` needs to be preceded by a semicolon.
-		 * This opening parenthesis or bracket should be at the start of an `ExpressionStatement`, a `MethodDefinition` or at
-		 * the start of the body of an `ArrowFunctionExpression`.
+		 * Checks whether a token can cause continuation of a preceding expression
+		 * (for example, of a class field initializer expression) in a class body.
+		 * This function checks specifically for tokens that can appear at the start
+		 * of a class member: `[` (computed key), `*` (generator method), `in` or `instanceof` (valid keys)
+		 * Without a preceding semicolon, these tokens would be parsed as index access or operators.
+		 * @param {Token} token The token to check.
+		 * @returns {boolean} Whether the token can cause continuation of a preceding expression.
+		 */
+		function canContinueExpressionInClassBody(token) {
+			return (
+				(token.type === "Punctuator" &&
+					(token.value === "[" || token.value === "*")) ||
+				// Different parsers may return these tokens as either "Identifier" or "Keyword"
+				((token.type === "Identifier" || token.type === "Keyword") &&
+					(token.value === "in" || token.value === "instanceof"))
+			);
+		}
+
+		/**
+		 * Determines whether an opening parenthesis `(`, bracket `[`, asterisk `*`, or backtick ``` ` ``` needs to be preceded by a semicolon.
+		 * This opening parenthesis or bracket should be at the start of an `ExpressionStatement`, a `MethodDefinition`, a `PropertyDefinition`,
+		 * or at the start of the body of an `ArrowFunctionExpression`.
 		 * @type {(sourceCode: SourceCode, node: ASTNode) => boolean}
 		 * @param {SourceCode} sourceCode The source code object.
-		 * @param {ASTNode} node A node at the position where an opening parenthesis or bracket will be inserted.
+		 * @param {ASTNode} node A node at the position where an opening parenthesis, bracket, or asterisk will be inserted.
 		 * @returns {boolean} Whether a semicolon is required before the opening parenthesis or bracket.
 		 */
 		let needsPrecedingSemicolon;
@@ -47522,6 +47540,18 @@ function requireAstUtils () {
 
 				const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]);
 
+				// Uninitialized class fields don't need a semicolon
+				if (
+					// Key
+					(prevNode.parent.type === "PropertyDefinition" &&
+						prevNode.parent.key === prevNode) ||
+					// Closing bracket of a computed key
+					(prevNode.type === "PropertyDefinition" &&
+						isClosingBracketToken(prevToken))
+				) {
+					return false;
+				}
+
 				if (
 					prevNode.type === "TSDeclareFunction" ||
 					prevNode.parent.type === "TSImportEqualsDeclaration" ||
@@ -49010,6 +49040,7 @@ function requireAstUtils () {
 			isTopLevelExpressionStatement,
 			isDirective,
 			isStartOfExpressionStatement,
+			canContinueExpressionInClassBody,
 			needsPrecedingSemicolon,
 			isImportAttributeKey,
 			getOpeningParenOfParams,
@@ -103350,6 +103381,12 @@ function requireNoUnusedPrivateClassMembers () {
 	if (hasRequiredNoUnusedPrivateClassMembers) return noUnusedPrivateClassMembers;
 	hasRequiredNoUnusedPrivateClassMembers = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -103358,6 +103395,7 @@ function requireNoUnusedPrivateClassMembers () {
 	noUnusedPrivateClassMembers = {
 		meta: {
 			type: "problem",
+			hasSuggestions: true,
 
 			docs: {
 				description: "Disallow unused private class members",
@@ -103370,12 +103408,168 @@ function requireNoUnusedPrivateClassMembers () {
 			messages: {
 				unusedPrivateClassMember:
 					"'{{classMemberName}}' is defined but never used.",
+				removeUnusedPrivateClassMember:
+					"Remove unused private class member '{{classMemberName}}'.",
 			},
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
 			const trackedClasses = [];
 
+			/**
+			 * Gets the start index of the line that contains a given token or node.
+			 * @param {ASTNode|Token|Comment} nodeOrToken The token or node to check
+			 * @returns {number} The line start index
+			 */
+			function getLineStartIndex(nodeOrToken) {
+				return nodeOrToken.range[0] - nodeOrToken.loc.start.column;
+			}
+
+			/**
+			 * Checks whether a token or node starts on its own line, preceded only by whitespace.
+			 * @param {ASTNode|Token|Comment} nodeOrToken The token or node to check
+			 * @returns {boolean} Whether the token or node starts on its own line
+			 */
+			function startsOnOwnLine(nodeOrToken) {
+				return (
+					sourceCode.getTokenBefore(nodeOrToken, {
+						includeComments: true,
+					}).loc.end.line !== nodeOrToken.loc.start.line
+				);
+			}
+
+			/**
+			 * Gets leading comments that are directly attached to a class member.
+			 * @param {ASTNode} classMemberNode The class member node
+			 * @returns {Comment[]} Leading comments to remove with the member
+			 */
+			function getLeadingComments(classMemberNode) {
+				const commentsBefore =
+					sourceCode.getCommentsBefore(classMemberNode);
+				const lastNonLeadingCommentIndex = commentsBefore.findLastIndex(
+					(comment, index, self) => {
+						const next =
+							index < self.length - 1
+								? self[index + 1]
+								: classMemberNode;
+
+						return (
+							!startsOnOwnLine(comment) ||
+							next.loc.start.line - comment.loc.end.line > 1
+						);
+					},
+				);
+
+				return commentsBefore.slice(lastNonLeadingCommentIndex + 1);
+			}
+
+			/**
+			 * Checks whether a class member shares its line with another token.
+			 * @param {ASTNode} classMemberNode The class member node
+			 * @returns {boolean} Whether the member shares its line with another token
+			 */
+			function sharesLineWithAnotherToken(classMemberNode) {
+				const previousToken = sourceCode.getTokenBefore(classMemberNode);
+				const nextToken = sourceCode.getTokenAfter(classMemberNode);
+
+				return (
+					previousToken.loc.end.line === classMemberNode.loc.start.line ||
+					nextToken.loc.start.line === classMemberNode.loc.end.line
+				);
+			}
+
+			/**
+			 * Gets trailing comments that are directly attached to a class member.
+			 * Same-line trailing comments are preserved when another token shares
+			 * the line, because the comment might describe the remaining code rather
+			 * than the unused member alone.
+			 * @param {ASTNode} classMemberNode The class member node
+			 * @returns {Comment[]} Trailing comments to remove with the member
+			 */
+			function getTrailingComments(classMemberNode) {
+				if (sharesLineWithAnotherToken(classMemberNode)) {
+					return [];
+				}
+
+				return sourceCode
+					.getCommentsAfter(classMemberNode)
+					.filter(
+						comment =>
+							comment.loc.start.line === classMemberNode.loc.end.line,
+					);
+			}
+
+			/**
+			 * Gets the token after which a semicolon should be inserted when removing a class member.
+			 * @param {ASTNode} classMemberNode The member that would be removed
+			 * @returns {Token|null} The token after which a semicolon should be inserted, or null if no semicolon is needed
+			 */
+			function getSemicolonInsertionToken(classMemberNode) {
+				const nextToken = sourceCode.getTokenAfter(classMemberNode);
+
+				if (
+					astUtils.canContinueExpressionInClassBody(nextToken) &&
+					astUtils.needsPrecedingSemicolon(sourceCode, classMemberNode)
+				) {
+					return sourceCode.getTokenBefore(classMemberNode);
+				}
+
+				return null;
+			}
+
+			/**
+			 * Gets the replacement range for removing an unused class member.
+			 * @param {ASTNode} classMemberNode The member that would be removed
+			 * @returns {number[]} The text range to remove
+			 */
+			function getMemberRemovalRange(classMemberNode) {
+				const leadingComments = getLeadingComments(classMemberNode);
+				const trailingComments = getTrailingComments(classMemberNode);
+				const shouldRemoveLeadingComments =
+					leadingComments.length > 0 &&
+					!sharesLineWithAnotherToken(classMemberNode);
+				const lastItemToRemove =
+					trailingComments.length > 0
+						? trailingComments.at(-1)
+						: classMemberNode;
+
+				const previousToken = sourceCode.getTokenBefore(classMemberNode);
+				const nextToken = sourceCode.getTokenAfter(lastItemToRemove, {
+					includeComments: true,
+				});
+				const nextTokenStartsOnNewLine =
+					nextToken.loc.start.line > lastItemToRemove.loc.end.line;
+				const shouldRemoveOwnLine =
+					!shouldRemoveLeadingComments &&
+					startsOnOwnLine(classMemberNode) &&
+					nextTokenStartsOnNewLine;
+				let start = classMemberNode.range[0];
+				let end = lastItemToRemove.range[1];
+
+				if (shouldRemoveLeadingComments) {
+					start = nextTokenStartsOnNewLine
+						? getLineStartIndex(leadingComments[0])
+						: leadingComments[0].range[0];
+					end = nextTokenStartsOnNewLine
+						? getLineStartIndex(nextToken)
+						: nextToken.range[0];
+				} else if (shouldRemoveOwnLine) {
+					start = getLineStartIndex(classMemberNode);
+					end = getLineStartIndex(nextToken);
+				} else if (
+					previousToken.loc.end.line === classMemberNode.loc.start.line
+				) {
+					start = previousToken.range[1];
+				} else if (
+					nextToken.loc.start.line === lastItemToRemove.loc.end.line
+				) {
+					end = nextToken.range[0];
+				}
+
+				return [start, end];
+			}
+
 			/**
 			 * Check whether the current node is in a write only assignment.
 			 * @param {ASTNode} privateIdentifierNode Node referring to a private identifier
@@ -103431,6 +103625,7 @@ function requireNoUnusedPrivateClassMembers () {
 							if (bodyMember.key.type === "PrivateIdentifier") {
 								privateMembers.set(bodyMember.key.name, {
 									declaredNode: bodyMember,
+									hasReference: false,
 									isAccessor:
 										bodyMember.type === "MethodDefinition" &&
 										(bodyMember.kind === "set" ||
@@ -103473,6 +103668,8 @@ function requireNoUnusedPrivateClassMembers () {
 						return;
 					}
 
+					memberDefinition.hasReference = true;
+
 					/*
 					 * Any usage of an accessor is considered a read, as the getter/setter can have
 					 * side-effects in its definition.
@@ -103544,11 +103741,12 @@ function requireNoUnusedPrivateClassMembers () {
 
 					for (const [
 						classMemberName,
-						{ declaredNode, isUsed },
+						{ declaredNode, hasReference, isUsed },
 					] of unusedPrivateMembers.entries()) {
 						if (isUsed) {
 							continue;
 						}
+
 						context.report({
 							node: declaredNode,
 							loc: declaredNode.key.loc,
@@ -103556,6 +103754,39 @@ function requireNoUnusedPrivateClassMembers () {
 							data: {
 								classMemberName: `#${classMemberName}`,
 							},
+							suggest: [
+								{
+									messageId: "removeUnusedPrivateClassMember",
+									data: {
+										classMemberName: `#${classMemberName}`,
+									},
+									*fix(fixer) {
+										if (hasReference) {
+											return;
+										}
+
+										const removalRange =
+											getMemberRemovalRange(declaredNode);
+										const semicolonInsertionToken =
+											getSemicolonInsertionToken(
+												declaredNode,
+											);
+										const removalFix = fixer.replaceTextRange(
+											removalRange,
+											"",
+										);
+
+										yield removalFix;
+
+										if (semicolonInsertionToken) {
+											yield fixer.insertTextAfter(
+												semicolonInsertionToken,
+												";",
+											);
+										}
+									},
+								},
+							],
 						});
 					}
 				},
@@ -107139,7 +107370,7 @@ function requireNoUselessConcat () {
 	}
 
 	/**
-	 * Get's the right most node on the left side of a BinaryExpression with + operator.
+	 * Gets the right most node on the left side of a BinaryExpression with + operator.
 	 * @param {ASTNode} node A BinaryExpression node to check.
 	 * @returns {ASTNode} node
 	 */
@@ -107153,7 +107384,7 @@ function requireNoUselessConcat () {
 	}
 
 	/**
-	 * Get's the left most node on the right side of a BinaryExpression with + operator.
+	 * Gets the left most node on the right side of a BinaryExpression with + operator.
 	 * @param {ASTNode} node A BinaryExpression node to check.
 	 * @returns {ASTNode} node
 	 */
@@ -107473,8 +107704,9 @@ function requireNoUselessConstructor () {
 									const nextToken =
 										sourceCode.getTokenAfter(node);
 									const addSemiColon =
-										nextToken.type === "Punctuator" &&
-										nextToken.value === "[" &&
+										astUtils.canContinueExpressionInClassBody(
+											nextToken,
+										) &&
 										astUtils.needsPrecedingSemicolon(
 											sourceCode,
 											node,
@@ -119691,12 +119923,14 @@ function requireRequireAwait () {
 					 */
 					const nextToken = sourceCode.getTokenAfter(asyncToken);
 					const addSemiColon =
-						nextToken.type === "Punctuator" &&
-						(nextToken.value === "[" || nextToken.value === "(") &&
-						(nodeWithAsyncKeyword.type === "MethodDefinition" ||
+						((astUtils.isOpeningParenToken(nextToken) &&
 							astUtils.isStartOfExpressionStatement(
 								nodeWithAsyncKeyword,
-							)) &&
+							)) ||
+							(nodeWithAsyncKeyword.type === "MethodDefinition" &&
+								astUtils.canContinueExpressionInClassBody(
+									nextToken,
+								))) &&
 						astUtils.needsPrecedingSemicolon(
 							sourceCode,
 							nodeWithAsyncKeyword,