eslint 10.0.0-alpha.0 → 10.0.0-beta.0

package/lib/rule-tester/rule-tester.js

@@ -387,9 +387,10 @@ function normalizeTestCase(item) {
  * Asserts that the `errors` property of an invalid test case is valid.
  * @param {number | string[]} errors The `errors` property of the invalid test case.
  * @param {string} ruleName The name of the rule being tested.
+ * @param {Object} [assertionOptions] The assertion options for the test case.
  * @returns {void}
  */
-function assertErrorsProperty(errors, ruleName) {
+function assertErrorsProperty(errors, ruleName, assertionOptions = {}) {
 	const isNumber = typeof errors === "number";
 	const isArray = Array.isArray(errors);
 
@@ -407,12 +408,75 @@ function assertErrorsProperty(errors, ruleName) {
 		}
 	}
 
+	const { requireMessage = false, requireLocation = false } =
+		assertionOptions;
+
 	if (isArray) {
 		assert.ok(
 			errors.length !== 0,
 			"Invalid cases must have at least one error",
 		);
+
+		for (const [number, error] of errors.entries()) {
+			if (typeof error === "string" || error instanceof RegExp) {
+				// Just an error message.
+				assert.ok(
+					requireMessage !== "messageId" && !requireLocation,
+					`errors[${number}] should be an object when 'assertionOptions.requireMessage' is 'messageId' or 'assertionOptions.requireLocation' is true.`,
+				);
+			} else if (typeof error === "object" && error !== null) {
+				/*
+				 * Error object.
+				 * This may have a message, messageId, data, line, and/or column.
+				 */
+
+				for (const propertyName of Object.keys(error)) {
+					assert.ok(
+						errorObjectParameters.has(propertyName),
+						`Invalid error property name '${propertyName}'. Expected one of ${friendlyErrorObjectParameterList}.`,
+					);
+				}
+
+				if (requireMessage === "message") {
+					assert.ok(
+						!hasOwnProperty(error, "messageId") &&
+							hasOwnProperty(error, "message"),
+						`errors[${number}] should specify 'message' (and not 'messageId') when 'assertionOptions.requireMessage' is 'message'.`,
+					);
+				} else if (requireMessage === "messageId") {
+					assert.ok(
+						!hasOwnProperty(error, "message") &&
+							hasOwnProperty(error, "messageId"),
+						`errors[${number}] should specify 'messageId' (and not 'message') when 'assertionOptions.requireMessage' is 'messageId'.`,
+					);
+				}
+
+				if (hasOwnProperty(error, "message")) {
+					assert.ok(
+						!hasOwnProperty(error, "messageId"),
+						`errors[${number}] should not specify both 'message' and 'messageId'.`,
+					);
+					assert.ok(
+						!hasOwnProperty(error, "data"),
+						`errors[${number}] should not specify both 'data' and 'message'.`,
+					);
+				} else {
+					assert.ok(
+						hasOwnProperty(error, "messageId"),
+						`errors[${number}] must specify either 'messageId' or 'message'.`,
+					);
+				}
+			} else {
+				assert.fail(
+					`errors[${number}] must be a string, RegExp, or an object.`,
+				);
+			}
+		}
 	} else {
+		assert.ok(
+			!requireMessage && !requireLocation,
+			"Invalid cases must have 'errors' value as an array",
+		);
 		assert.ok(
 			errors > 0,
 			"Invalid cases must have 'error' value greater than 0",
@@ -543,6 +607,16 @@ function assertTestCommonProperties(item) {
  * @throws {AssertionError} If the test case is not valid.
  */
 function assertValidTestCase(item, seenTestCases) {
+	// must not have properties of invalid test cases
+	assert.ok(
+		item.errors === void 0,
+		"Valid test case must not have 'errors' property",
+	);
+	assert.ok(
+		item.output === void 0,
+		"Valid test case must not have 'output' property",
+	);
+
 	assertTestCommonProperties(item);
 	checkDuplicateTestCase(item, seenTestCases);
 }
@@ -554,13 +628,19 @@ function assertValidTestCase(item, seenTestCases) {
  * @param {Object} item The invalid test case object to check.
  * @param {Set<string>} seenTestCases Set of serialized test cases to check for duplicates.
  * @param {string} ruleName The name of the rule being tested.
+ * @param {Object} [assertionOptions] The assertion options for the test case.
  * @returns {void}
  * @throws {AssertionError} If the test case is not valid.
  */
-function assertInvalidTestCase(item, seenTestCases, ruleName) {
+function assertInvalidTestCase(
+	item,
+	seenTestCases,
+	ruleName,
+	assertionOptions = {},
+) {
 	assertTestCommonProperties(item);
 
-	assertErrorsProperty(item.errors, ruleName);
+	assertErrorsProperty(item.errors, ruleName, assertionOptions);
 
 	// 'output' is optional, but if it exists it must be a string or null
 	if (hasOwnProperty(item, "output")) {
@@ -753,6 +833,10 @@ class RuleTester {
 	 * @param {string} ruleName The name of the rule to run.
 	 * @param {RuleDefinition} rule The rule to test.
 	 * @param {{
+	 *   assertionOptions?: {
+	 *     requireMessage?: boolean | "message" | "messageId",
+	 *     requireLocation?: boolean
+	 *   },
 	 *   valid: (ValidTestCase | string)[],
 	 *   invalid: InvalidTestCase[]
 	 * }} test The collection of tests to run.
@@ -1133,6 +1217,9 @@ class RuleTester {
 		 * @private
 		 */
 		function testInvalidTemplate(item) {
+			const { requireMessage = false, requireLocation = false } =
+				test.assertionOptions ?? {};
+
 			const ruleHasMetaMessages =
 				hasOwnProperty(rule, "meta") &&
 				hasOwnProperty(rule.meta, "messages");
@@ -1142,6 +1229,11 @@ class RuleTester {
 						.join(", ")}]`
 				: null;
 
+			assert.ok(
+				ruleHasMetaMessages || requireMessage !== "messageId",
+				`Assertion options can not use 'requireMessage: "messageId"' if rule under test doesn't define 'meta.messages'.`,
+			);
+
 			const result = runRuleForItem(item);
 			const messages = result.messages;
 
@@ -1215,22 +1307,7 @@ class RuleTester {
 						 * This may have a message, messageId, data, line, and/or column.
 						 */
 
-						Object.keys(error).forEach(propertyName => {
-							assert.ok(
-								errorObjectParameters.has(propertyName),
-								`Invalid error property name '${propertyName}'. Expected one of ${friendlyErrorObjectParameterList}.`,
-							);
-						});
-
 						if (hasOwnProperty(error, "message")) {
-							assert.ok(
-								!hasOwnProperty(error, "messageId"),
-								"Error should not specify both 'message' and a 'messageId'.",
-							);
-							assert.ok(
-								!hasOwnProperty(error, "data"),
-								"Error should not specify both 'data' and 'message'.",
-							);
 							assertMessageMatches(
 								message.message,
 								error.message,
@@ -1288,33 +1365,34 @@ class RuleTester {
 									`Hydrated message "${rehydratedMessage}" does not match "${message.message}"`,
 								);
 							}
-						} else {
-							assert.fail(
-								"Test error must specify either a 'messageId' or 'message'.",
-							);
 						}
 
+						const locationProperties = [
+							"line",
+							"column",
+							"endLine",
+							"endColumn",
+						];
 						const actualLocation = {};
 						const expectedLocation = {};
 
-						if (hasOwnProperty(error, "line")) {
-							actualLocation.line = message.line;
-							expectedLocation.line = error.line;
-						}
-
-						if (hasOwnProperty(error, "column")) {
-							actualLocation.column = message.column;
-							expectedLocation.column = error.column;
-						}
-
-						if (hasOwnProperty(error, "endLine")) {
-							actualLocation.endLine = message.endLine;
-							expectedLocation.endLine = error.endLine;
+						for (const key of locationProperties) {
+							if (hasOwnProperty(error, key)) {
+								actualLocation[key] = message[key];
+								expectedLocation[key] = error[key];
+							}
 						}
 
-						if (hasOwnProperty(error, "endColumn")) {
-							actualLocation.endColumn = message.endColumn;
-							expectedLocation.endColumn = error.endColumn;
+						if (requireLocation) {
+							const missingKeys = locationProperties.filter(
+								key =>
+									!hasOwnProperty(error, key) &&
+									hasOwnProperty(message, key),
+							);
+							assert.ok(
+								missingKeys.length === 0,
+								`Error is missing expected location properties: ${missingKeys.join(", ")}`,
+							);
 						}
 
 						if (Object.keys(expectedLocation).length > 0) {
@@ -1540,11 +1618,6 @@ class RuleTester {
 								}
 							}
 						}
-					} else {
-						// Message was an unexpected type
-						assert.fail(
-							`Error should be a string, object, or RegExp, but found (${util.inspect(message)})`,
-						);
 					}
 				}
 			}
@@ -1621,6 +1694,7 @@ class RuleTester {
 										item,
 										seenTestCases,
 										ruleName,
+										test.assertionOptions,
 									);
 									testInvalidTemplate(item);
 								} finally {

package/lib/rules/array-bracket-spacing.js

@@ -258,13 +258,13 @@ module.exports = {
 			if (astUtils.isTokenOnSameLine(first, second)) {
 				if (
 					openingBracketMustBeSpaced &&
-					!sourceCode.isSpaceBetweenTokens(first, second)
+					!sourceCode.isSpaceBetween(first, second)
 				) {
 					reportRequiredBeginningSpace(node, first);
 				}
 				if (
 					!openingBracketMustBeSpaced &&
-					sourceCode.isSpaceBetweenTokens(first, second)
+					sourceCode.isSpaceBetween(first, second)
 				) {
 					reportNoBeginningSpace(node, first);
 				}
@@ -276,13 +276,13 @@ module.exports = {
 			) {
 				if (
 					closingBracketMustBeSpaced &&
-					!sourceCode.isSpaceBetweenTokens(penultimate, last)
+					!sourceCode.isSpaceBetween(penultimate, last)
 				) {
 					reportRequiredEndingSpace(node, last);
 				}
 				if (
 					!closingBracketMustBeSpaced &&
-					sourceCode.isSpaceBetweenTokens(penultimate, last)
+					sourceCode.isSpaceBetween(penultimate, last)
 				) {
 					reportNoEndingSpace(node, last);
 				}

package/lib/rules/block-spacing.js

@@ -95,7 +95,7 @@ module.exports = {
 		function isValid(left, right) {
 			return (
 				!util.isTokenOnSameLine(left, right) ||
-				sourceCode.isSpaceBetweenTokens(left, right) === always
+				sourceCode.isSpaceBetween(left, right) === always
 			);
 		}
 

package/lib/rules/comma-spacing.js

@@ -178,10 +178,7 @@ module.exports = {
 						!commaTokensToIgnore.includes(token) &&
 						astUtils.isTokenOnSameLine(previousToken, token) &&
 						options.before !==
-							sourceCode.isSpaceBetweenTokens(
-								previousToken,
-								token,
-							)
+							sourceCode.isSpaceBetween(previousToken, token)
 					) {
 						report(token, "before", previousToken);
 					}
@@ -195,7 +192,7 @@ module.exports = {
 						!(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
 						astUtils.isTokenOnSameLine(token, nextToken) &&
 						options.after !==
-							sourceCode.isSpaceBetweenTokens(token, nextToken)
+							sourceCode.isSpaceBetween(token, nextToken)
 					) {
 						report(token, "after", nextToken);
 					}

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/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-extra-parens.js

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

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

@@ -10,6 +10,30 @@
 
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Format import names for error messages.
+ * @param {string[]} importNames The import names to format.
+ * @returns {string} The formatted import names.
+ */
+function formatImportNames(importNames) {
+	return new Intl.ListFormat("en-US").format(
+		importNames.map(name => `'${name}'`),
+	);
+}
+
+/**
+ * Returns "is" or "are" based on the number of import names.
+ * @param {string[]} importNames The import names to check.
+ * @returns {string} "is" if one import name, otherwise "are".
+ */
+function isOrAre(importNames) {
+	return importNames.length === 1 ? "is" : "are";
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -175,22 +199,22 @@ module.exports = {
 				"'{{importName}}' import from '{{importSource}}' is restricted from being used by a pattern. {{customMessage}}",
 
 			patternAndEverything:
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted from being used by a pattern.",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern.",
 
 			patternAndEverythingWithRegexImportName:
 				"* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used.",
 			patternAndEverythingWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted from being used by a pattern. {{customMessage}}",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern. {{customMessage}}",
 			patternAndEverythingWithRegexImportNameAndCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
 				"* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used. {{customMessage}}",
 
 			everything:
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted.",
 			everythingWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted. {{customMessage}}",
+				"* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted. {{customMessage}}",
 
 			importName:
 				"'{{importName}}' import from '{{importSource}}' is restricted.",
@@ -199,16 +223,16 @@ module.exports = {
 				"'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}",
 
 			allowedImportName:
-				"'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed.",
+				"'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed.",
 			allowedImportNameWithCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed. {{customMessage}}",
+				"'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed. {{customMessage}}",
 
 			everythingWithAllowImportNames:
-				"* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed.",
+				"* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed.",
 			everythingWithAllowImportNamesAndCustomMessage:
 				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed. {{customMessage}}",
+				"* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed. {{customMessage}}",
 
 			allowedImportNamePattern:
 				"'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'.",
@@ -452,7 +476,10 @@ module.exports = {
 									loc: specifier.loc,
 									data: {
 										importSource,
-										importNames: restrictedImportNames,
+										importNames: formatImportNames(
+											restrictedImportNames,
+										),
+										isOrAre: isOrAre(restrictedImportNames),
 										customMessage,
 									},
 								});
@@ -465,7 +492,11 @@ module.exports = {
 									loc: specifier.loc,
 									data: {
 										importSource,
-										allowedImportNames,
+										allowedImportNames:
+											formatImportNames(
+												allowedImportNames,
+											),
+										isOrAre: isOrAre(allowedImportNames),
 										customMessage,
 									},
 								});
@@ -525,7 +556,11 @@ module.exports = {
 										importSource,
 										customMessage,
 										importName,
-										allowedImportNames,
+										allowedImportNames:
+											formatImportNames(
+												allowedImportNames,
+											),
+										isOrAre: isOrAre(allowedImportNames),
 									},
 								});
 							});
@@ -612,7 +647,10 @@ module.exports = {
 							loc: specifier.loc,
 							data: {
 								importSource,
-								importNames: restrictedImportNames,
+								importNames: formatImportNames(
+									restrictedImportNames,
+								),
+								isOrAre: isOrAre(restrictedImportNames),
 								customMessage,
 							},
 						});
@@ -625,7 +663,9 @@ module.exports = {
 							loc: specifier.loc,
 							data: {
 								importSource,
-								allowedImportNames,
+								allowedImportNames:
+									formatImportNames(allowedImportNames),
+								isOrAre: isOrAre(allowedImportNames),
 								customMessage,
 							},
 						});
@@ -713,7 +753,9 @@ module.exports = {
 								importSource,
 								customMessage,
 								importName,
-								allowedImportNames,
+								allowedImportNames:
+									formatImportNames(allowedImportNames),
+								isOrAre: isOrAre(allowedImportNames),
 							},
 						});
 					});

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-useless-assignment.js

@@ -336,9 +336,12 @@ module.exports = {
 				}
 
 				if (
-					targetAssignment.variable.references.some(
-						ref => ref.identifier.type !== "Identifier",
-					)
+					targetAssignment.variable.references.some(ref => {
+						const type = ref.identifier.type;
+						return (
+							type !== "Identifier" && type !== "JSXIdentifier"
+						);
+					})
 				) {
 					/**
 					 * Skip checking for a variable that has at least one non-identifier reference.
@@ -529,7 +532,7 @@ module.exports = {
 			TryStatement(node) {
 				scopeStack.tryStatementBlocks.push(node.block);
 			},
-			Identifier(node) {
+			"Identifier, JSXIdentifier"(node) {
 				for (const segment of scopeStack.currentSegments) {
 					const segmentInfo = scopeStack.segments[segment.id];
 
@@ -539,7 +542,7 @@ module.exports = {
 					segmentInfo.last = node;
 				}
 			},
-			":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(
+			"VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression:exit"(
 				node,
 			) {
 				if (scopeStack.currentSegments.size === 0) {

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);