eslint 10.2.1 → 10.4.0

package/lib/rules/no-magic-numbers.js

@@ -91,11 +91,10 @@ function isAncestorTSIndexedAccessType(node) {
 module.exports = {
 	meta: {
 		type: "suggestion",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
 
 		docs: {
 			description: "Disallow magic numbers",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			frozen: true,
 			url: "https://eslint.org/docs/latest/rules/no-magic-numbers",
@@ -107,11 +106,9 @@ module.exports = {
 				properties: {
 					detectObjects: {
 						type: "boolean",
-						default: false,
 					},
 					enforceConst: {
 						type: "boolean",
-						default: false,
 					},
 					ignore: {
 						type: "array",
@@ -128,37 +125,45 @@ module.exports = {
 					},
 					ignoreArrayIndexes: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreDefaultValues: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreClassFieldInitialValues: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreEnums: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreNumericLiteralTypes: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreReadonlyClassProperties: {
 						type: "boolean",
-						default: false,
 					},
 					ignoreTypeIndexes: {
 						type: "boolean",
-						default: false,
 					},
 				},
 				additionalProperties: false,
 			},
 		],
 
+		defaultOptions: [
+			{
+				detectObjects: false,
+				enforceConst: false,
+				ignore: [],
+				ignoreArrayIndexes: false,
+				ignoreDefaultValues: false,
+				ignoreClassFieldInitialValues: false,
+				ignoreEnums: false,
+				ignoreNumericLiteralTypes: false,
+				ignoreReadonlyClassProperties: false,
+				ignoreTypeIndexes: false,
+			},
+		],
+
 		messages: {
 			useConst: "Number constants declarations must use 'const'.",
 			noMagic: "No magic number: {{raw}}.",
@@ -166,19 +171,19 @@ module.exports = {
 	},
 
 	create(context) {
-		const config = context.options[0] || {},
-			detectObjects = !!config.detectObjects,
-			enforceConst = !!config.enforceConst,
-			ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
-			ignoreArrayIndexes = !!config.ignoreArrayIndexes,
-			ignoreDefaultValues = !!config.ignoreDefaultValues,
-			ignoreClassFieldInitialValues =
-				!!config.ignoreClassFieldInitialValues,
-			ignoreEnums = !!config.ignoreEnums,
-			ignoreNumericLiteralTypes = !!config.ignoreNumericLiteralTypes,
-			ignoreReadonlyClassProperties =
-				!!config.ignoreReadonlyClassProperties,
-			ignoreTypeIndexes = !!config.ignoreTypeIndexes;
+		const {
+			detectObjects,
+			enforceConst,
+			ignore: rawIgnore,
+			ignoreArrayIndexes,
+			ignoreDefaultValues,
+			ignoreClassFieldInitialValues,
+			ignoreEnums,
+			ignoreNumericLiteralTypes,
+			ignoreReadonlyClassProperties,
+			ignoreTypeIndexes,
+		} = context.options[0];
+		const ignore = new Set(rawIgnore.map(normalizeIgnoreValue));
 
 		const okTypes = detectObjects
 			? []

package/lib/rules/no-restricted-exports.js

@@ -92,6 +92,8 @@ module.exports = {
 			},
 		],
 
+		defaultOptions: [{}],
+
 		messages: {
 			restrictedNamed:
 				"'{{name}}' is restricted from being used as an exported name.",
@@ -100,14 +102,12 @@ module.exports = {
 	},
 
 	create(context) {
-		const restrictedNames = new Set(
-			context.options[0] && context.options[0].restrictedNamedExports,
-		);
-		const restrictedNamePattern =
-			context.options[0] &&
-			context.options[0].restrictedNamedExportsPattern;
-		const restrictDefaultExports =
-			context.options[0] && context.options[0].restrictDefaultExports;
+		const {
+			restrictedNamedExports,
+			restrictedNamedExportsPattern: restrictedNamePattern,
+			restrictDefaultExports,
+		} = context.options[0];
+		const restrictedNames = new Set(restrictedNamedExports);
 		const sourceCode = context.sourceCode;
 
 		/**

package/lib/rules/no-restricted-globals.js

@@ -53,12 +53,11 @@ const arrayOfGlobals = {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
 		type: "suggestion",
 
 		docs: {
 			description: "Disallow specified global variables",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-restricted-globals",
 		},

package/lib/rules/no-restricted-imports.js

@@ -171,11 +171,10 @@ const arrayOfStringsOrObjectPatterns = {
 module.exports = {
 	meta: {
 		type: "suggestion",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
 
 		docs: {
 			description: "Disallow specified modules when loaded by `import`",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-restricted-imports",
 		},

package/lib/rules/no-restricted-properties.js

@@ -70,6 +70,8 @@ module.exports = {
 			uniqueItems: true,
 		},
 
+		defaultOptions: [],
+
 		messages: {
 			restrictedObjectProperty:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period

package/lib/rules/no-restricted-syntax.js

@@ -41,6 +41,8 @@ module.exports = {
 			minItems: 0,
 		},
 
+		defaultOptions: [],
+
 		messages: {
 			// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
 			restrictedSyntax: "{{message}}",

package/lib/rules/no-shadow.js

@@ -55,8 +55,6 @@ const ALLOWED_FUNCTION_VARIABLE_DEF_TYPES = new Set([
 module.exports = {
 	meta: {
 		type: "suggestion",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
 
 		defaultOptions: [
 			{
@@ -72,6 +70,7 @@ module.exports = {
 		docs: {
 			description:
 				"Disallow variable declarations from shadowing variables declared in the outer scope",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-shadow",
 		},

package/lib/rules/no-unassigned-vars.js

@@ -12,12 +12,11 @@
 module.exports = {
 	meta: {
 		type: "problem",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
 
 		docs: {
 			description:
 				"Disallow `let` or `var` variables that are read but never assigned",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/no-unassigned-vars",
 		},

package/lib/rules/no-unused-expressions.js

@@ -29,12 +29,11 @@ function alwaysFalse() {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
 		type: "suggestion",
 
 		docs: {
 			description: "Disallow unused expressions",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-unused-expressions",
 		},

package/lib/rules/no-unused-private-class-members.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -13,6 +19,7 @@
 module.exports = {
 	meta: {
 		type: "problem",
+		hasSuggestions: true,
 
 		docs: {
 			description: "Disallow unused private class members",
@@ -25,12 +32,168 @@ module.exports = {
 		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
@@ -86,6 +249,7 @@ module.exports = {
 						if (bodyMember.key.type === "PrivateIdentifier") {
 							privateMembers.set(bodyMember.key.name, {
 								declaredNode: bodyMember,
+								hasReference: false,
 								isAccessor:
 									bodyMember.type === "MethodDefinition" &&
 									(bodyMember.kind === "set" ||
@@ -128,6 +292,8 @@ module.exports = {
 					return;
 				}
 
+				memberDefinition.hasReference = true;
+
 				/*
 				 * Any usage of an accessor is considered a read, as the getter/setter can have
 				 * side-effects in its definition.
@@ -199,11 +365,12 @@ module.exports = {
 
 				for (const [
 					classMemberName,
-					{ declaredNode, isUsed },
+					{ declaredNode, hasReference, isUsed },
 				] of unusedPrivateMembers.entries()) {
 					if (isUsed) {
 						continue;
 					}
+
 					context.report({
 						node: declaredNode,
 						loc: declaredNode.key.loc,
@@ -211,6 +378,39 @@ module.exports = {
 						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,
+											";",
+										);
+									}
+								},
+							},
+						],
 					});
 				}
 			},

package/lib/rules/no-unused-vars.js

@@ -42,6 +42,20 @@ const astUtils = require("./utils/ast-utils");
  * @property {string} additional Any additional info to be appended at the end.
  */
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_OPTIONS = {
+	vars: "all",
+	args: "after-used",
+	ignoreRestSiblings: false,
+	caughtErrors: "all",
+	ignoreClassWithStaticInitBlock: false,
+	ignoreUsingDeclarations: false,
+	reportUsedIgnorePattern: false,
+};
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -108,6 +122,8 @@ module.exports = {
 			},
 		],
 
+		defaultOptions: [DEFAULT_OPTIONS],
+
 		messages: {
 			unusedVar:
 				"'{{varName}}' is {{action}} but never used{{additional}}.",
@@ -123,65 +139,46 @@ module.exports = {
 		const REST_PROPERTY_TYPE =
 			/^(?:RestElement|(?:Experimental)?RestProperty)$/u;
 
-		const config = {
-			vars: "all",
-			args: "after-used",
-			ignoreRestSiblings: false,
-			caughtErrors: "all",
-			ignoreClassWithStaticInitBlock: false,
-			ignoreUsingDeclarations: false,
-			reportUsedIgnorePattern: false,
-		};
+		let config;
 
 		const firstOption = context.options[0];
 
-		if (firstOption) {
-			if (typeof firstOption === "string") {
-				config.vars = firstOption;
-			} else {
-				config.vars = firstOption.vars || config.vars;
-				config.args = firstOption.args || config.args;
-				config.ignoreRestSiblings =
-					firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
-				config.caughtErrors =
-					firstOption.caughtErrors || config.caughtErrors;
-				config.ignoreClassWithStaticInitBlock =
-					firstOption.ignoreClassWithStaticInitBlock ||
-					config.ignoreClassWithStaticInitBlock;
-				config.ignoreUsingDeclarations =
-					firstOption.ignoreUsingDeclarations ||
-					config.ignoreUsingDeclarations;
-				config.reportUsedIgnorePattern =
-					firstOption.reportUsedIgnorePattern ||
-					config.reportUsedIgnorePattern;
-
-				if (firstOption.varsIgnorePattern) {
-					config.varsIgnorePattern = new RegExp(
-						firstOption.varsIgnorePattern,
-						"u",
-					);
-				}
+		if (typeof firstOption === "string") {
+			config = {
+				...DEFAULT_OPTIONS,
+				vars: firstOption,
+			};
+		} else {
+			config = {
+				...firstOption,
+			};
 
-				if (firstOption.argsIgnorePattern) {
-					config.argsIgnorePattern = new RegExp(
-						firstOption.argsIgnorePattern,
-						"u",
-					);
-				}
+			if (firstOption.varsIgnorePattern) {
+				config.varsIgnorePattern = new RegExp(
+					firstOption.varsIgnorePattern,
+					"u",
+				);
+			}
 
-				if (firstOption.caughtErrorsIgnorePattern) {
-					config.caughtErrorsIgnorePattern = new RegExp(
-						firstOption.caughtErrorsIgnorePattern,
-						"u",
-					);
-				}
+			if (firstOption.argsIgnorePattern) {
+				config.argsIgnorePattern = new RegExp(
+					firstOption.argsIgnorePattern,
+					"u",
+				);
+			}
 
-				if (firstOption.destructuredArrayIgnorePattern) {
-					config.destructuredArrayIgnorePattern = new RegExp(
-						firstOption.destructuredArrayIgnorePattern,
-						"u",
-					);
-				}
+			if (firstOption.caughtErrorsIgnorePattern) {
+				config.caughtErrorsIgnorePattern = new RegExp(
+					firstOption.caughtErrorsIgnorePattern,
+					"u",
+				);
+			}
+
+			if (firstOption.destructuredArrayIgnorePattern) {
+				config.destructuredArrayIgnorePattern = new RegExp(
+					firstOption.destructuredArrayIgnorePattern,
+					"u",
+				);
 			}
 		}
 

package/lib/rules/no-use-before-define.js

@@ -276,13 +276,12 @@ function isClassRefInClassDecorator(variable, reference) {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
 		type: "problem",
 
 		docs: {
 			description:
 				"Disallow the use of variables before they are defined",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-use-before-define",
 		},

package/lib/rules/no-useless-concat.js

@@ -33,7 +33,7 @@ function isConcatOperatorToken(token) {
 }
 
 /**
- * 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
  */
@@ -47,7 +47,7 @@ function getLeft(node) {
 }
 
 /**
- * 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
  */

package/lib/rules/no-useless-constructor.js

@@ -164,12 +164,11 @@ function isRedundantSuperCall(body, ctorParams) {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
 		type: "suggestion",
 
 		docs: {
 			description: "Disallow unnecessary constructors",
+			dialects: ["JavaScript", "TypeScript"],
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/no-useless-constructor",
 		},
@@ -237,8 +236,9 @@ module.exports = {
 								const nextToken =
 									sourceCode.getTokenAfter(node);
 								const addSemiColon =
-									nextToken.type === "Punctuator" &&
-									nextToken.value === "[" &&
+									astUtils.canContinueExpressionInClassBody(
+										nextToken,
+									) &&
 									astUtils.needsPrecedingSemicolon(
 										sourceCode,
 										node,