eslint-linter-browserify 10.2.0 → 10.3.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.2.0";
+var version = "10.3.0";
 var require$$3$1 = {
 	version: version};
 
@@ -11523,11 +11523,10 @@ function requireCodePathState () {
 			this.position = "try";
 
 			/**
-			 * If the `try` statement has a `finally` block, this affects how a
-			 * `return` statement behaves in the `try` block. Without `finally`,
-			 * `return` behaves as usual and doesn't require a fork; with `finally`,
-			 * `return` forks into the `finally` block, so we need a fork context
-			 * to track it.
+			 * If the `try` statement has a `finally` block, this affects how return-like
+			 * leaving paths behave in the `try` block. Without `finally`, they behave as
+			 * usual and don't require a fork; with `finally`, they fork into the
+			 * `finally` block, so we need a fork context to track them.
 			 * @type {ForkContext|null}
 			 */
 			this.returnedForkContext = hasFinalizer
@@ -12709,6 +12708,23 @@ function requireCodePathState () {
 			this.forkContext.add(segments);
 		}
 
+		/**
+		 * Records abrupt resumption paths from a suspended `yield` expression,
+		 * then splits normal post-`yield` continuation into a fresh segment.
+		 * @returns {void}
+		 */
+		makeYield() {
+			const forkContext = this.forkContext;
+			const leavingSegments = forkContext.head;
+
+			if (forkContext.reachable) {
+				getReturnContext(this).returnedForkContext.add(leavingSegments);
+				getThrowContext(this).thrownForkContext.add(leavingSegments);
+
+				forkContext.replaceHead(forkContext.makeNext(-1, -1));
+			}
+		}
+
 		/**
 		 * Makes a code path segment from the first throwable node to the `catch`
 		 * block or the `finally` block.
@@ -13364,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;
 		}
@@ -13484,9 +13499,10 @@ function requireCodePath () {
 		 * Final code path segments that represent normal completion of the code path.
 		 * For functions, this means both explicit `return` statements and implicit returns,
 		 * such as the last reachable segment in a function that does not have an
-		 * explicit `return` as this implicitly returns `undefined`. For scripts,
-		 * modules, class field initializers, and class static blocks, this means
-		 * all lines of code have been executed.
+		 * explicit `return` as this implicitly returns `undefined`, as well as
+		 * return-like exits from suspended `yield` expressions. For scripts, modules,
+		 * class field initializers, and class static blocks, this means all lines of
+		 * code have been executed.
 		 * These segments are also present in `finalSegments`.
 		 * This is a passthrough to the underlying `CodePathState`.
 		 * @type {CodePathSegment[]}
@@ -13496,7 +13512,8 @@ function requireCodePath () {
 		}
 
 		/**
-		 * Final code path segments that represent `throw` statements.
+		 * Final code path segments that represent `throw` statements and throw-like
+		 * exits from suspended `yield` expressions.
 		 * This is a passthrough to the underlying `CodePathState`.
 		 * These segments are also present in `finalSegments`.
 		 * @type {CodePathSegment[]}
@@ -13755,7 +13772,7 @@ function requireCodePathAnalyzer () {
 
 	/**
 	 * Checks if a given node appears as the value of a PropertyDefinition node.
-	 * @param {ASTNode} node THe node to check.
+	 * @param {ASTNode} node The node to check.
 	 * @returns {boolean} `true` if the node is a PropertyDefinition value,
 	 *      false if not.
 	 */
@@ -13801,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.
 	 */
@@ -13831,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,
@@ -13945,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}
@@ -14225,7 +14242,7 @@ function requireCodePathAnalyzer () {
 
 			case "SwitchCase":
 				/*
-				 * Fork if this node is after the 2st node in `cases`.
+				 * Fork if this node is after the 1st node in `cases`.
 				 * It's similar to `else` blocks.
 				 * The next `test` node is processed in this path.
 				 */
@@ -14344,10 +14361,13 @@ function requireCodePathAnalyzer () {
 			case "ImportExpression":
 			case "MemberExpression":
 			case "NewExpression":
-			case "YieldExpression":
 				state.makeFirstThrowablePathInTryBlock();
 				break;
 
+			case "YieldExpression":
+				state.makeYield();
+				break;
+
 			case "WhileStatement":
 			case "DoWhileStatement":
 			case "ForStatement":
@@ -14436,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.
 		 */
@@ -19283,15 +19303,16 @@ function requireFlatConfigSchema () {
 	}
 
 	/**
-	 * Validates that a given string is the form pluginName/objectName.
+	 * Validates that a given string matches the "pluginName/memberPlaceholder" pattern.
 	 * @param {string} value The string to check.
+	 * @param {string} memberPlaceholder The placeholder for the member portion of the expected format in the error message.
 	 * @returns {void}
-	 * @throws {TypeError} If the string isn't in the correct format.
+	 * @throws {TypeError} If the string doesn't match the expected pattern.
 	 */
-	function assertIsPluginMemberName(value) {
+	function assertIsPluginMemberName(value, memberPlaceholder) {
 		if (!/[\w\-@$]+(?:\/[\w\-$]+)+$/iu.test(value)) {
 			throw new TypeError(
-				`Expected string in the form "pluginName/objectName" but found "${value}".`,
+				`Expected string in the form "pluginName/${memberPlaceholder}" but found "${value}".`,
 			);
 		}
 	}
@@ -19434,7 +19455,9 @@ function requireFlatConfigSchema () {
 	/** @type {ObjectPropertySchema} */
 	const languageSchema = {
 		merge: "replace",
-		validate: assertIsPluginMemberName,
+		validate(value) {
+			assertIsPluginMemberName(value, "languageName");
+		},
 	};
 
 	/** @type {ObjectPropertySchema} */
@@ -19489,7 +19512,7 @@ function requireFlatConfigSchema () {
 		merge: "replace",
 		validate(value) {
 			if (typeof value === "string") {
-				assertIsPluginMemberName(value);
+				assertIsPluginMemberName(value, "processorName");
 			} else if (value && typeof value === "object") {
 				if (
 					typeof value.preprocess !== "function" ||
@@ -47402,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;
@@ -47498,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" ||
@@ -48986,6 +49040,7 @@ function requireAstUtils () {
 			isTopLevelExpressionStatement,
 			isDirective,
 			isStartOfExpressionStatement,
+			canContinueExpressionInClassBody,
 			needsPrecedingSemicolon,
 			isImportAttributeKey,
 			getOpeningParenOfParams,
@@ -73973,12 +74028,18 @@ function requireNoAsyncPromiseExecutor () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			return {
 				"NewExpression[callee.name='Promise'][arguments.0.async=true]"(
 					node,
 				) {
+					if (!sourceCode.isGlobalReference(node.callee)) {
+						return;
+					}
+
 					context.report({
-						node: context.sourceCode.getFirstToken(
+						node: sourceCode.getFirstToken(
 							node.arguments[0],
 							token => token.value === "async",
 						),
@@ -98974,7 +99035,7 @@ function requireNoShadow () {
 
 			/**
 			 * Checks the current context for shadowed variables.
-			 * @param {Scope} scope Fixme
+			 * @param {Scope} scope The scope to check for shadowed variables.
 			 * @returns {void}
 			 */
 			function checkForShadows(scope) {
@@ -103320,6 +103381,12 @@ function requireNoUnusedPrivateClassMembers () {
 	if (hasRequiredNoUnusedPrivateClassMembers) return noUnusedPrivateClassMembers;
 	hasRequiredNoUnusedPrivateClassMembers = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -103328,6 +103395,7 @@ function requireNoUnusedPrivateClassMembers () {
 	noUnusedPrivateClassMembers = {
 		meta: {
 			type: "problem",
+			hasSuggestions: true,
 
 			docs: {
 				description: "Disallow unused private class members",
@@ -103340,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
@@ -103401,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" ||
@@ -103443,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.
@@ -103514,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,
@@ -103526,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,
+												";",
+											);
+										}
+									},
+								},
+							],
 						});
 					}
 				},
@@ -107109,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
 	 */
@@ -107123,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
 	 */
@@ -107443,8 +107704,9 @@ function requireNoUselessConstructor () {
 									const nextToken =
 										sourceCode.getTokenAfter(node);
 									const addSemiColon =
-										nextToken.type === "Punctuator" &&
-										nextToken.value === "[" &&
+										astUtils.canContinueExpressionInClassBody(
+											nextToken,
+										) &&
 										astUtils.needsPrecedingSemicolon(
 											sourceCode,
 											node,
@@ -119661,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,