oxlint-plugin-react-doctor 0.7.6-dev.1f14fa1 → 0.7.6-dev.47beb25

package/dist/index.js

@@ -5964,7 +5964,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 //#endregion
 //#region src/plugin/utils/get-static-property-key-name.ts
 const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property")) return null;
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition")) return null;
 	if (node.computed) {
 		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
 		return null;
@@ -21401,6 +21401,7 @@ const nextjsNoNativeScript = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-polyfill-script.ts
+const ABSOLUTE_URL_SCHEME_PATTERN = /^[a-z][a-z\d+.-]*:/i;
 const nextjsNoPolyfillScript = defineRule({
 	id: "nextjs-no-polyfill-script",
 	title: "Redundant polyfill script",
@@ -21414,7 +21415,9 @@ const nextjsNoPolyfillScript = defineRule({
 		const srcAttribute = findJsxAttribute(node.attributes ?? [], "src");
 		if (!srcAttribute?.value) return;
 		const srcValue = isNodeOfType(srcAttribute.value, "Literal") ? srcAttribute.value.value : null;
-		if (typeof srcValue === "string" && POLYFILL_SCRIPT_PATTERN.test(srcValue)) context.report({
+		const requestUrl = typeof srcValue === "string" ? srcValue.split("#", 1)[0] : null;
+		const requestScheme = requestUrl?.trimStart().match(ABSOLUTE_URL_SCHEME_PATTERN)?.[0].toLowerCase();
+		if (requestUrl && (!requestScheme || requestScheme === "http:" || requestScheme === "https:") && POLYFILL_SCRIPT_PATTERN.test(requestUrl)) context.report({
 			node,
 			message: "This polyfill CDN script makes your users download polyfills Next.js already includes."
 		});
@@ -33003,6 +33006,18 @@ const INTL_FORMAT_METHOD_NAMES = new Set([
 	"formatToParts",
 	"formatRange"
 ]);
+const ABSENT_PROPERTY_PROOF = { status: "absent" };
+const PRESENT_PROPERTY_PROOF = { status: "present" };
+const UNDEFINED_PROPERTY_PROOF = { status: "undefined" };
+const UNKNOWN_PROPERTY_PROOF = { status: "unknown" };
+const READ_ONLY_OBJECT_METHOD_NAMES = new Set([
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+]);
 const isProvableDateExpression = (expression) => {
 	if (!expression) return false;
 	const unwrapped = stripParenExpression(expression);
@@ -33017,32 +33032,290 @@ const receiverNameLooksDateFlavored = (expression) => {
 	if (isNodeOfType(unwrapped, "CallExpression")) return receiverNameLooksDateFlavored(unwrapped.callee);
 	return false;
 };
-const objectLiteralHasProperty = (objectExpression, propertyName) => {
-	if (!objectExpression) return false;
-	const unwrapped = stripParenExpression(objectExpression);
-	if (!isNodeOfType(unwrapped, "ObjectExpression")) return false;
-	for (const property of unwrapped.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) continue;
-		if (property.computed) continue;
-		if (isNodeOfType(property.key, "Identifier") && property.key.name === propertyName) return true;
-		if (isNodeOfType(property.key, "Literal") && property.key.value === propertyName) return true;
+const isStaticUndefined = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
+	const symbol = scopes.symbolFor(expression);
+	if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isStaticUndefined(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isNestedAssignmentTarget = (expression) => {
+	let target = expression;
+	let parent = target.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === target;
+		if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left === target;
+		if (isNodeOfType(parent, "AssignmentPattern")) {
+			if (parent.left !== target) return false;
+		} else if (isNodeOfType(parent, "RestElement")) {
+			if (parent.argument !== target) return false;
+		} else if (isNodeOfType(parent, "ArrayPattern")) {
+			if (!parent.elements?.some((element) => element === target)) return false;
+		} else if (isNodeOfType(parent, "Property")) {
+			if (parent.value !== target || !isNodeOfType(parent.parent, "ObjectPattern")) return false;
+		} else if (isNodeOfType(parent, "ObjectPattern")) {
+			if (!parent.properties?.some((property) => property === target)) return false;
+		} else return false;
+		target = parent;
+		parent = target.parent;
+	}
+	return false;
+};
+const isPotentialMutationReference = (identifier, readNode) => {
+	let expression = identifier;
+	let parent = expression.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+		expression = parent;
+		parent = expression.parent;
+	}
+	const rootExpression = expression;
+	let memberDepth = 0;
+	while (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
+		memberDepth += 1;
+		expression = parent;
+		parent = expression.parent;
+		while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+			expression = parent;
+			parent = expression.parent;
+		}
+	}
+	if (!parent || isAstDescendant(identifier, readNode)) return false;
+	if (isNestedAssignmentTarget(expression)) return true;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.left === expression) return true;
+	if (isNodeOfType(parent, "UpdateExpression") && parent.argument === expression) return true;
+	if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression) return true;
+	if (isNodeOfType(parent, "CallExpression")) {
+		if (parent.callee === expression) {
+			if (memberDepth === 0) return true;
+			const memberExpression = stripParenExpression(expression);
+			return memberDepth === 1 && isNodeOfType(memberExpression, "MemberExpression") && !READ_ONLY_OBJECT_METHOD_NAMES.has(getStaticPropertyName(memberExpression) ?? "");
+		}
+		return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
 	}
+	if (isNodeOfType(parent, "NewExpression")) return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === rootExpression) return true;
 	return false;
 };
-const hasExplicitLocaleArgument = (argument) => {
+const getSimpleAlias = (identifier, scopes) => {
+	let expression = identifier;
+	let parent = expression.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+		expression = parent;
+		parent = expression.parent;
+	}
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== expression || !isNodeOfType(parent.id, "Identifier")) return null;
+	const symbol = scopes.symbolFor(parent.id);
+	return symbol ? {
+		symbol,
+		readNode: parent.id
+	} : null;
+};
+const getDirectCallForExpression = (expression) => {
+	let callee = expression;
+	let parent = callee.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === callee) {
+		callee = parent;
+		parent = callee.parent;
+	}
+	return isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
+};
+const getMethodOwner = (functionNode, scopes) => {
+	const methodNode = functionNode.parent;
+	if (isNodeOfType(methodNode, "Property") && methodNode.value === functionNode && isNodeOfType(methodNode.parent, "ObjectExpression")) {
+		const objectParent = methodNode.parent.parent;
+		if (!isNodeOfType(objectParent, "VariableDeclarator") || objectParent.init !== methodNode.parent || !isNodeOfType(objectParent.id, "Identifier")) return null;
+		const ownerSymbol = scopes.symbolFor(objectParent.id);
+		const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
+		return ownerSymbol && methodName ? {
+			methodName,
+			ownerKind: "object",
+			ownerSymbol,
+			isStatic: false
+		} : null;
+	}
+	if (!isNodeOfType(methodNode, "MethodDefinition") || methodNode.value !== functionNode || !isNodeOfType(methodNode.parent, "ClassBody")) return null;
+	const classNode = methodNode.parent.parent;
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return null;
+	let bindingIdentifier = isNodeOfType(classNode.id, "Identifier") ? classNode.id : null;
+	if (!bindingIdentifier && isNodeOfType(classNode.parent, "VariableDeclarator")) bindingIdentifier = isNodeOfType(classNode.parent.id, "Identifier") ? classNode.parent.id : null;
+	if (!bindingIdentifier) return null;
+	const ownerSymbol = scopes.symbolFor(bindingIdentifier);
+	const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
+	return ownerSymbol && methodName ? {
+		methodName,
+		ownerKind: "class",
+		ownerSymbol,
+		isStatic: Boolean(methodNode.static)
+	} : null;
+};
+const doesSymbolResolveToOwner = (symbol, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!symbol) return false;
+	if (symbol.declarationNode === ownerSymbol.declarationNode) return true;
+	if (symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = stripParenExpression(symbol.initializer);
+	return isNodeOfType(initializer, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(initializer), ownerSymbol, scopes, visitedSymbolIds);
+};
+const isClassInstanceExpression = (expression, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "NewExpression") && isNodeOfType(candidate.callee, "Identifier")) return doesSymbolResolveToOwner(scopes.symbolFor(candidate.callee), ownerSymbol, scopes);
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isClassInstanceExpression(symbol.initializer, ownerSymbol, scopes, visitedSymbolIds);
+};
+const getMethodCalls = (functionNode, scopes) => {
+	const owner = getMethodOwner(functionNode, scopes);
+	if (!owner) return [];
+	const calls = [];
+	walkAst(scopes.rootScope.node, (child) => {
+		if (!isNodeOfType(child, "MemberExpression")) return;
+		if (getStaticPropertyName(child) !== owner.methodName) return;
+		const receiver = stripParenExpression(child.object);
+		let doesReceiverMatch = isNodeOfType(receiver, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(receiver), owner.ownerSymbol, scopes);
+		if (owner.ownerKind === "class" && !owner.isStatic) doesReceiverMatch = isClassInstanceExpression(receiver, owner.ownerSymbol, scopes);
+		if (!doesReceiverMatch) return;
+		const call = getDirectCallForExpression(child);
+		if (call) calls.push(call);
+	});
+	return calls;
+};
+const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, scopes, visitedSymbolIds, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (visitedFunctionNodes.has(functionNode)) return false;
+	visitedFunctionNodes.add(functionNode);
+	const usageFunction = findEnclosingFunction(usageNode);
+	const immediateCall = getDirectCallForExpression(functionNode);
+	if (immediateCall) {
+		const immediateCallFunction = findEnclosingFunction(immediateCall);
+		if (immediateCallFunction === usageFunction) {
+			const immediateCallStart = getRangeStart(immediateCall);
+			return immediateCallStart === null || immediateCallStart < usageBoundary;
+		}
+		if (!immediateCallFunction) return usageFunction !== null;
+		return isFunctionInvokedBeforeUsage(immediateCallFunction, usageNode, usageBoundary, scopes, visitedSymbolIds, new Set(visitedFunctionNodes));
+	}
+	for (const methodCall of getMethodCalls(functionNode, scopes)) {
+		const methodCallFunction = findEnclosingFunction(methodCall);
+		if (methodCallFunction === usageFunction) {
+			const methodCallStart = getRangeStart(methodCall);
+			if (methodCallStart === null || methodCallStart < usageBoundary) return true;
+			continue;
+		}
+		if (!methodCallFunction) {
+			if (usageFunction) return true;
+			continue;
+		}
+		if (isFunctionInvokedBeforeUsage(methodCallFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes))) return true;
+	}
+	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	if (!bindingIdentifier) return false;
+	const symbol = scopes.symbolFor(bindingIdentifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	let wasInvokedBeforeUsage = false;
+	walkAst(scopes.rootScope.node, (child) => {
+		if (wasInvokedBeforeUsage || !isNodeOfType(child, "Identifier")) return;
+		if (scopes.symbolFor(child)?.declarationNode !== symbol.declarationNode) return;
+		const call = getDirectCallForExpression(child);
+		if (!call) return false;
+		const callFunction = findEnclosingFunction(call);
+		if (callFunction === usageFunction) {
+			const callStart = getRangeStart(call);
+			wasInvokedBeforeUsage = callStart === null || callStart < usageBoundary;
+			return;
+		}
+		if (!callFunction) {
+			wasInvokedBeforeUsage = usageFunction !== null;
+			return;
+		}
+		wasInvokedBeforeUsage = isFunctionInvokedBeforeUsage(callFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes));
+	});
+	return wasInvokedBeforeUsage;
+};
+const getMutationUsageBoundary = (usageNode, readNode) => {
+	const readStart = getRangeStart(readNode);
+	let readExpression = readNode;
+	let readParent = readExpression.parent;
+	while (readParent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(readParent.type) && "expression" in readParent && readParent.expression === readExpression) {
+		readExpression = readParent;
+		readParent = readExpression.parent;
+	}
+	if ((isNodeOfType(usageNode, "CallExpression") || isNodeOfType(usageNode, "NewExpression")) && usageNode.arguments?.some((argument) => argument === readExpression)) return usageNode.range?.[1] ?? null;
+	if (isAstDescendant(readNode, usageNode)) return readStart;
+	return getRangeStart(usageNode);
+};
+const wasMutatedBeforeUsage = (symbol, usageNode, readNode, scopes, visitedMutationSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
+	if (visitedMutationSymbolIds.has(symbol.id)) return false;
+	visitedMutationSymbolIds.add(symbol.id);
+	const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, readNode) : inheritedUsageBoundary;
+	if (typeof usageBoundary !== "number") return true;
+	const usageFunction = findEnclosingFunction(usageNode);
+	return symbol.references.some((reference) => {
+		const referenceStart = getRangeStart(reference.identifier);
+		const simpleAlias = getSimpleAlias(reference.identifier, scopes);
+		if (simpleAlias) return wasMutatedBeforeUsage(simpleAlias.symbol, usageNode, readNodesBySymbolId.get(simpleAlias.symbol.id) ?? simpleAlias.readNode, scopes, new Set(visitedMutationSymbolIds), usageBoundary, readNodesBySymbolId);
+		if (!isPotentialMutationReference(reference.identifier, readNode)) return false;
+		if (referenceStart === null) return true;
+		const mutationFunction = findEnclosingFunction(reference.identifier);
+		if (mutationFunction === usageFunction) return referenceStart < usageBoundary;
+		if (!mutationFunction) return usageFunction !== null;
+		if (usageFunction && isAstDescendant(usageFunction, mutationFunction)) return true;
+		return isFunctionInvokedBeforeUsage(mutationFunction, usageNode, usageBoundary, scopes, /* @__PURE__ */ new Set());
+	});
+};
+const getObjectPropertyProof = (objectExpression, propertyName, scopes, usageNode, visitedSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
+	if (!objectExpression) return ABSENT_PROPERTY_PROOF;
+	const unwrapped = stripParenExpression(objectExpression);
+	if (isNodeOfType(unwrapped, "Literal") || isStaticUndefined(unwrapped, scopes)) return ABSENT_PROPERTY_PROOF;
+	if (isNodeOfType(unwrapped, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrapped);
+		const nextReadNodesBySymbolId = new Map(readNodesBySymbolId);
+		if (symbol) nextReadNodesBySymbolId.set(symbol.id, unwrapped);
+		const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, unwrapped) : inheritedUsageBoundary;
+		if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id) || wasMutatedBeforeUsage(symbol, usageNode, unwrapped, scopes, /* @__PURE__ */ new Set(), usageBoundary, nextReadNodesBySymbolId)) return UNKNOWN_PROPERTY_PROOF;
+		visitedSymbolIds.add(symbol.id);
+		return getObjectPropertyProof(symbol.initializer, propertyName, scopes, usageNode, visitedSymbolIds, usageBoundary, nextReadNodesBySymbolId);
+	}
+	if (isNodeOfType(unwrapped, "ConditionalExpression")) {
+		const consequent = getObjectPropertyProof(unwrapped.consequent, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
+		const alternate = getObjectPropertyProof(unwrapped.alternate, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
+		return consequent.status === alternate.status ? consequent : UNKNOWN_PROPERTY_PROOF;
+	}
+	if (isNodeOfType(unwrapped, "CallExpression") && isNodeOfType(unwrapped.callee, "MemberExpression") && !unwrapped.callee.computed && isNodeOfType(unwrapped.callee.object, "Identifier") && unwrapped.callee.object.name === "Object" && scopes.isGlobalReference(unwrapped.callee.object) && isNodeOfType(unwrapped.callee.property, "Identifier") && unwrapped.callee.property.name === "freeze") return getObjectPropertyProof(unwrapped.arguments?.[0], propertyName, scopes, usageNode, visitedSymbolIds, inheritedUsageBoundary, readNodesBySymbolId);
+	if (!isNodeOfType(unwrapped, "ObjectExpression")) return UNKNOWN_PROPERTY_PROOF;
+	const properties = unwrapped.properties ?? [];
+	for (let propertyIndex = properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
+		const property = properties[propertyIndex];
+		if (!property) continue;
+		if (isNodeOfType(property, "SpreadElement")) {
+			const spreadProof = getObjectPropertyProof(property.argument, propertyName, scopes, unwrapped, new Set(visitedSymbolIds), void 0);
+			if (spreadProof.status !== "absent") return spreadProof;
+			continue;
+		}
+		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property) !== propertyName) continue;
+		return isStaticUndefined(property.value, scopes) ? UNDEFINED_PROPERTY_PROOF : PRESENT_PROPERTY_PROOF;
+	}
+	return ABSENT_PROPERTY_PROOF;
+};
+const objectHasExplicitProperty = (objectExpression, propertyName, scopes, usageNode) => getObjectPropertyProof(objectExpression, propertyName, scopes, usageNode).status === "present";
+const hasExplicitLocaleArgument = (argument, scopes) => {
 	if (!argument) return false;
 	const unwrapped = stripParenExpression(argument);
-	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined") return false;
+	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined" && scopes.isGlobalReference(unwrapped) || isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "void") return false;
 	return true;
 };
-const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate) => {
+const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate, scopes) => {
 	const localeArgument = call.arguments?.[0];
-	if (!hasExplicitLocaleArgument(localeArgument)) return false;
+	if (!hasExplicitLocaleArgument(localeArgument, scopes)) return false;
 	const optionsArgument = call.arguments?.[1];
-	if (objectLiteralHasProperty(optionsArgument, "timeZone")) return true;
+	if (objectHasExplicitProperty(optionsArgument, "timeZone", scopes, call)) return true;
 	return !DATE_ONLY_LOCALE_METHOD_NAMES.has(methodName) && !receiverIsProvablyDate;
 };
-const matchLocaleMethodCall = (call) => {
+const matchLocaleMethodCall = (call, scopes) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -33050,7 +33323,7 @@ const matchLocaleMethodCall = (call) => {
 	if (!LOCALE_FORMAT_METHOD_NAMES.has(methodName)) return null;
 	const receiverIsProvablyDate = isProvableDateExpression(callee.object);
 	if (methodName === "toLocaleString" && !receiverIsProvablyDate && !receiverNameLooksDateFlavored(callee.object)) return null;
-	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate)) return null;
+	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate, scopes)) return null;
 	return {
 		node: call,
 		display: `${methodName}()`
@@ -33066,13 +33339,13 @@ const getIntlFormatterName = (expression) => {
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
 	return INTL_FORMATTER_NAMES.has(callee.property.name) ? callee.property.name : null;
 };
-const isDeterministicIntlConstruction = (construction, formatterName) => {
+const isDeterministicIntlConstruction = (construction, formatterName, scopes) => {
 	if (!isNodeOfType(construction, "CallExpression") && !isNodeOfType(construction, "NewExpression")) return false;
-	if (!hasExplicitLocaleArgument(construction.arguments?.[0])) return false;
+	if (!hasExplicitLocaleArgument(construction.arguments?.[0], scopes)) return false;
 	if (formatterName !== "DateTimeFormat") return true;
-	return objectLiteralHasProperty(construction.arguments?.[1], "timeZone");
+	return objectHasExplicitProperty(construction.arguments?.[1], "timeZone", scopes, construction);
 };
-const matchIntlFormatCall = (call) => {
+const matchIntlFormatCall = (call, scopes) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -33085,7 +33358,7 @@ const matchIntlFormatCall = (call) => {
 	if (!construction) return null;
 	const formatterName = getIntlFormatterName(construction);
 	if (!formatterName) return null;
-	if (isDeterministicIntlConstruction(construction, formatterName)) return null;
+	if (isDeterministicIntlConstruction(construction, formatterName, scopes)) return null;
 	return {
 		node: call,
 		display: `Intl.${formatterName}().${callee.property.name}()`
@@ -33154,7 +33427,7 @@ const noLocaleFormatInRender = defineRule({
 				fileIsEmailTemplate = hasEmailTemplateImport(node);
 			},
 			CallExpression(node) {
-				const match = matchLocaleMethodCall(node) ?? matchIntlFormatCall(node) ?? matchDateDefaultStringification(node);
+				const match = matchLocaleMethodCall(node, context.scopes) ?? matchIntlFormatCall(node, context.scopes) ?? matchDateDefaultStringification(node);
 				if (match) reportIfRenderPhase(match);
 			},
 			TemplateLiteral(node) {
@@ -33174,7 +33447,7 @@ const noLocaleFormatInRender = defineRule({
 				walkAst(helperNode.body ?? helperNode, (child) => {
 					if (isFunctionLike$1(child)) return false;
 					if (!isNodeOfType(child, "CallExpression")) return;
-					const match = matchLocaleMethodCall(child) ?? matchIntlFormatCall(child);
+					const match = matchLocaleMethodCall(child, context.scopes) ?? matchIntlFormatCall(child, context.scopes);
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.1f14fa1",
+  "version": "0.7.6-dev.47beb25",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",