eslint 9.39.1 → 10.0.0-alpha.1

package/lib/rules/computed-property-spacing.js

@@ -203,13 +203,13 @@ module.exports = {
 				if (astUtils.isTokenOnSameLine(before, first)) {
 					if (propertyNameMustBeSpaced) {
 						if (
-							!sourceCode.isSpaceBetweenTokens(before, first) &&
+							!sourceCode.isSpaceBetween(before, first) &&
 							astUtils.isTokenOnSameLine(before, first)
 						) {
 							reportRequiredBeginningSpace(node, before);
 						}
 					} else {
-						if (sourceCode.isSpaceBetweenTokens(before, first)) {
+						if (sourceCode.isSpaceBetween(before, first)) {
 							reportNoBeginningSpace(node, before, first);
 						}
 					}
@@ -218,13 +218,13 @@ module.exports = {
 				if (astUtils.isTokenOnSameLine(last, after)) {
 					if (propertyNameMustBeSpaced) {
 						if (
-							!sourceCode.isSpaceBetweenTokens(last, after) &&
+							!sourceCode.isSpaceBetween(last, after) &&
 							astUtils.isTokenOnSameLine(last, after)
 						) {
 							reportRequiredEndingSpace(node, after);
 						}
 					} else {
-						if (sourceCode.isSpaceBetweenTokens(last, after)) {
+						if (sourceCode.isSpaceBetween(last, after)) {
 							reportNoEndingSpace(node, after, last);
 						}
 					}

package/lib/rules/dot-notation.js

@@ -76,7 +76,7 @@ module.exports = {
 		/**
 		 * Check if the property is valid dot notation
 		 * @param {ASTNode} node The dot notation node
-		 * @param {string} value Value which is to be checked
+		 * @param {string|boolean|null} value Value which is to be checked
 		 * @returns {void}
 		 */
 		function checkComputedProperty(node, value) {
@@ -125,7 +125,7 @@ module.exports = {
 						}
 						yield fixer.replaceTextRange(
 							[leftBracket.range[0], rightBracket.range[1]],
-							value,
+							String(value),
 						);
 
 						// Insert a space after the property if it will be connected to the next token.

package/lib/rules/func-names.js

@@ -43,6 +43,7 @@ module.exports = {
 					enum: ["always", "as-needed", "never"],
 				},
 			},
+			type: "array",
 			items: [
 				{
 					$ref: "#/definitions/value",
@@ -57,6 +58,7 @@ module.exports = {
 					additionalProperties: false,
 				},
 			],
+			additionalItems: false,
 		},
 
 		messages: {

package/lib/rules/keyword-spacing.js

@@ -163,7 +163,7 @@ module.exports = {
 				!isOpenParenOfTemplate(prevToken) &&
 				!tokensToIgnore.has(prevToken) &&
 				astUtils.isTokenOnSameLine(prevToken, token) &&
-				!sourceCode.isSpaceBetweenTokens(prevToken, token)
+				!sourceCode.isSpaceBetween(prevToken, token)
 			) {
 				context.report({
 					loc: token.loc,
@@ -192,7 +192,7 @@ module.exports = {
 				!isOpenParenOfTemplate(prevToken) &&
 				!tokensToIgnore.has(prevToken) &&
 				astUtils.isTokenOnSameLine(prevToken, token) &&
-				sourceCode.isSpaceBetweenTokens(prevToken, token)
+				sourceCode.isSpaceBetween(prevToken, token)
 			) {
 				context.report({
 					loc: { start: prevToken.loc.end, end: token.loc.start },
@@ -224,7 +224,7 @@ module.exports = {
 				!isCloseParenOfTemplate(nextToken) &&
 				!tokensToIgnore.has(nextToken) &&
 				astUtils.isTokenOnSameLine(token, nextToken) &&
-				!sourceCode.isSpaceBetweenTokens(token, nextToken)
+				!sourceCode.isSpaceBetween(token, nextToken)
 			) {
 				context.report({
 					loc: token.loc,
@@ -253,7 +253,7 @@ module.exports = {
 				!isCloseParenOfTemplate(nextToken) &&
 				!tokensToIgnore.has(nextToken) &&
 				astUtils.isTokenOnSameLine(token, nextToken) &&
-				sourceCode.isSpaceBetweenTokens(token, nextToken)
+				sourceCode.isSpaceBetween(token, nextToken)
 			) {
 				context.report({
 					loc: { start: token.loc.end, end: nextToken.loc.start },

package/lib/rules/no-eval.js

@@ -65,7 +65,7 @@ module.exports = {
 		],
 
 		messages: {
-			unexpected: "eval can be harmful.",
+			unexpected: "`eval` can be harmful.",
 		},
 	},
 

package/lib/rules/no-extra-parens.js

@@ -470,7 +470,7 @@ module.exports = {
 			return (
 				rightParenToken &&
 				tokenAfterRightParen &&
-				!sourceCode.isSpaceBetweenTokens(
+				!sourceCode.isSpaceBetween(
 					rightParenToken,
 					tokenAfterRightParen,
 				) &&

package/lib/rules/no-invalid-regexp.js

@@ -40,6 +40,7 @@ module.exports = {
 						items: {
 							type: "string",
 						},
+						uniqueItems: true,
 					},
 				},
 				additionalProperties: false,

package/lib/rules/no-shadow-restricted-names.js

@@ -34,7 +34,7 @@ module.exports = {
 
 		defaultOptions: [
 			{
-				reportGlobalThis: false,
+				reportGlobalThis: true,
 			},
 		],
 

package/lib/rules/no-spaced-func.js

@@ -81,7 +81,7 @@ module.exports = {
 			if (
 				parenToken &&
 				parenToken.range[1] < node.range[1] &&
-				sourceCode.isSpaceBetweenTokens(prevToken, parenToken)
+				sourceCode.isSpaceBetween(prevToken, parenToken)
 			) {
 				context.report({
 					node,

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

@@ -18,7 +18,7 @@ module.exports = {
 		docs: {
 			description:
 				"Disallow `let` or `var` variables that are read but never assigned",
-			recommended: false,
+			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/no-unassigned-vars",
 		},
 

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

@@ -130,7 +130,7 @@ module.exports = {
 		docs: {
 			description:
 				"Disallow variable assignments when the value is not used",
-			recommended: false,
+			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/no-useless-assignment",
 		},
 

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

@@ -185,6 +185,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const { sourceCode } = context;
+
 		/**
 		 * Checks whether a node is a redundant constructor
 		 * @param {ASTNode} node node to check
@@ -211,6 +213,14 @@ module.exports = {
 			const body = node.value.body.body;
 			const ctorParams = node.value.params;
 			const superClass = node.parent.parent.superClass;
+			const parenToken = sourceCode.getFirstToken(
+				node,
+				astUtils.isOpeningParenToken,
+			);
+			const loc = {
+				start: node.loc.start,
+				end: sourceCode.getTokenBefore(parenToken).loc.end,
+			};
 
 			if (
 				superClass
@@ -218,19 +228,19 @@ module.exports = {
 					: body.length === 0
 			) {
 				context.report({
-					node,
+					loc,
 					messageId: "noUselessConstructor",
 					suggest: [
 						{
 							messageId: "removeConstructor",
 							*fix(fixer) {
 								const nextToken =
-									context.sourceCode.getTokenAfter(node);
+									sourceCode.getTokenAfter(node);
 								const addSemiColon =
 									nextToken.type === "Punctuator" &&
 									nextToken.value === "[" &&
 									astUtils.needsPrecedingSemicolon(
-										context.sourceCode,
+										sourceCode,
 										node,
 									);
 

package/lib/rules/no-whitespace-before-property.js

@@ -141,7 +141,7 @@ module.exports = {
 					leftToken = sourceCode.getTokenBefore(rightToken, 1);
 				}
 
-				if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {
+				if (sourceCode.isSpaceBetween(leftToken, rightToken)) {
 					reportError(node, leftToken, rightToken);
 				}
 			},

package/lib/rules/object-curly-spacing.js

@@ -204,10 +204,7 @@ module.exports = {
 		 */
 		function validateBraceSpacing(node, first, second, penultimate, last) {
 			if (astUtils.isTokenOnSameLine(first, second)) {
-				const firstSpaced = sourceCode.isSpaceBetweenTokens(
-					first,
-					second,
-				);
+				const firstSpaced = sourceCode.isSpaceBetween(first, second);
 
 				if (options.spaced && !firstSpaced) {
 					reportRequiredBeginningSpace(node, first);
@@ -236,10 +233,7 @@ module.exports = {
 						? !options.spaced
 						: options.spaced;
 
-				const lastSpaced = sourceCode.isSpaceBetweenTokens(
-					penultimate,
-					last,
-				);
+				const lastSpaced = sourceCode.isSpaceBetween(penultimate, last);
 
 				if (closingCurlyBraceMustBeSpaced && !lastSpaced) {
 					reportRequiredEndingSpace(node, last);

package/lib/rules/preserve-caught-error.js

@@ -158,7 +158,7 @@ module.exports = {
 		docs: {
 			description:
 				"Disallow losing originally caught error when re-throwing custom errors",
-			recommended: false,
+			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/preserve-caught-error", // URL to the documentation page for this rule
 		},
 		/*

package/lib/rules/radix.js

@@ -15,9 +15,6 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const MODE_ALWAYS = "always",
-	MODE_AS_NEEDED = "as-needed";
-
 const validRadixValues = new Set(
 	Array.from({ length: 37 - 2 }, (_, index) => index + 2),
 );
@@ -63,15 +60,6 @@ function isValidRadix(radix) {
 	);
 }
 
-/**
- * Checks whether a given node is a default value of radix or not.
- * @param {ASTNode} radix A node of radix to check.
- * @returns {boolean} `true` if the node is the literal node of `10`.
- */
-function isDefaultRadix(radix) {
-	return radix.type === "Literal" && radix.value === 10;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -81,11 +69,9 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
-		defaultOptions: [MODE_ALWAYS],
-
 		docs: {
 			description:
-				"Enforce the consistent use of the radix argument when using `parseInt()`",
+				"Enforce the use of the radix argument when using `parseInt()`",
 			recommended: false,
 			url: "https://eslint.org/docs/latest/rules/radix",
 		},
@@ -93,6 +79,7 @@ module.exports = {
 		hasSuggestions: true,
 
 		schema: [
+			// deprecated
 			{
 				enum: ["always", "as-needed"],
 			},
@@ -100,7 +87,6 @@ module.exports = {
 
 		messages: {
 			missingParameters: "Missing parameters.",
-			redundantRadix: "Redundant radix parameter.",
 			missingRadix: "Missing radix parameter.",
 			invalidRadix:
 				"Invalid radix parameter, must be an integer between 2 and 36.",
@@ -110,7 +96,6 @@ module.exports = {
 	},
 
 	create(context) {
-		const [mode] = context.options;
 		const sourceCode = context.sourceCode;
 
 		/**
@@ -131,41 +116,33 @@ module.exports = {
 					break;
 
 				case 1:
-					if (mode === MODE_ALWAYS) {
-						context.report({
-							node,
-							messageId: "missingRadix",
-							suggest: [
-								{
-									messageId: "addRadixParameter10",
-									fix(fixer) {
-										const tokens =
-											sourceCode.getTokens(node);
-										const lastToken = tokens.at(-1); // Parenthesis.
-										const secondToLastToken = tokens.at(-2); // May or may not be a comma.
-										const hasTrailingComma =
-											secondToLastToken.type ===
-												"Punctuator" &&
-											secondToLastToken.value === ",";
-
-										return fixer.insertTextBefore(
-											lastToken,
-											hasTrailingComma ? " 10," : ", 10",
-										);
-									},
+					context.report({
+						node,
+						messageId: "missingRadix",
+						suggest: [
+							{
+								messageId: "addRadixParameter10",
+								fix(fixer) {
+									const tokens = sourceCode.getTokens(node);
+									const lastToken = tokens.at(-1); // Parenthesis.
+									const secondToLastToken = tokens.at(-2); // May or may not be a comma.
+									const hasTrailingComma =
+										secondToLastToken.type ===
+											"Punctuator" &&
+										secondToLastToken.value === ",";
+
+									return fixer.insertTextBefore(
+										lastToken,
+										hasTrailingComma ? " 10," : ", 10",
+									);
 								},
-							],
-						});
-					}
+							},
+						],
+					});
 					break;
 
 				default:
-					if (mode === MODE_AS_NEEDED && isDefaultRadix(args[1])) {
-						context.report({
-							node,
-							messageId: "redundantRadix",
-						});
-					} else if (!isValidRadix(args[1])) {
+					if (!isValidRadix(args[1])) {
 						context.report({
 							node,
 							messageId: "invalidRadix",

package/lib/rules/require-yield.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -29,6 +35,7 @@ module.exports = {
 
 	create(context) {
 		const stack = [];
+		const sourceCode = context.sourceCode;
 
 		/**
 		 * If the node is a generator function, start counting `yield` keywords.
@@ -55,7 +62,10 @@ module.exports = {
 			const countYield = stack.pop();
 
 			if (countYield === 0 && node.body.body.length > 0) {
-				context.report({ node, messageId: "missingYield" });
+				context.report({
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: "missingYield",
+				});
 			}
 		}
 

package/lib/rules/rest-spread-spacing.js

@@ -74,10 +74,7 @@ module.exports = {
 		function checkWhiteSpace(node) {
 			const operator = sourceCode.getFirstToken(node),
 				nextToken = sourceCode.getTokenAfter(operator),
-				hasWhitespace = sourceCode.isSpaceBetweenTokens(
-					operator,
-					nextToken,
-				);
+				hasWhitespace = sourceCode.isSpaceBetween(operator, nextToken);
 			let type;
 
 			switch (node.type) {

package/lib/rules/semi-spacing.js

@@ -95,7 +95,7 @@ module.exports = {
 			return (
 				tokenBefore &&
 				astUtils.isTokenOnSameLine(tokenBefore, token) &&
-				sourceCode.isSpaceBetweenTokens(tokenBefore, token)
+				sourceCode.isSpaceBetween(tokenBefore, token)
 			);
 		}
 
@@ -110,7 +110,7 @@ module.exports = {
 			return (
 				tokenAfter &&
 				astUtils.isTokenOnSameLine(token, tokenAfter) &&
-				sourceCode.isSpaceBetweenTokens(token, tokenAfter)
+				sourceCode.isSpaceBetween(token, tokenAfter)
 			);
 		}
 

package/lib/rules/space-before-blocks.js

@@ -164,7 +164,7 @@ module.exports = {
 				!isConflicted(precedingToken, node) &&
 				astUtils.isTokenOnSameLine(precedingToken, node)
 			) {
-				const hasSpace = sourceCode.isSpaceBetweenTokens(
+				const hasSpace = sourceCode.isSpaceBetween(
 					precedingToken,
 					node,
 				);

package/lib/rules/space-before-function-paren.js

@@ -155,10 +155,7 @@ module.exports = {
 				astUtils.isOpeningParenToken,
 			);
 			const leftToken = sourceCode.getTokenBefore(rightToken);
-			const hasSpacing = sourceCode.isSpaceBetweenTokens(
-				leftToken,
-				rightToken,
-			);
+			const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
 
 			if (hasSpacing && functionConfig === "never") {
 				context.report({

package/lib/rules/space-in-parens.js

@@ -153,7 +153,7 @@ module.exports = {
 		 */
 		function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
 			if (
-				sourceCode.isSpaceBetweenTokens(
+				sourceCode.isSpaceBetween(
 					openingParenToken,
 					tokenAfterOpeningParen,
 				)
@@ -195,7 +195,7 @@ module.exports = {
 			}
 
 			if (
-				!sourceCode.isSpaceBetweenTokens(
+				!sourceCode.isSpaceBetween(
 					openingParenToken,
 					tokenAfterOpeningParen,
 				)
@@ -220,7 +220,7 @@ module.exports = {
 			closingParenToken,
 		) {
 			if (
-				sourceCode.isSpaceBetweenTokens(
+				sourceCode.isSpaceBetween(
 					tokenBeforeClosingParen,
 					closingParenToken,
 				)
@@ -261,7 +261,7 @@ module.exports = {
 			}
 
 			if (
-				!sourceCode.isSpaceBetweenTokens(
+				!sourceCode.isSpaceBetween(
 					tokenBeforeClosingParen,
 					closingParenToken,
 				)

package/lib/rules/space-infix-ops.js

@@ -87,8 +87,8 @@ module.exports = {
 			const next = sourceCode.getTokenAfter(operator);
 
 			if (
-				!sourceCode.isSpaceBetweenTokens(prev, operator) ||
-				!sourceCode.isSpaceBetweenTokens(operator, next)
+				!sourceCode.isSpaceBetween(prev, operator) ||
+				!sourceCode.isSpaceBetween(operator, next)
 			) {
 				return operator;
 			}
@@ -238,11 +238,8 @@ module.exports = {
 				const rightToken = sourceCode.getTokenAfter(operatorToken);
 
 				if (
-					!sourceCode.isSpaceBetweenTokens(
-						leftToken,
-						operatorToken,
-					) ||
-					!sourceCode.isSpaceBetweenTokens(operatorToken, rightToken)
+					!sourceCode.isSpaceBetween(leftToken, operatorToken) ||
+					!sourceCode.isSpaceBetween(operatorToken, rightToken)
 				) {
 					report(node, operatorToken);
 				}

package/lib/rules/switch-colon-spacing.js

@@ -84,7 +84,7 @@ module.exports = {
 			return (
 				astUtils.isClosingBraceToken(right) ||
 				!astUtils.isTokenOnSameLine(left, right) ||
-				sourceCode.isSpaceBetweenTokens(left, right) === expected
+				sourceCode.isSpaceBetween(left, right) === expected
 			);
 		}
 

package/lib/rules/template-tag-spacing.js

@@ -66,7 +66,7 @@ module.exports = {
 		function checkSpacing(node) {
 			const tagToken = sourceCode.getTokenBefore(node.quasi);
 			const literalToken = sourceCode.getFirstToken(node.quasi);
-			const hasWhitespace = sourceCode.isSpaceBetweenTokens(
+			const hasWhitespace = sourceCode.isSpaceBetween(
 				tagToken,
 				literalToken,
 			);