oxlint-plugin-react-doctor 0.7.7-dev.e5b0690 → 0.7.7-dev.ec144d9

package/dist/index.js

@@ -5991,15 +5991,17 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 //#endregion
 //#region src/plugin/utils/get-static-property-key-name.ts
 const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition")) return null;
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
+	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
 	if (node.computed) {
-		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
+		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
+		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
 		return null;
 	}
-	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
-	if (isNodeOfType(node.key, "Literal")) {
-		if (typeof node.key.value === "string") return node.key.value;
-		if (options.stringifyNonStringLiterals) return String(node.key.value);
+	if (isNodeOfType(key, "Identifier")) return key.name;
+	if (isNodeOfType(key, "Literal")) {
+		if (typeof key.value === "string") return key.value;
+		if (options.stringifyNonStringLiterals) return String(key.value);
 	}
 	return null;
 };
@@ -11003,6 +11005,14 @@ const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
 	"catch",
 	"finally"
 ]);
+const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
+const getPromiseChainCallForCallback = (candidate) => {
+	let callbackContainer = candidate.parent;
+	while (callbackContainer && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callbackContainer.type)) callbackContainer = callbackContainer.parent;
+	if (!isNodeOfType(callbackContainer, "CallExpression")) return null;
+	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
+	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
+};
 const collectEffectInvokedFunctions = (effectCallback) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
@@ -11014,7 +11024,6 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 		invokedFunctions.add(strippedCandidate);
 		pendingFunctions.push(strippedCandidate);
 	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
 	while (pendingFunctions.length > 0) {
 		const currentFunction = pendingFunctions.pop();
 		if (!currentFunction) break;
@@ -11222,6 +11231,50 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	return true;
 };
 //#endregion
+//#region src/plugin/utils/is-node-reachable-within-function.ts
+const isInsideStaticallyUnreachableBranch = (node) => {
+	let child = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "IfStatement") && isNodeOfType(parent.test, "Literal")) {
+			if (parent.test.value === false && parent.consequent === child) return true;
+			if (parent.test.value === true && parent.alternate === child) return true;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && isNodeOfType(parent.test, "Literal")) {
+			if (parent.test.value === false && parent.consequent === child) return true;
+			if (parent.test.value === true && parent.alternate === child) return true;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) {
+			if (isNodeOfType(parent.left, "Literal") && (parent.operator === "&&" && !parent.left.value || parent.operator === "||" && Boolean(parent.left.value))) return true;
+		}
+		child = parent;
+		parent = parent.parent;
+	}
+	return false;
+};
+const isNodeReachableWithinFunction = (node, context) => {
+	if (isInsideStaticallyUnreachableBranch(node)) return false;
+	const owner = context.cfg.enclosingFunction(node);
+	if (!owner) return true;
+	const functionCfg = context.cfg.cfgFor(owner);
+	if (!functionCfg) return true;
+	const targetBlock = functionCfg.blockOf(node);
+	if (!targetBlock) return true;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (currentBlock === targetBlock) return true;
+		for (const edge of currentBlock.successors) {
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
@@ -11350,27 +11403,6 @@ const findSubscribeLikeUsages = (callback, context) => {
 	});
 	return usages.filter((usage) => isNodeReachableWithinFunction(usage.node, context));
 };
-const isNodeReachableWithinFunction = (node, context) => {
-	const owner = context.cfg.enclosingFunction(node);
-	if (!owner) return true;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return true;
-	const targetBlock = functionCfg.blockOf(node);
-	if (!targetBlock) return true;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (currentBlock === targetBlock) return true;
-		for (const edge of currentBlock.successors) {
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
 const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
 	let pathAnchor = usageNode;
 	let pathOwner = findEnclosingFunction(pathAnchor);
@@ -11844,6 +11876,94 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	return didFindUnmountCleanup;
 };
 const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
+const collectBlockingBooleanStates = (expression, blockedExpressionValue, context) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, context);
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
+		if (!(unwrappedExpression.operator === "||" && blockedExpressionValue || unwrappedExpression.operator === "&&" && !blockedExpressionValue)) return [];
+		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, context)];
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression") && [
+		"===",
+		"==",
+		"!==",
+		"!="
+	].includes(unwrappedExpression.operator)) {
+		const leftValue = readStaticBoolean(unwrappedExpression.left);
+		const rightValue = readStaticBoolean(unwrappedExpression.right);
+		const booleanValue = leftValue ?? rightValue;
+		const comparedKey = resolveExpressionKey(leftValue === null ? unwrappedExpression.left : unwrappedExpression.right, context);
+		if (booleanValue === null || comparedKey === null) return [];
+		return [{
+			key: comparedKey,
+			value: (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") === blockedExpressionValue ? booleanValue : !booleanValue
+		}];
+	}
+	const expressionKey = resolveExpressionKey(unwrappedExpression, context);
+	return expressionKey === null ? [] : [{
+		key: expressionKey,
+		value: blockedExpressionValue
+	}];
+};
+const isDirectEarlyReturnConsequent = (ifStatement) => {
+	if (!isNodeOfType(ifStatement, "IfStatement") || ifStatement.alternate) return false;
+	if (isNodeOfType(ifStatement.consequent, "ReturnStatement")) return true;
+	return isNodeOfType(ifStatement.consequent, "BlockStatement") && ifStatement.consequent.body.length === 1 && isNodeOfType(ifStatement.consequent.body[0], "ReturnStatement");
+};
+const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
+	if (!isFunctionLike$2(callback) || callback.async) return [];
+	const guardStates = [];
+	walkAst(callback.body, (child) => {
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "IfStatement") && isDirectEarlyReturnConsequent(child) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, context));
+	});
+	let descendant = usageNode;
+	let ancestor = descendant.parent;
+	while (ancestor && ancestor !== callback) {
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, context));
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return guardStates;
+};
+const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
+	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
+	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+	if (!cleanupFunction || !isFunctionLike$2(cleanupFunction) || cleanupFunction.async) return false;
+	let didInvalidateGuard = false;
+	walkAst(cleanupFunction.body, (child) => {
+		if (didInvalidateGuard) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveExpressionKey(child.left, context) === guardState.key && readStaticBoolean(child.right) === guardState.value && context.cfg.isUnconditionalFromEntry(child)) {
+			didInvalidateGuard = true;
+			return false;
+		}
+	});
+	return didInvalidateGuard;
+};
+const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, context) => {
+	const usageStart = getRangeStart(usageNode);
+	if (!isFunctionLike$2(callback) || usageStart === null) return true;
+	let didWriteGuard = false;
+	walkAst(callback.body, (child) => {
+		if (didWriteGuard) return false;
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null || childStart >= usageStart) return;
+		const writtenExpression = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : null;
+		if (writtenExpression && resolveExpressionKey(writtenExpression, context) === guardState.key) {
+			didWriteGuard = true;
+			return false;
+		}
+	});
+	return didWriteGuard;
+};
+const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
+	const usageFunction = findEnclosingFunction(usage.node);
+	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
+	if (usage.handleKey === null || !usageFunction || usageFunction === callback || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
+	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
+};
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (callback.async) return false;
@@ -11883,6 +12003,7 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 		if (!cleanupFunction || !isFunctionLike$2(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
+	if (hasGuardedDeferredCleanup(callback, usage, matchingCleanupReturns, context)) return true;
 	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
 };
 const findFirstUsageWithoutCleanup = (callback, usages, context) => {
@@ -17201,7 +17322,7 @@ const GLOBAL_BUILTIN_NAMES = new Set([
 ]);
 const STRING_PROTOTYPE_PATH = "String.prototype";
 const REGEXP_PROTOTYPE_PATH = "RegExp.prototype";
-const getStaticStringValue = (argument) => {
+const getStaticStringValue$1 = (argument) => {
 	if (!argument) return null;
 	const unwrappedArgument = stripParenExpression(argument);
 	if (isNodeOfType(unwrappedArgument, "Literal") && typeof unwrappedArgument.value === "string") return unwrappedArgument.value;
@@ -17209,7 +17330,7 @@ const getStaticStringValue = (argument) => {
 	return null;
 };
 const getEffectiveRegExpFlags = (patternArgument, flagsArgument) => {
-	if (flagsArgument) return getStaticStringValue(flagsArgument);
+	if (flagsArgument) return getStaticStringValue$1(flagsArgument);
 	if (!patternArgument) return "";
 	const unwrappedPattern = stripParenExpression(patternArgument);
 	if (isNodeOfType(unwrappedPattern, "Literal") && unwrappedPattern.value instanceof RegExp) return unwrappedPattern.value.flags;
@@ -17359,7 +17480,7 @@ const getCallRegExpHazard = (node, context, symbolCache) => {
 	const mutationHazard = targetPath === "global" ? "globalRegExpReplaced" : "replaceAllIntegrityLost";
 	const guardedPropertyName = targetPath === "global" ? "RegExp" : "replaceAll";
 	if (isSinglePropertyMutation) {
-		const propertyName = getStaticStringValue(node.arguments?.[1]);
+		const propertyName = getStaticStringValue$1(node.arguments?.[1]);
 		return propertyName === null || propertyName === guardedPropertyName ? mutationHazard : "none";
 	}
 	if (!isPropertyCollectionMutation) return "none";
@@ -25449,8 +25570,11 @@ const unwrapUseCallback = (node) => {
 	const callee = node.callee;
 	return isNodeOfType(callee, "Identifier") && callee.name === "useCallback" || isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useCallback" ? node.arguments?.[0] : node;
 };
+const hasParameterDefinition = (ref) => Boolean(ref.resolved?.defs.some((definition) => definition.type === "Parameter"));
 const resolveToFunction = (ref) => {
-	const definitionNode = ref.resolved?.defs[0]?.node;
+	const definition = ref.resolved?.defs[0];
+	if (!definition || hasParameterDefinition(ref)) return null;
+	const definitionNode = definition.node;
 	if (!definitionNode) return null;
 	if (isFunctionLike$2(definitionNode)) return definitionNode;
 	if (isNodeOfType(definitionNode, "VariableDeclarator")) {
@@ -25860,7 +25984,7 @@ const isCleanupReturnArgument = (analysis, node) => {
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const ref = getRef(analysis, node);
-		if (ref && resolveToFunction(ref)) return true;
+		if (ref && (hasParameterDefinition(ref) || resolveToFunction(ref))) return true;
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
 	return false;
@@ -26332,7 +26456,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	if (isNodeOfType(candidate, "Identifier")) {
 		const reference = getRef(analysis, candidate);
 		if (!reference) return null;
-		if (reference.resolved?.defs.some((definition) => definition.type === "Parameter" || definition.type === "ImportBinding")) return null;
+		if (reference.resolved?.defs.some((definition) => definition.type === "ImportBinding")) return null;
 		const resolved = resolveToFunction(reference);
 		if (resolved) return resolved;
 		const definitionNode = reference.resolved?.defs[0]?.node;
@@ -38141,8 +38265,6 @@ const getWrapperHookWrappedFunction = (initializer) => {
 	if (!wrapped || !isFunctionLike$2(wrapped)) return null;
 	return wrapped;
 };
-const hasParameterDef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "Parameter"));
-const resolvesToFunctionBinding = (ref) => !hasParameterDef(ref) && Boolean(resolveToFunction(ref));
 const HANDLER_NAMED_PROP_PATTERN = /^(on|handle)[A-Z]/;
 const wrappedFunctionNotifiesParent = (analysis, wrappedFunction) => getDownstreamRefs(analysis, wrappedFunction).some((innerRef) => {
 	if (!isProp(analysis, innerRef)) return false;
@@ -38463,7 +38585,7 @@ const noPassDataToParent = defineRule({
 					if (isConstant(argRef)) return false;
 					if (isParentWiredHookResultRef(analysis, argRef)) return false;
 					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
+					if (resolveToFunction(argRef)) return false;
 					const argIdentifier = argRef.identifier;
 					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
 					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
@@ -46894,7 +47016,258 @@ const queryMutationMissingInvalidation = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-node-conditionally-executed.ts
+const isNodeConditionallyExecuted = (node, boundary) => {
+	let child = node;
+	let parent = child.parent ?? null;
+	while (parent && parent !== boundary) {
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === child || parent.alternate === child)) return true;
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) return true;
+		if (isNodeOfType(parent, "AssignmentPattern") && parent.right === child) return true;
+		child = parent;
+		parent = child.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/tanstack-query/utils/resolve-tanstack-query-hook-name.ts
+const resolveTanstackNamespaceHookName = (memberExpression, contextNode, scopes) => {
+	const hookName = getStaticPropertyKeyName(memberExpression, { allowComputedString: true });
+	const namespaceObject = stripParenExpression(memberExpression.object);
+	if (!hookName || !TANSTACK_QUERY_HOOKS.has(hookName)) return null;
+	if (!isNodeOfType(namespaceObject, "Identifier")) return null;
+	const resolvedNamespaceSymbol = resolveConstIdentifierAlias(namespaceObject, scopes);
+	if (resolvedNamespaceSymbol?.kind !== "import") return null;
+	const namespaceBinding = getImportBindingForName(contextNode, resolvedNamespaceSymbol.name);
+	return namespaceBinding?.isNamespace && isTanstackQuerySource(namespaceBinding.source) ? hookName : null;
+};
+const resolveTanstackQueryHookName = (callExpression, scopes) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const resolvedSymbol = resolveConstIdentifierAlias(callee, scopes);
+		if (!resolvedSymbol) return null;
+		if (resolvedSymbol.kind === "const" && resolvedSymbol.initializer) {
+			const initializer = stripParenExpression(resolvedSymbol.initializer);
+			return isNodeOfType(initializer, "MemberExpression") ? resolveTanstackNamespaceHookName(initializer, callExpression, scopes) : null;
+		}
+		if (resolvedSymbol.kind !== "import") return null;
+		const importBinding = getImportBindingForName(callExpression, resolvedSymbol.name);
+		if (importBinding === null) return null;
+		if (importBinding.isNamespace || !isTanstackQuerySource(importBinding.source)) return null;
+		return importBinding.exportedName !== null && TANSTACK_QUERY_HOOKS.has(importBinding.exportedName) ? importBinding.exportedName : null;
+	}
+	if (isNodeOfType(callee, "MemberExpression")) return resolveTanstackNamespaceHookName(callee, callExpression, scopes);
+	return null;
+};
+const resolveTanstackQueryHookNameFromInitializer = (initializer, scopes) => {
+	const unwrappedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(unwrappedInitializer, "CallExpression")) return resolveTanstackQueryHookName(unwrappedInitializer, scopes);
+	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return null;
+	const resolvedSymbol = resolveConstIdentifierAlias(unwrappedInitializer, scopes);
+	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
+	const resolvedInitializer = stripParenExpression(resolvedSymbol.initializer);
+	if (!isNodeOfType(resolvedInitializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(resolvedInitializer, scopes);
+};
+//#endregion
 //#region src/plugin/rules/tanstack-query/query-no-query-in-effect.ts
+const isTanstackQueryResult = (expression, context) => Boolean(resolveTanstackQueryHookNameFromInitializer(expression, context.scopes));
+const isStaticRefetchMember = (memberExpression) => getStaticPropertyKeyName(memberExpression, { allowComputedString: true }) === "refetch";
+const resolveCalledFunction = (callee, context) => {
+	const unwrappedCallee = stripParenExpression(callee);
+	if (isFunctionLike$2(unwrappedCallee)) return unwrappedCallee;
+	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(unwrappedCallee, context.scopes);
+	if (!symbol) return null;
+	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
+	return candidate && isFunctionLike$2(candidate) ? candidate : null;
+};
+const hasSuspensionBefore = (functionNode, boundary, context) => {
+	if (!isFunctionLike$2(functionNode)) return true;
+	if (functionNode.generator) return true;
+	const boundaryStart = getRangeStart(boundary);
+	if (boundaryStart === null) return true;
+	let hasSuspension = false;
+	walkAst(functionNode, (node) => {
+		if (node !== functionNode && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "AwaitExpression") || !isNodeReachableWithinFunction(node, context)) return;
+		const suspensionStart = getRangeStart(node);
+		if (suspensionStart !== null && suspensionStart < boundaryStart) {
+			hasSuspension = true;
+			return false;
+		}
+	});
+	return hasSuspension;
+};
+const isFunctionAncestor = (ancestor, functionNode) => {
+	let enclosingFunction = findEnclosingFunction(functionNode);
+	while (enclosingFunction) {
+		if (enclosingFunction === ancestor) return true;
+		enclosingFunction = findEnclosingFunction(enclosingFunction);
+	}
+	return false;
+};
+const isUnconditionallyExecuted = (node, functionNode, context) => context.cfg.isUnconditionalFromEntry(node) && !isNodeConditionallyExecuted(node, functionNode) && !(isNodeOfType(node, "MemberExpression") && isNodeOfType(node.parent, "AssignmentExpression") && node.parent.left === node && (node.parent.operator === "&&=" || node.parent.operator === "||=" || node.parent.operator === "??="));
+const functionInvokesTarget = (callerFunction, targetFunction, context, visitedFunctions, canCrossSuspension = false) => {
+	if (visitedFunctions.has(callerFunction)) return false;
+	visitedFunctions.add(callerFunction);
+	let invokesTarget = false;
+	walkAst(callerFunction, (node) => {
+		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		if (!isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context) || !canCrossSuspension && hasSuspensionBefore(callerFunction, node, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === targetFunction || calledFunction && functionInvokesTarget(calledFunction, targetFunction, context, visitedFunctions, canCrossSuspension)) {
+			invokesTarget = true;
+			return false;
+		}
+	});
+	return invokesTarget;
+};
+const isFunctionInvokedBefore = (invokedFunction, boundary, context) => {
+	const boundaryFunction = findEnclosingFunction(boundary);
+	const boundaryStart = getRangeStart(boundary);
+	if (!boundaryFunction || boundaryStart === null) return false;
+	let isInvokedBefore = false;
+	walkAst(boundaryFunction, (node) => {
+		if (node !== boundaryFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		const callStart = getRangeStart(node);
+		if (callStart === null || callStart >= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, boundaryFunction, context) || hasSuspensionBefore(boundaryFunction, node, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === invokedFunction || calledFunction && functionInvokesTarget(calledFunction, invokedFunction, context, /* @__PURE__ */ new Set())) {
+			isInvokedBefore = true;
+			return false;
+		}
+	});
+	return isInvokedBefore;
+};
+const isFunctionInvokedAfter = (invokedFunction, boundary, callerFunction, context) => {
+	const boundaryStart = getRangeStart(boundary);
+	if (boundaryStart === null) return false;
+	let isInvokedAfter = false;
+	walkAst(callerFunction, (node) => {
+		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		const callStart = getRangeStart(node);
+		if (callStart === null || callStart <= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === invokedFunction || calledFunction && functionInvokesTarget(calledFunction, invokedFunction, context, /* @__PURE__ */ new Set(), true)) {
+			isInvokedAfter = true;
+			return false;
+		}
+	});
+	return isInvokedAfter;
+};
+const isWriteExecutedBefore = (writeNode, boundary, context, deferredExecutionFunction) => {
+	const writeStart = getRangeStart(writeNode);
+	const boundaryStart = getRangeStart(boundary);
+	const writeFunction = findEnclosingFunction(writeNode);
+	const writeExecutionBoundary = writeFunction ?? findProgramRoot(writeNode);
+	if (writeStart === null || boundaryStart === null || !writeExecutionBoundary || !isNodeReachableWithinFunction(writeNode, context) || !isUnconditionallyExecuted(writeNode, writeExecutionBoundary, context)) return false;
+	const boundaryFunction = findEnclosingFunction(boundary);
+	const renderFunction = deferredExecutionFunction ? findEnclosingFunction(deferredExecutionFunction) : null;
+	if (writeFunction === boundaryFunction) return writeStart < boundaryStart;
+	if (!writeFunction) return writeStart < boundaryStart;
+	if (boundaryFunction && isFunctionAncestor(writeFunction, boundaryFunction)) {
+		if (Boolean(renderFunction && (writeFunction === renderFunction || isFunctionAncestor(writeFunction, renderFunction)))) return true;
+		if (deferredExecutionFunction && boundaryFunction !== deferredExecutionFunction) {
+			if (hasSuspensionBefore(boundaryFunction, boundary, context) && isFunctionInvokedBefore(boundaryFunction, writeNode, context)) return true;
+			return isFunctionInvokedAfter(boundaryFunction, writeNode, writeFunction, context);
+		}
+		return writeStart < boundaryStart;
+	}
+	if (renderFunction && isFunctionAncestor(renderFunction, writeFunction) && !hasSuspensionBefore(writeFunction, writeNode, context) && functionInvokesTarget(renderFunction, writeFunction, context, /* @__PURE__ */ new Set())) return true;
+	return !hasSuspensionBefore(writeFunction, writeNode, context) && isFunctionInvokedBefore(writeFunction, boundary, context);
+};
+const getStaticStringValue = (node) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isNodeOfType(unwrappedNode, "Literal") && typeof unwrappedNode.value === "string") return unwrappedNode.value;
+	if (isNodeOfType(unwrappedNode, "TemplateLiteral") && unwrappedNode.expressions.length === 0) return getStaticTemplateLiteralValue(unwrappedNode);
+	return null;
+};
+const isSameRefetchMember = (target, candidate, context) => {
+	const unwrappedTarget = stripParenExpression(target);
+	const unwrappedCandidate = stripParenExpression(candidate);
+	if (!isNodeOfType(unwrappedTarget, "Identifier") || !isNodeOfType(unwrappedCandidate, "MemberExpression") || !isStaticRefetchMember(unwrappedCandidate)) return false;
+	const candidateTarget = stripParenExpression(unwrappedCandidate.object);
+	if (!isNodeOfType(candidateTarget, "Identifier")) return false;
+	const targetSymbol = resolveConstIdentifierAlias(unwrappedTarget, context.scopes);
+	const candidateSymbol = resolveConstIdentifierAlias(candidateTarget, context.scopes);
+	return Boolean(targetSymbol && candidateSymbol?.id === targetSymbol.id);
+};
+const getRefetchMutationTarget = (node, context) => {
+	if (isNodeOfType(node, "MemberExpression") && isStaticRefetchMember(node)) {
+		const parent = node.parent;
+		if (isNodeOfType(parent, "AssignmentExpression") && parent.left === node && isSameRefetchMember(node.object, parent.right, context)) return null;
+		return isNodeOfType(parent, "AssignmentExpression") && parent.left === node || isNodeOfType(parent, "UpdateExpression") && parent.argument === node || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" ? node.object : null;
+	}
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "Object" || context.scopes.symbolFor(receiver)) return null;
+	const methodName = getStaticPropertyKeyName(callee, { allowComputedString: true });
+	const target = node.arguments[0];
+	if (!target || isNodeOfType(target, "SpreadElement")) return null;
+	if (methodName === "defineProperty") {
+		const propertyKey = node.arguments[1];
+		if (!propertyKey || getStaticStringValue(propertyKey) !== "refetch") return null;
+		const descriptor = node.arguments[2];
+		if (isNodeOfType(descriptor, "ObjectExpression")) {
+			const valueProperty = descriptor.properties.find((property) => isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "value");
+			if (isNodeOfType(valueProperty, "Property") && isSameRefetchMember(target, valueProperty.value, context)) return null;
+		}
+		return target;
+	}
+	if (methodName !== "assign") return null;
+	let finalRefetchValue = null;
+	for (const source of node.arguments.slice(1)) {
+		if (!isNodeOfType(source, "ObjectExpression")) continue;
+		for (const property of source.properties) if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "refetch") finalRefetchValue = property.value;
+	}
+	if (!finalRefetchValue || isSameRefetchMember(target, finalRefetchValue, context)) return null;
+	return target;
+};
+const hasRefetchMemberWriteBefore = (expression, boundary, context, deferredExecutionFunction) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
+	const resultSymbol = resolveConstIdentifierAlias(unwrappedExpression, context.scopes);
+	if (!resultSymbol) return false;
+	const program = findProgramRoot(expression);
+	if (!program) return true;
+	if (getRangeStart(boundary) === null) return true;
+	let hasWrite = false;
+	walkAst(program, (node) => {
+		const mutationTarget = getRefetchMutationTarget(node, context);
+		if (!mutationTarget) return;
+		if (!isWriteExecutedBefore(node, boundary, context, deferredExecutionFunction)) return;
+		const object = stripParenExpression(mutationTarget);
+		if (!isNodeOfType(object, "Identifier")) return;
+		if (resolveConstIdentifierAlias(object, context.scopes)?.id === resultSymbol.id) {
+			hasWrite = true;
+			return false;
+		}
+	});
+	return hasWrite;
+};
+const isTanstackRefetchExpression = (expression, context, deferredExecutionFunction, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return isStaticRefetchMember(unwrappedExpression) && isTanstackQueryResult(unwrappedExpression.object, context) && !hasRefetchMemberWriteBefore(unwrappedExpression.object, unwrappedExpression, context, deferredExecutionFunction);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read") || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+	visitedSymbolIds.add(symbol.id);
+	const bindingProperty = symbol.bindingIdentifier.parent;
+	if (isNodeOfType(bindingProperty, "Property") && getStaticPropertyKeyName(bindingProperty, { allowComputedString: true }) === "refetch") {
+		const initializer = symbol.declarationNode.init;
+		return Boolean(initializer && isTanstackQueryResult(initializer, context) && !hasRefetchMemberWriteBefore(initializer, symbol.declarationNode, context, null));
+	}
+	return Boolean(symbol.declarationNode.id === symbol.bindingIdentifier && symbol.initializer && isTanstackRefetchExpression(symbol.initializer, context, null, visitedSymbolIds));
+};
+const isTanstackRefetchCall = (callExpression, context, effectCallback) => {
+	return isTanstackRefetchExpression(callExpression.callee, context, effectCallback);
+};
 const queryNoQueryInEffect = defineRule({
 	id: "query-no-query-in-effect",
 	title: "Query refetch inside useEffect",
@@ -46910,8 +47283,7 @@ const queryNoQueryInEffect = defineRule({
 		walkAst(callback, (child) => {
 			if (child !== callback && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const callee = child.callee;
-			if (isNodeOfType(callee, "Identifier") && callee.name === "refetch" || isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "refetch") context.report({
+			if (isTanstackRefetchCall(child, context, callback)) context.report({
 				node: child,
 				message: "refetch() inside useEffect duplicates work React Query already does, causing extra fetches."
 			});
@@ -46920,28 +47292,6 @@ const queryNoQueryInEffect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/tanstack-query/query-no-rest-destructuring.ts
-const resolveTanstackQueryHookName = (callExpression) => {
-	const callee = callExpression.callee;
-	if (isNodeOfType(callee, "Identifier")) {
-		const importBinding = getImportBindingForName(callExpression, callee.name);
-		if (importBinding === null) return TANSTACK_QUERY_HOOKS.has(callee.name) ? callee.name : null;
-		if (importBinding.isNamespace || !isTanstackQuerySource(importBinding.source)) return null;
-		return importBinding.exportedName !== null && TANSTACK_QUERY_HOOKS.has(importBinding.exportedName) ? importBinding.exportedName : null;
-	}
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && TANSTACK_QUERY_HOOKS.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) {
-		const namespaceBinding = getImportBindingForName(callExpression, callee.object.name);
-		if (namespaceBinding?.isNamespace && isTanstackQuerySource(namespaceBinding.source)) return callee.property.name;
-	}
-	return null;
-};
-const resolveHookNameFromInitializer = (initializer, scopes) => {
-	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
-	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
-	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
-	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
-};
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
 	title: "Rest destructuring on query result",
@@ -46953,7 +47303,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
+		const hookName = resolveTanstackQueryHookNameFromInitializer(node.init, context.scopes);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -55649,22 +55999,6 @@ const isInsideClassComponent = (node) => {
 	}
 	return false;
 };
-const hasShortCircuitAncestor = (descendant, ancestor) => {
-	let current = descendant.parent;
-	while (current && current !== ancestor) {
-		if (isNodeOfType(current, "ConditionalExpression") && (isWithinRange(descendant, current.consequent) || isWithinRange(descendant, current.alternate))) return true;
-		if (isNodeOfType(current, "LogicalExpression") && (current.operator === "&&" || current.operator === "||" || current.operator === "??") && isWithinRange(descendant, current.right)) return true;
-		if (isNodeOfType(current, "AssignmentPattern") && isWithinRange(descendant, current.right)) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-const isWithinRange = (descendant, sibling) => {
-	const descendantSpan = descendant;
-	const siblingSpan = sibling;
-	if (typeof descendantSpan.start !== "number" || typeof siblingSpan.start !== "number" || typeof siblingSpan.end !== "number") return false;
-	return descendantSpan.start >= siblingSpan.start && (descendantSpan.end ?? siblingSpan.end) <= siblingSpan.end;
-};
 const isInsideTry = (descendant, ancestor) => {
 	let current = descendant.parent;
 	while (current && current !== ancestor) {
@@ -55856,7 +56190,7 @@ const rulesOfHooks = defineRule({
 					});
 					return;
 				}
-				if (hasShortCircuitAncestor(node, enclosing.node)) {
+				if (isNodeConditionallyExecuted(node, enclosing.node)) {
 					context.report({
 						node: node.callee,
 						message: buildConditionalMessage(hookName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.7-dev.e5b0690",
+  "version": "0.7.7-dev.ec144d9",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",