oxlint-plugin-react-doctor 0.7.6-dev.0150fc9 → 0.7.6-dev.0a8d30b

package/dist/index.js

@@ -1180,8 +1180,8 @@ const stripParenExpression = (node) => {
 	return current;
 };
 //#endregion
-//#region src/plugin/utils/get-root-identifier-name.ts
-const getRootIdentifierName = (node, options) => {
+//#region src/plugin/utils/get-root-identifier.ts
+const getRootIdentifier$1 = (node, options) => {
 	if (!node) return null;
 	const followCallChains = options?.followCallChains === true;
 	let cursor = node;
@@ -1192,16 +1192,18 @@ const getRootIdentifierName = (node, options) => {
 			continue;
 		}
 		if (followCallChains && isNodeOfType(cursor, "CallExpression")) {
-			const callee = cursor.callee;
-			if (!isNodeOfType(callee, "MemberExpression")) return null;
-			cursor = callee.object;
+			if (!isNodeOfType(cursor.callee, "MemberExpression")) return null;
+			cursor = cursor.callee.object;
 			continue;
 		}
 		break;
 	}
-	return isNodeOfType(cursor, "Identifier") ? cursor.name : null;
+	return isNodeOfType(cursor, "Identifier") ? cursor : null;
 };
 //#endregion
+//#region src/plugin/utils/get-root-identifier-name.ts
+const getRootIdentifierName = (node, options) => getRootIdentifier$1(node, options)?.name ?? null;
+//#endregion
 //#region src/plugin/rules/state-and-effects/advanced-event-handler-refs.ts
 const STABLE_HANDLER_HOOK_NAMES = new Set([
 	"useCallback",
@@ -5962,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;
@@ -31959,6 +31961,26 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/react-ref-origin.ts
+const resolveReactRefSymbol = (memberExpression, scopes) => {
+	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(receiver, scopes);
+	if (!symbol?.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+};
+const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (resolveReactRefSymbol(expression, scopes)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(expression, scopes);
+	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
 const TIMER_FUNCTION_NAMES = new Set([
 	"cancelAnimationFrame",
@@ -31990,6 +32012,33 @@ const NOTIFICATION_METHOD_NAMES = new Set([
 	"success",
 	"warning"
 ]);
+const NOTIFICATION_MODULE_SOURCES = new Set([
+	"@chakra-ui/react",
+	"@heroui/react",
+	"@mantine/notifications",
+	"antd",
+	"react-hot-toast",
+	"react-toastify",
+	"sonner"
+]);
+const SYNCHRONOUS_ARRAY_METHOD_NAMES = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort"
+]);
+const isNotificationModuleSource = (source) => {
+	if (!source) return false;
+	for (const moduleSource of NOTIFICATION_MODULE_SOURCES) if (source === moduleSource || source.startsWith(`${moduleSource}/`)) return true;
+	return /(?:^|[/_.-])(?:notification|toast)s?(?:$|[/_.-])/i.test(source);
+};
 const getMemberCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
@@ -32001,27 +32050,37 @@ const getMemberCall = (node) => {
 };
 const isNotificationReceiver = (receiver, scopes) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
+	const importBinding = getImportBindingForName(receiver, receiver.name);
+	if (importBinding) return isNotificationModuleSource(importBinding.source) && (importBinding.exportedName === "default" || importBinding.exportedName !== null && NOTIFICATION_RECEIVER_NAMES.has(importBinding.exportedName));
 	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
 	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
 	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const hookImport = getImportBindingForName(callee, callee.name);
+	return Boolean(hookImport && isNotificationModuleSource(hookImport.source) && hookImport.exportedName !== null && /^use(?:Message|Notification|Toast)$/.test(hookImport.exportedName));
+};
+const isKnownGlobalObject = (node, expectedName, scopes) => isNodeOfType(node, "Identifier") && node.name === expectedName && scopes.isGlobalReference(node);
+const isGlobalMember = (node, expectedPropertyName, scopes) => isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && node.property.name === expectedPropertyName && (isKnownGlobalObject(node.object, "window", scopes) || isKnownGlobalObject(node.object, "globalThis", scopes));
+const isStorageReceiver = (node, scopes) => {
+	if (isNodeOfType(node, "Identifier") && STORAGE_RECEIVER_NAMES.has(node.name) && scopes.isGlobalReference(node)) return true;
+	for (const receiverName of STORAGE_RECEIVER_NAMES) if (isGlobalMember(node, receiverName, scopes)) return true;
+	return false;
 };
 const getKnownImpureCall = (callExpression, scopes) => {
 	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
+	if (isNodeOfType(callExpression.callee, "MemberExpression") && !callExpression.callee.computed && isNodeOfType(callExpression.callee.property, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.property.name) && (isKnownGlobalObject(callExpression.callee.object, "window", scopes) || isKnownGlobalObject(callExpression.callee.object, "globalThis", scopes))) return `${callExpression.callee.property.name}()`;
 	const memberCall = getMemberCall(callExpression);
 	if (!memberCall) return null;
 	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
+	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isStorageReceiver(receiver, scopes)) return `${methodName}()`;
+	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && hasReactRefCurrentOrigin(receiver, scopes)) return `.${methodName}()`;
+	const receiverRoot = getRootIdentifier$1(receiver);
+	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && receiverRoot !== null && isKnownGlobalObject(receiverRoot, "document", scopes)) return `.${methodName}()`;
+	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNotificationReceiver(receiver, scopes)) return `${methodName}()`;
 	return null;
 };
 const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
+	const rootIdentifier = getRootIdentifier$1(assignmentTarget);
 	if (!rootIdentifier) return null;
 	const updaterScope = scopes.ownScopeFor(updater);
 	if (!updaterScope) return null;
@@ -32030,12 +32089,26 @@ const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) =>
 	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
 	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
 };
+const isArrayValue = (node, scopes) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "ArrayExpression")) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	return isNodeOfType(resolveConstIdentifierAlias(expression, scopes)?.initializer, "ArrayExpression");
+};
+const isDefinitelySynchronousCallback = (callback, scopes) => {
+	const parent = callback.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "CallExpression") && parent.callee === callback) return true;
+	if (!isNodeOfType(parent, "CallExpression") || !parent.arguments?.some((argument) => argument === callback)) return false;
+	if (isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ARRAY_METHOD_NAMES.has(parent.callee.property.name) && isArrayValue(parent.callee.object, scopes)) return true;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.object, "Identifier") && parent.callee.object.name === "Array" && scopes.isGlobalReference(parent.callee.object) && isNodeOfType(parent.callee.property, "Identifier") && parent.callee.property.name === "from" && parent.arguments[1] === callback;
+};
 const findImpureUpdaterOperation = (updater, scopes) => {
 	const analysis = getProgramAnalysis(updater);
 	let operation = null;
 	walkAst(updater, (child) => {
 		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
+		if (child !== updater && isFunctionLike$1(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isNodeOfType(child.callee, "Identifier") && analysis) {
 				const calleeReference = getRef(analysis, child.callee);
@@ -32067,18 +32140,25 @@ const noImpureStateUpdater = defineRule({
 	severity: "error",
 	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
 	create: (context) => ({ CallExpression(node) {
-		const updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
+		const updaterArgument = node.arguments?.[0];
+		if (!updaterArgument) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
 		const calleeReference = getRef(analysis, node.callee);
 		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
 		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
 		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
+		let updater = null;
+		if (isFunctionLike$1(updaterArgument)) updater = updaterArgument;
+		else if (isNodeOfType(updaterArgument, "Identifier")) {
+			const updaterReference = getRef(analysis, updaterArgument);
+			if (updaterReference) updater = resolveToFunction(updaterReference);
+		}
+		if (!updater) return;
 		const operation = findImpureUpdaterOperation(updater, context.scopes);
 		if (!operation) return;
 		context.report({
-			node: updater,
+			node: updaterArgument,
 			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
 		});
 	} })
@@ -32923,6 +33003,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);
@@ -32937,32 +33029,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;
@@ -32970,7 +33320,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}()`
@@ -32986,13 +33336,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;
@@ -33005,7 +33355,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}()`
@@ -33074,7 +33424,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) {
@@ -33094,7 +33444,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;
@@ -36920,28 +37270,85 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
+const REPEATED_ANCESTOR_TYPES = new Set([
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"WhileStatement"
+]);
 const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
+	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "current") return false;
 	const receiver = stripParenExpression(node.object);
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
+const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
+	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(node);
+	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
+};
+const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
+const hasRepeatedExecutionAncestor = (node, stop) => {
+	let ancestor = node.parent;
+	while (ancestor && ancestor !== stop) {
+		if (isFunctionLike$1(ancestor) || REPEATED_ANCESTOR_TYPES.has(ancestor.type)) return true;
+		ancestor = ancestor.parent;
+	}
+	return ancestor !== stop;
+};
+const getBranchConstraints = (node, branchRoot) => {
+	const constraints = /* @__PURE__ */ new Map();
+	let descendant = node;
+	let ancestor = descendant.parent;
+	while (ancestor && descendant !== branchRoot) {
+		if (isNodeOfType(ancestor, "IfStatement")) {
+			if (ancestor.consequent === descendant) constraints.set(ancestor, true);
+			if (ancestor.alternate === descendant) constraints.set(ancestor, false);
+		}
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return constraints;
+};
+const canExecuteTogether = (firstConstraints, secondConstraints) => {
+	for (const [statement, branch] of firstConstraints) {
+		const otherBranch = secondConstraints.get(statement);
+		if (otherBranch !== void 0 && otherBranch !== branch) return false;
+	}
+	return true;
+};
+const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
+	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
+	const assignmentStart = getRangeStart(assignmentExpression);
+	let hasCoExecutableWrite = false;
+	walkAst(branchRoot, (child) => {
+		if (hasCoExecutableWrite) return false;
+		const childStart = getRangeStart(child);
+		if (child === assignmentExpression || !isNodeOfType(child, "AssignmentExpression") || assignmentStart === null || childStart === null || childStart >= assignmentStart || resolveReactRefSymbol(child.left, scopes)?.id !== refSymbol.id || hasRepeatedExecutionAncestor(child, branchRoot)) return;
+		if (canExecuteTogether(assignmentConstraints, getBranchConstraints(child, branchRoot))) {
+			hasCoExecutableWrite = true;
+			return false;
+		}
+	});
+	return !hasCoExecutableWrite;
+};
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
+	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
+		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
+			"===",
+			"==",
+			"!==",
+			"!="
+		].includes(ancestor.test.operator)) {
 			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
+			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
+			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
+			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;
@@ -45224,7 +45631,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody) => {
+const findHookCallBindings = (componentBody, scopes) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -45235,8 +45642,10 @@ const findHookCallBindings = (componentBody) => {
 			const callee = declarator.init.callee;
 			if (!isNodeOfType(callee, "Identifier")) continue;
 			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
+			const valueSymbol = scopes.symbolFor(declarator.id);
+			if (!valueSymbol) continue;
 			bindings.push({
-				valueName: declarator.id.name,
+				valueSymbol,
 				hookName: callee.name,
 				declarator
 			});
@@ -45244,6 +45653,49 @@ const findHookCallBindings = (componentBody) => {
 	}
 	return bindings;
 };
+const collectExactAliasSymbols = (componentBody, sourceSymbol, scopes) => {
+	const symbols = [sourceSymbol];
+	const symbolIds = new Set([sourceSymbol.id]);
+	const aliasSourceIdentifiers = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(componentBody, "BlockStatement")) return {
+		symbols,
+		aliasSourceIdentifiers
+	};
+	let didFindAlias = true;
+	while (didFindAlias) {
+		didFindAlias = false;
+		for (const statement of componentBody.body ?? []) {
+			if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const") continue;
+			for (const declarator of statement.declarations ?? []) {
+				let aliasIdentifier = null;
+				let sourceIdentifier = null;
+				const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
+				const arrayBinding = isNodeOfType(declarator.id, "ArrayPattern") ? declarator.id.elements[0] : null;
+				const arrayValueNode = isNodeOfType(initializer, "ArrayExpression") ? initializer.elements[0] : null;
+				const arrayValue = arrayValueNode && !isNodeOfType(arrayValueNode, "SpreadElement") ? stripParenExpression(arrayValueNode) : null;
+				if (isNodeOfType(declarator.id, "Identifier") && isNodeOfType(initializer, "Identifier")) {
+					aliasIdentifier = declarator.id;
+					sourceIdentifier = initializer;
+				} else if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements.length === 1 && isNodeOfType(arrayBinding, "Identifier") && isNodeOfType(initializer, "ArrayExpression") && initializer.elements.length === 1 && isNodeOfType(arrayValue, "Identifier")) {
+					aliasIdentifier = arrayBinding;
+					sourceIdentifier = arrayValue;
+				}
+				if (!aliasIdentifier || !sourceIdentifier) continue;
+				const referencedSymbol = scopes.symbolFor(sourceIdentifier);
+				const aliasSymbol = scopes.symbolFor(aliasIdentifier);
+				if (!referencedSymbol || !symbolIds.has(referencedSymbol.id) || !aliasSymbol || aliasSymbol.kind !== "const" || symbolIds.has(aliasSymbol.id)) continue;
+				symbolIds.add(aliasSymbol.id);
+				symbols.push(aliasSymbol);
+				aliasSourceIdentifiers.add(sourceIdentifier);
+				didFindAlias = true;
+			}
+		}
+	}
+	return {
+		symbols,
+		aliasSourceIdentifiers
+	};
+};
 const rerenderDeferReadsHook = defineRule({
 	id: "rerender-defer-reads-hook",
 	title: "URL hook value only read in handlers",
@@ -45254,15 +45706,13 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody);
+			const bindings = findHookCallBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
 			const handlerBindingNames = collectHandlerBindingNames(componentBody);
 			for (const binding of bindings) {
+				const { symbols, aliasSourceIdentifiers } = collectExactAliasSymbols(componentBody, binding.valueSymbol, context.scopes);
 				const referenceLocations = [];
-				walkAst(componentBody, (child) => {
-					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
-					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
-				});
+				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.0150fc9",
+  "version": "0.7.6-dev.0a8d30b",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",