Remove use of node.{range,loc} (#2790)

fisker · web-flow · commit 9aca7b9a73d9 · 2025-10-24T17:06:25.000+08:00
diff --git a/eslint.dogfooding.config.js b/eslint.dogfooding.config.js
@@ -10,7 +10,6 @@ const config = [
 		// If external rules needs to be disabled, add the rule name here.
 		'n/no-unsupported-features/es-syntax',
 		'eslint-plugin/require-meta-default-options',
-		'internal/no-restricted-property-access',
 		'@stylistic/max-len',
 	]),
 	{
diff --git a/rules/catch-error-name.js b/rules/catch-error-name.js
@@ -95,7 +95,7 @@ const create = context => {
 			};
 
 			if (fixedName) {
-				problem.fix = fixer => renameVariable(variable, fixedName, fixer);
+				problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);
 			}
 
 			return problem;
diff --git a/rules/escape-case.js b/rules/escape-case.js
@@ -56,7 +56,7 @@ const create = context => {
 			node,
 			original: node.value.raw,
 			lowercase,
-			fix: (fixer, fixed) => replaceTemplateElement(fixer, node, fixed),
+			fix: (fixer, fixed) => replaceTemplateElement(node, fixed, context, fixer),
 		});
 	});
 };
diff --git a/rules/fix/rename-variable.js b/rules/fix/rename-variable.js
@@ -1,7 +1,8 @@
 import getVariableIdentifiers from '../utils/get-variable-identifiers.js';
 import replaceReferenceIdentifier from './replace-reference-identifier.js';
 
-const renameVariable = (variable, name, fixer) => getVariableIdentifiers(variable)
-	.map(identifier => replaceReferenceIdentifier(identifier, name, fixer));
+const renameVariable = (variable, name, context, fixer) =>
+	getVariableIdentifiers(variable)
+		.map(identifier => replaceReferenceIdentifier(identifier, name, context, fixer));
 
 export default renameVariable;
diff --git a/rules/fix/replace-reference-identifier.js b/rules/fix/replace-reference-identifier.js
@@ -3,27 +3,27 @@ import isShorthandPropertyAssignmentPatternLeft from '../utils/is-shorthand-prop
 import isShorthandImportLocal from '../utils/is-shorthand-import-local.js';
 import isShorthandExportLocal from '../utils/is-shorthand-export-local.js';
 
-export default function replaceReferenceIdentifier(identifier, replacement, fixer) {
+export default function replaceReferenceIdentifier(identifier, replacement, context, fixer) {
 	if (
 		isShorthandPropertyValue(identifier)
 		|| isShorthandPropertyAssignmentPatternLeft(identifier)
 	) {
 		return fixer.replaceText(identifier, `${identifier.name}: ${replacement}`);
 	}
 
-	if (isShorthandImportLocal(identifier)) {
+	if (isShorthandImportLocal(identifier, context)) {
 		return fixer.replaceText(identifier, `${identifier.name} as ${replacement}`);
 	}
 
-	if (isShorthandExportLocal(identifier)) {
+	if (isShorthandExportLocal(identifier, context)) {
 		return fixer.replaceText(identifier, `${replacement} as ${identifier.name}`);
 	}
 
 	// `typeAnnotation`
 	if (identifier.typeAnnotation) {
+		const {sourceCode} = context;
 		return fixer.replaceTextRange(
-			// eslint-disable-next-line internal/no-restricted-property-access
-			[identifier.range[0], identifier.typeAnnotation.range[0]],
+			[sourceCode.getRange(identifier)[0], sourceCode.getRange(identifier.typeAnnotation)[0]],
 			`${replacement}${identifier.optional ? '?' : ''}`,
 		);
 	}
diff --git a/rules/fix/replace-string-raw.js b/rules/fix/replace-string-raw.js
@@ -1,12 +1,10 @@
 // Replace `StringLiteral` or `TemplateLiteral` node with raw text
-const replaceStringRaw = (fixer, node, raw) =>
+const replaceStringRaw = (node, raw, context, fixer) =>
 	fixer.replaceTextRange(
 		// Ignore quotes and backticks
 		[
-			// eslint-disable-next-line internal/no-restricted-property-access
-			node.range[0] + 1,
-			// eslint-disable-next-line internal/no-restricted-property-access
-			node.range[1] - 1,
+			context.sourceCode.getRange(node)[0] + 1,
+			context.sourceCode.getRange(node)[1] - 1,
 		],
 		raw,
 	);
diff --git a/rules/fix/replace-template-element.js b/rules/fix/replace-template-element.js
@@ -1,6 +1,6 @@
-const replaceTemplateElement = (fixer, node, replacement) => {
-	// eslint-disable-next-line internal/no-restricted-property-access
-	const {range: [start, end], tail} = node;
+const replaceTemplateElement = (node, replacement, context, fixer) => {
+	const {tail} = node;
+	const [start, end] = context.sourceCode.getRange(node);
 	return fixer.replaceTextRange(
 		[start + 1, end - (tail ? 1 : 2)],
 		replacement,
diff --git a/rules/fix/switch-new-expression-to-call-expression.js b/rules/fix/switch-new-expression-to-call-expression.js
@@ -34,7 +34,7 @@ export default function * switchNewExpressionToCallExpression(newExpression, con
 			}
 		```
 	*/
-	if (!isOnSameLine(newToken, newExpression.callee) && !isParenthesized(newExpression, context.sourceCode)) {
+	if (!isOnSameLine(newToken, newExpression.callee, context) && !isParenthesized(newExpression, context.sourceCode)) {
 		// Ideally, we should use first parenthesis of the `callee`, and should check spaces after the `new` token
 		// But adding extra parentheses is harmless, no need to be too complicated
 		yield * addParenthesizesToReturnOrThrowExpression(fixer, newExpression.parent, context);
diff --git a/rules/no-hex-escape.js b/rules/no-hex-escape.js
@@ -15,7 +15,7 @@ function checkEscape(context, node, value) {
 			messageId: MESSAGE_ID,
 			fix: fixer =>
 				node.type === 'TemplateElement'
-					? replaceTemplateElement(fixer, node, fixedValue)
+					? replaceTemplateElement(node, fixedValue, context, fixer)
 					: fixer.replaceText(node, fixedValue),
 		};
 	}
diff --git a/rules/no-negated-condition.js b/rules/no-negated-condition.js
@@ -111,7 +111,7 @@ const create = context => {
 				if (
 					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 					&& parent.argument === node
-					&& !isOnSameLine(firstToken, secondToken)
+					&& !isOnSameLine(firstToken, secondToken, context)
 					&& !isParenthesized(node, sourceCode)
 					&& !isParenthesized(test, sourceCode)
 				) {
diff --git a/rules/no-negation-in-equality-check.js b/rules/no-negation-in-equality-check.js
@@ -57,7 +57,7 @@ const create = context => ({
 							&& !isParenthesized(binaryExpression, sourceCode)
 						) {
 							const returnToken = sourceCode.getFirstToken(parent);
-							if (!isOnSameLine(returnToken, tokenAfterBang)) {
+							if (!isOnSameLine(returnToken, tokenAfterBang, context)) {
 								yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
 							}
 						}
diff --git a/rules/no-typeof-undefined.js b/rules/no-typeof-undefined.js
@@ -77,7 +77,7 @@ const create = context => {
 				if (
 					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 					&& parent.argument === binaryExpression
-					&& !isOnSameLine(typeofToken, secondToken)
+					&& !isOnSameLine(typeofToken, secondToken, context)
 					&& !isParenthesized(binaryExpression, sourceCode)
 					&& !isParenthesized(typeofNode, sourceCode)
 				) {
diff --git a/rules/no-unnecessary-await.js b/rules/no-unnecessary-await.js
@@ -73,7 +73,7 @@ const create = context => ({
 			/** @param {import('eslint').Rule.RuleFixer} fixer */
 			* fix(fixer) {
 				if (
-					!isOnSameLine(awaitToken, valueNode)
+					!isOnSameLine(awaitToken, valueNode, context)
 					&& !isParenthesized(node, sourceCode)
 				) {
 					yield * addParenthesizesToReturnOrThrowExpression(fixer, node.parent, context);
diff --git a/rules/no-useless-spread.js b/rules/no-useless-spread.js
@@ -92,7 +92,7 @@ function * unwrapSingleArraySpread(fixer, arrayExpression, context) {
 	if (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === arrayExpression
-		&& !isOnSameLine(openingBracketToken, thirdToken)
+		&& !isOnSameLine(openingBracketToken, thirdToken, context)
 		&& !isParenthesized(arrayExpression, sourceCode)
 	) {
 		yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
diff --git a/rules/prefer-array-find.js b/rules/prefer-array-find.js
@@ -320,7 +320,7 @@ const create = context => {
 				if (singularName) {
 					// Rename variable to be singularized now that it refers to a single item in the array instead of the entire array.
 					const singularizedName = getAvailableVariableName(singularName, getScopes(scope));
-					yield * renameVariable(variable, singularizedName, fixer);
+					yield * renameVariable(variable, singularizedName, context, fixer);
 
 					// Prevent possible variable conflicts
 					yield * extendFixRange(fixer, sourceCode.getRange(sourceCode.ast));
diff --git a/rules/prefer-module.js b/rules/prefer-module.js
@@ -307,7 +307,7 @@ function create(context) {
 				problem.suggest = suggestions.get(node.name)
 					.map(({messageId, replacement}) => ({
 						messageId,
-						fix: fixer => replaceReferenceIdentifier(node, replacement, fixer),
+						fix: fixer => replaceReferenceIdentifier(node, replacement, context, fixer),
 					}));
 
 				return problem;
diff --git a/rules/prefer-number-properties.js b/rules/prefer-number-properties.js
@@ -54,7 +54,7 @@ function checkProperty({node, path: [name]}, context) {
 		return problem;
 	}
 
-	const fix = fixer => replaceReferenceIdentifier(node, `Number.${property}`, fixer);
+	const fix = fixer => replaceReferenceIdentifier(node, `Number.${property}`, context, fixer);
 	const isSafeToFix = globalObjects[name];
 
 	if (isSafeToFix) {
diff --git a/rules/prefer-string-raw.js b/rules/prefer-string-raw.js
@@ -125,7 +125,7 @@ const create = context => {
 						continue;
 					}
 
-					yield replaceTemplateElement(fixer, quasis, cooked);
+					yield replaceTemplateElement(quasis, cooked, context, fixer);
 				}
 			},
 		};
diff --git a/rules/prefer-switch.js b/rules/prefer-switch.js
@@ -97,12 +97,14 @@ const getBreakTarget = node => {
 	}
 };
 
-const isNodeInsideNode = (inner, outer) =>
-	// eslint-disable-next-line internal/no-restricted-property-access
-	inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
-function hasBreakInside(breakStatements, node) {
+const isNodeInsideNode = (inner, outer, context) => {
+	const {sourceCode} = context;
+	return sourceCode.getRange(inner)[0] >= sourceCode.getRange(outer)[0] && sourceCode.getRange(inner)[1] <= sourceCode.getRange(outer)[1];
+};
+
+function hasBreakInside(breakStatements, node, context) {
 	for (const breakStatement of breakStatements) {
-		if (!isNodeInsideNode(breakStatement, node)) {
+		if (!isNodeInsideNode(breakStatement, node, context)) {
 			continue;
 		}
 
@@ -112,7 +114,7 @@ function hasBreakInside(breakStatements, node) {
 			return true;
 		}
 
-		if (isNodeInsideNode(node, breakTarget)) {
+		if (isNodeInsideNode(node, breakTarget, context)) {
 			return true;
 		}
 	}
@@ -300,7 +302,7 @@ const create = context => {
 
 				if (
 					!hasSideEffect(discriminant, sourceCode)
-					&& !ifStatements.some(({statement}) => hasBreakInside(breakStatements, statement))
+					&& !ifStatements.some(({statement}) => hasBreakInside(breakStatements, statement, context))
 				) {
 					problem.fix = fix({discriminant, ifStatements}, context, options);
 				}
diff --git a/rules/prefer-ternary.js b/rules/prefer-ternary.js
@@ -34,8 +34,8 @@ function getNodeBody(node) {
 	return node;
 }
 
-// eslint-disable-next-line internal/no-restricted-property-access -- Need fix
-const isSingleLineNode = node => node.loc.start.line === node.loc.end.line;
+const isSingleLineNode = (node, context) =>
+	context.sourceCode.getLoc(node).start.line === context.sourceCode.getLoc(node).end.line;
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
@@ -184,7 +184,7 @@ const create = context => {
 
 			if (
 				onlySingleLine
-				&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node))
+				&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node, context))
 			) {
 				return;
 			}
diff --git a/rules/prevent-abbreviations.js b/rules/prevent-abbreviations.js
@@ -414,7 +414,7 @@ const create = context => {
 			}
 		}
 
-		if (isShorthandImportLocal(definition.name)) {
+		if (isShorthandImportLocal(definition.name, context)) {
 			if (!options.checkShorthandImports) {
 				return;
 			}
@@ -470,7 +470,7 @@ const create = context => {
 				generatedNames.add(replacement);
 			}
 
-			problem.fix = fixer => renameVariable(variable, replacement, fixer);
+			problem.fix = fixer => renameVariable(variable, replacement, context, fixer);
 		}
 
 		context.report(problem);
diff --git a/rules/string-content.js b/rules/string-content.js
@@ -112,9 +112,10 @@ const create = context => {
 				);
 			}
 			: fixer => replaceTemplateElement(
-				fixer,
 				node,
 				escapeTemplateElementRaw(fixed),
+				context,
+				fixer,
 			);
 
 		if (autoFix) {
diff --git a/rules/template-indent.js b/rules/template-indent.js
@@ -96,7 +96,7 @@ const create = context => {
 			messageId: MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE,
 			fix: fixer => fixed
 				.split(delimiter)
-				.map((replacement, index) => replaceTemplateElement(fixer, node.quasis[index], replacement)),
+				.map((replacement, index) => replaceTemplateElement(node.quasis[index], replacement, context, fixer)),
 		};
 	};
 
diff --git a/rules/text-encoding-identifier-case.js b/rules/text-encoding-identifier-case.js
@@ -69,7 +69,7 @@ const create = context => {
 		}
 
 		/** @param {import('eslint').Rule.RuleFixer} fixer */
-		const fix = fixer => replaceStringRaw(fixer, node, replacement);
+		const fix = fixer => replaceStringRaw(node, replacement, context, fixer);
 
 		const problem = {
 			node,
@@ -88,7 +88,7 @@ const create = context => {
 		problem.suggest = [
 			{
 				messageId: MESSAGE_ID_SUGGESTION,
-				fix: fixer => replaceStringRaw(fixer, node, replacement),
+				fix: fixer => replaceStringRaw(node, replacement, context, fixer),
 			},
 		];
 
diff --git a/rules/utils/has-same-range.js b/rules/utils/has-same-range.js
@@ -1,9 +1,7 @@
-const hasSameRange = (node1, node2) =>
+const hasSameRange = (node1, node2, context) =>
 	node1
 	&& node2
-	// eslint-disable-next-line internal/no-restricted-property-access
-	&& node1.range[0] === node2.range[0]
-	// eslint-disable-next-line internal/no-restricted-property-access
-	&& node1.range[1] === node2.range[1];
+	&& context.sourceCode.getRange(node1)[0] === context.sourceCode.getRange(node2)[0]
+	&& context.sourceCode.getRange(node1)[1] === context.sourceCode.getRange(node2)[1];
 
 export default hasSameRange;
diff --git a/rules/utils/is-on-same-line.js b/rules/utils/is-on-same-line.js
@@ -1,4 +1,7 @@
-export default function isOnSameLine(nodeOrTokenA, nodeOrTokenB) {
-	// eslint-disable-next-line internal/no-restricted-property-access -- Need fix
-	return nodeOrTokenA.loc.start.line === nodeOrTokenB.loc.start.line;
+export default function isOnSameLine(nodeOrTokenA, nodeOrTokenB, context) {
+	const [
+		lineA,
+		lineB,
+	] = [nodeOrTokenA, nodeOrTokenB].map(nodeOrToken => context.sourceCode.getLoc(nodeOrToken).start.line);
+	return lineA === lineB;
 }
diff --git a/rules/utils/is-shorthand-export-local.js b/rules/utils/is-shorthand-export-local.js
@@ -1,8 +1,8 @@
 import hasSameRange from './has-same-range.js';
 
-const isShorthandExportLocal = node => {
+const isShorthandExportLocal = (node, context) => {
 	const {type, local, exported} = node.parent;
-	return type === 'ExportSpecifier' && hasSameRange(local, exported) && local === node;
+	return type === 'ExportSpecifier' && hasSameRange(local, exported, context) && local === node;
 };
 
 export default isShorthandExportLocal;
diff --git a/rules/utils/is-shorthand-import-local.js b/rules/utils/is-shorthand-import-local.js
@@ -1,8 +1,8 @@
 import hasSameRange from './has-same-range.js';
 
-const isShorthandImportLocal = node => {
+const isShorthandImportLocal = (node, context) => {
 	const {type, local, imported} = node.parent;
-	return type === 'ImportSpecifier' && hasSameRange(local, imported) && local === node;
+	return type === 'ImportSpecifier' && hasSameRange(local, imported, context) && local === node;
 };
 
 export default isShorthandImportLocal;

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ const config = [`
`10`	`10`	`// If external rules needs to be disabled, add the rule name here.`
`11`	`11`	`'n/no-unsupported-features/es-syntax',`
`12`	`12`	`'eslint-plugin/require-meta-default-options',`
`13`		`- 'internal/no-restricted-property-access',`
`14`	`13`	`'@stylistic/max-len',`
`15`	`14`	`]),`
`16`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ const create = context => {`
`95`	`95`	`};`
`96`	`96`
`97`	`97`	`if (fixedName) {`
`98`		`- problem.fix = fixer => renameVariable(variable, fixedName, fixer);`
	`98`	`+ problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`return problem;`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ export default function * switchNewExpressionToCallExpression(newExpression, con`
`34`	`34`	`}`
`35`	`35`	```
`36`	`36`	`*/`
`37`		`- if (!isOnSameLine(newToken, newExpression.callee) && !isParenthesized(newExpression, context.sourceCode)) {`
	`37`	`+ if (!isOnSameLine(newToken, newExpression.callee, context) && !isParenthesized(newExpression, context.sourceCode)) {`
`38`	`38`	// Ideally, we should use first parenthesis of the `callee`, and should check spaces after the `new` token
`39`	`39`	`// But adding extra parentheses is harmless, no need to be too complicated`
`40`	`40`	`yield * addParenthesizesToReturnOrThrowExpression(fixer, newExpression.parent, context);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ function checkEscape(context, node, value) {`
`15`	`15`	`messageId: MESSAGE_ID,`
`16`	`16`	`fix: fixer =>`
`17`	`17`	`node.type === 'TemplateElement'`
`18`		`- ? replaceTemplateElement(fixer, node, fixedValue)`
	`18`	`+ ? replaceTemplateElement(node, fixedValue, context, fixer)`
`19`	`19`	`: fixer.replaceText(node, fixedValue),`
`20`	`20`	`};`
`21`	`21`	`}`