oxlint-plugin-react-doctor 0.7.9-dev.9aa98b9 → 0.7.9-dev.b30fb80

package/dist/index.js

@@ -6205,6 +6205,23 @@ const asyncDeferAwait = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/expression-reads-pattern-binding.ts
+const expressionReadsPatternBinding = (expression, patterns, scopes) => {
+	const bindingSymbolIds = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) walkAst(pattern, (child) => {
+		if (!isNodeOfType(child, "Identifier")) return;
+		const symbol = scopes.symbolFor(child);
+		if (symbol?.bindingIdentifier === child) bindingSymbolIds.add(symbol.id);
+	});
+	let didReadBinding = false;
+	walkAst(expression, (child) => {
+		if (didReadBinding || !isNodeOfType(child, "Identifier")) return;
+		const reference = scopes.referenceFor(child);
+		if (reference?.flag !== "write" && reference?.resolvedSymbol && bindingSymbolIds.has(reference.resolvedSymbol.id)) didReadBinding = true;
+	});
+	return didReadBinding;
+};
+//#endregion
 //#region src/plugin/utils/get-callee-identifier-trail.ts
 const getCalleeIdentifierTrail = (call) => {
 	let entry = call;
@@ -6310,16 +6327,12 @@ const isInsideTransactionCallback = (node) => {
 	return false;
 };
 const reportIfIndependent = (statements, context) => {
-	const declaredNames = /* @__PURE__ */ new Set();
+	const declaredPatterns = [];
 	for (const statement of statements) {
 		const awaitArgument = getAwaitedCall(statement);
 		if (!awaitArgument) continue;
-		let referencesEarlierResult = false;
-		walkAst(awaitArgument, (child) => {
-			if (isNodeOfType(child, "Identifier") && declaredNames.has(child.name)) referencesEarlierResult = true;
-		});
-		if (referencesEarlierResult) return;
-		if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations[0]?.id) collectPatternNames(statement.declarations[0].id, declaredNames);
+		if (expressionReadsPatternBinding(awaitArgument, declaredPatterns, context.scopes)) return;
+		if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations[0]?.id) declaredPatterns.push(statement.declarations[0].id);
 	}
 	context.report({
 		node: statements[0],
@@ -8463,10 +8476,21 @@ const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) =>
 };
 const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
+	return isReactApiCallee(node.callee, apiNames, scopes, options, /* @__PURE__ */ new Set());
+};
+const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds) => {
+	const callee = stripParenExpression(rawCallee);
+	if (options.resolveConditionalAliases && isNodeOfType(callee, "ConditionalExpression")) return isReactApiCallee(callee.consequent, apiNames, scopes, options, new Set(visitedSymbolIds)) && isReactApiCallee(callee.alternate, apiNames, scopes, options, new Set(visitedSymbolIds));
 	if (isNodeOfType(callee, "Identifier")) {
 		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
 		if (options.resolveNamedAliases && isDestructuredReactApiBinding(callee, apiNames, scopes, options)) return true;
+		if (options.resolveConditionalAliases) {
+			const symbol = scopes.symbolFor(callee);
+			if (symbol?.kind === "const" && symbol.initializer && !visitedSymbolIds.has(symbol.id)) {
+				visitedSymbolIds.add(symbol.id);
+				return isReactApiCallee(symbol.initializer, apiNames, scopes, options, visitedSymbolIds);
+			}
+		}
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
@@ -12323,6 +12347,10 @@ const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
 };
 const executesDuringRender = (functionNode, scopes) => {
 	const parent = functionNode.parent;
+	if (isNodeOfType(parent, "NewExpression")) {
+		const callee = stripParenExpression(parent.callee);
+		return Boolean(scopes && parent.arguments?.[0] === functionNode && isNodeOfType(callee, "Identifier") && callee.name === "Promise" && scopes.isGlobalReference(callee));
+	}
 	if (!isNodeOfType(parent, "CallExpression")) return false;
 	if (parent.callee === functionNode) return true;
 	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
@@ -29812,18 +29840,143 @@ const ARITHMETIC_KEY_OPERATORS = new Set([
 	"%"
 ]);
 const bindingMutationResultsByProgram = /* @__PURE__ */ new WeakMap();
-const extractCandidateIdentifiers = (expression) => {
+const UNKNOWN_STATIC_KEY_BRANCH_VALUE = {
+	isNullish: null,
+	isTruthy: null
+};
+const mergeStaticKeyBranchValues = (firstValue, secondValue) => ({
+	isNullish: firstValue.isNullish === secondValue.isNullish ? firstValue.isNullish : null,
+	isTruthy: firstValue.isTruthy === secondValue.isTruthy ? firstValue.isTruthy : null
+});
+const readStaticKeyBranchValue = (expression, depth) => {
+	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT) return null;
+	const node = stripParenExpression(expression);
+	if (isNodeOfType(node, "Literal")) return {
+		isNullish: node.value === null,
+		isTruthy: Boolean(node.value)
+	};
+	if (isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ClassExpression") || isNodeOfType(node, "NewExpression")) return {
+		isNullish: false,
+		isTruthy: true
+	};
+	if (isNodeOfType(node, "TemplateLiteral")) return {
+		isNullish: false,
+		isTruthy: (node.quasis ?? []).some((quasi) => typeof quasi.value?.cooked === "string" && quasi.value.cooked.length > 0) ? true : null
+	};
+	if (isNodeOfType(node, "BinaryExpression")) return {
+		isNullish: false,
+		isTruthy: null
+	};
+	if (isNodeOfType(node, "Identifier")) {
+		const binding = findVariableInitializer(node, node.name);
+		if (!binding) {
+			if (node.name === "undefined") return {
+				isNullish: true,
+				isTruthy: false
+			};
+			if (node.name === "NaN") return {
+				isNullish: false,
+				isTruthy: false
+			};
+			if (node.name === "Infinity") return {
+				isNullish: false,
+				isTruthy: true
+			};
+			return null;
+		}
+		if (!isConstDeclaredBinding(binding) || !binding.initializer) return null;
+		const declarator = binding.bindingIdentifier.parent;
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.id !== binding.bindingIdentifier || declarator.init !== binding.initializer) return null;
+		return readStaticKeyBranchValue(binding.initializer, depth + 1);
+	}
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier")) {
+		if (!Boolean(findVariableInitializer(node.callee, node.callee.name)) && STRING_COERCION_FUNCTIONS.has(node.callee.name)) return {
+			isNullish: false,
+			isTruthy: null
+		};
+	}
+	if (isNodeOfType(node, "UnaryExpression")) {
+		if (node.operator === "void") return {
+			isNullish: true,
+			isTruthy: false
+		};
+		if (node.operator === "typeof") return {
+			isNullish: false,
+			isTruthy: true
+		};
+		if (node.operator === "+" || node.operator === "-" || node.operator === "~") return {
+			isNullish: false,
+			isTruthy: null
+		};
+		if (node.operator !== "!") return null;
+		const argumentValue = readStaticKeyBranchValue(node.argument, depth + 1);
+		if (!argumentValue || argumentValue.isTruthy === null) return null;
+		return {
+			isNullish: false,
+			isTruthy: !argumentValue.isTruthy
+		};
+	}
+	if (isNodeOfType(node, "SequenceExpression")) {
+		const finalExpression = node.expressions.at(-1);
+		return finalExpression ? readStaticKeyBranchValue(finalExpression, depth + 1) : null;
+	}
+	if (isNodeOfType(node, "LogicalExpression")) {
+		const leftValue = readStaticKeyBranchValue(node.left, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE;
+		if (node.operator === "&&" && leftValue.isTruthy !== null) return leftValue.isTruthy ? readStaticKeyBranchValue(node.right, depth + 1) : leftValue;
+		if (node.operator === "||" && leftValue.isTruthy !== null) return leftValue.isTruthy ? leftValue : readStaticKeyBranchValue(node.right, depth + 1);
+		if (node.operator === "??" && leftValue.isNullish !== null) return leftValue.isNullish ? readStaticKeyBranchValue(node.right, depth + 1) : leftValue;
+		const rightValue = readStaticKeyBranchValue(node.right, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE;
+		if (node.operator === "||") return {
+			isNullish: rightValue.isNullish === false ? false : null,
+			isTruthy: rightValue.isTruthy === true ? true : null
+		};
+		if (node.operator === "&&") return {
+			isNullish: leftValue.isNullish === false && rightValue.isNullish === false ? false : null,
+			isTruthy: rightValue.isTruthy === false ? false : null
+		};
+		return {
+			isNullish: rightValue.isNullish === false ? false : null,
+			isTruthy: leftValue.isTruthy !== null && leftValue.isTruthy === rightValue.isTruthy ? leftValue.isTruthy : null
+		};
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const testValue = readStaticKeyBranchValue(node.test, depth + 1);
+		if (testValue?.isTruthy !== null && testValue?.isTruthy !== void 0) return readStaticKeyBranchValue(testValue.isTruthy ? node.consequent : node.alternate, depth + 1);
+		return mergeStaticKeyBranchValues(readStaticKeyBranchValue(node.consequent, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE, readStaticKeyBranchValue(node.alternate, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE);
+	}
+	return null;
+};
+const extractCandidateIdentifiers = (expression, depth = 0) => {
+	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT) return [];
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "Identifier")) return [node];
-	if (isNodeOfType(node, "UnaryExpression") && (node.operator === "-" || node.operator === "+" || node.operator === "~") && isNodeOfType(node.argument, "Identifier")) return [node.argument];
+	if (isNodeOfType(node, "UnaryExpression") && (node.operator === "-" || node.operator === "+" || node.operator === "~") && node.argument) return extractCandidateIdentifiers(node.argument, depth + 1);
 	if (isNodeOfType(node, "TemplateLiteral")) {
 		const identifiers = [];
-		for (const templateExpression of node.expressions ?? []) if (isNodeOfType(templateExpression, "Identifier")) identifiers.push(templateExpression);
+		for (const templateExpression of node.expressions ?? []) identifiers.push(...extractCandidateIdentifiers(templateExpression, depth + 1));
 		return identifiers;
 	}
+	if (isNodeOfType(node, "LogicalExpression")) {
+		const leftValue = readStaticKeyBranchValue(node.left, 0);
+		if (leftValue) {
+			if (node.operator === "&&" && leftValue.isTruthy !== null) return extractCandidateIdentifiers(leftValue.isTruthy ? node.right : node.left, depth + 1);
+			if (node.operator === "||" && leftValue.isTruthy !== null) return extractCandidateIdentifiers(leftValue.isTruthy ? node.left : node.right, depth + 1);
+			if (node.operator === "??" && leftValue.isNullish !== null) return extractCandidateIdentifiers(leftValue.isNullish ? node.right : node.left, depth + 1);
+		}
+		return [...extractCandidateIdentifiers(node.left, depth + 1), ...extractCandidateIdentifiers(node.right, depth + 1)];
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const testValue = readStaticKeyBranchValue(node.test, 0);
+		if (testValue && testValue.isTruthy !== null) return extractCandidateIdentifiers(testValue.isTruthy ? node.consequent : node.alternate, depth + 1);
+		return [...extractCandidateIdentifiers(node.consequent, depth + 1), ...extractCandidateIdentifiers(node.alternate, depth + 1)];
+	}
+	if (isNodeOfType(node, "SequenceExpression")) {
+		const finalExpression = node.expressions.at(-1);
+		return finalExpression ? extractCandidateIdentifiers(finalExpression, depth + 1) : [];
+	}
 	if (isNodeOfType(node, "CallExpression")) {
-		if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return [node.callee.object];
-		if (isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && isNodeOfType(node.arguments?.[0], "Identifier")) return [node.arguments[0]];
+		if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return extractCandidateIdentifiers(node.callee.object, depth + 1);
+		if (isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && !findVariableInitializer(node.callee, node.callee.name) && node.arguments?.[0]) return extractCandidateIdentifiers(node.arguments[0], depth + 1);
 		return [];
 	}
 	if (isNodeOfType(node, "BinaryExpression")) {
@@ -31976,6 +32129,7 @@ const createStateTriggerReachability = ({ analysis, context, effectFunction }) =
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
+const APPLICABLE_EFFECT_HOOK_NAMES = new Set(["useEffect", "useLayoutEffect"]);
 const getUseStateDeclarator = (ref) => (ref.resolved?.defs ?? []).map((def) => def.node).find((node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "ArrayPattern")) ?? null;
 const isDeclaredWithin = (node, container) => {
 	let walker = node;
@@ -32027,7 +32181,12 @@ const noChainStateUpdates = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Set all the related state together in the event handler that starts it, instead of having one useEffect react to a state change and set more state. See https://react.dev/learn/you-might-not-need-an-effect#chains-of-computations",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactApiCall(node, APPLICABLE_EFFECT_HOOK_NAMES, context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveConditionalAliases: true,
+			resolveNamedAliases: true
+		})) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		if (hasCleanup(analysis, node)) return;
@@ -42005,7 +42164,7 @@ const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
 		variables
 	};
 };
-const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall) => {
+const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall, isReactUseEffectCall) => {
 	const callee = stripParenExpression(callExpression.callee);
 	if (!isNodeOfType(callee, "MemberExpression") || getStaticMemberPropertyName(callee) !== "current") return null;
 	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
@@ -42013,7 +42172,9 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 	const { refCall, variables } = bindingProvenance;
 	const componentFunction = findEnclosingFunction$1(effectCall);
 	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
+	const notificationEffectStatement = getDirectComponentBodyStatement(effectCall, componentFunction.body);
+	const notificationEffectRoot = findTransparentExpressionRoot(effectCall);
+	if (!notificationEffectStatement || !isNodeOfType(notificationEffectStatement, "ExpressionStatement") || notificationEffectRoot.parent !== notificationEffectStatement || !isReactUseEffectCall(effectCall)) return null;
 	const callbackPropNames = /* @__PURE__ */ new Set();
 	const initializer = refCall.arguments?.[0];
 	const initializerCallbackName = initializer ? getParentCallbackPropName(analysis, initializer) : null;
@@ -42031,9 +42192,20 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 		const assignment = getRefMemberAssignment(identifier);
 		if (!assignment) continue;
 		const assignmentStatement = findTransparentExpressionRoot(assignment).parent;
-		if (assignment.operator !== "=" || !assignmentStatement || !isNodeOfType(assignmentStatement, "ExpressionStatement") || assignmentStatement.parent !== componentFunction.body) return null;
+		if (assignment.operator !== "=" || !assignmentStatement || !isNodeOfType(assignmentStatement, "ExpressionStatement")) return null;
 		const assignedCallbackName = getParentCallbackPropName(analysis, assignment.right);
 		if (!assignedCallbackName) return null;
+		if (assignmentStatement.parent !== componentFunction.body) {
+			if (!initializerCallbackName || assignedCallbackName !== initializerCallbackName) return null;
+			const assignmentEffectBody = assignmentStatement.parent;
+			if (!assignmentEffectBody || !isNodeOfType(assignmentEffectBody, "BlockStatement")) return null;
+			const assignmentEffectFunction = assignmentEffectBody.parent;
+			if (!assignmentEffectFunction || !isFunctionLike$1(assignmentEffectFunction) || assignmentEffectFunction.body !== assignmentEffectBody) return null;
+			const assignmentEffectCall = findTransparentExpressionRoot(assignmentEffectFunction).parent;
+			if (!assignmentEffectCall || !isNodeOfType(assignmentEffectCall, "CallExpression") || !isReactUseEffectCall(assignmentEffectCall) || getEffectFn(analysis, assignmentEffectCall) !== assignmentEffectFunction) return null;
+			const assignmentEffectStatement = getDirectComponentBodyStatement(assignmentEffectCall, componentFunction.body);
+			if (!assignmentEffectStatement || !isNodeOfType(assignmentEffectStatement, "ExpressionStatement") || assignmentEffectCall.parent !== assignmentEffectStatement || assignmentEffectStatement.range[0] >= notificationEffectStatement.range[0]) return null;
+		}
 		callbackPropNames.add(assignedCallbackName);
 	}
 	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
@@ -42246,6 +42418,10 @@ const noPassDataToParent = defineRule({
 			allowGlobalReactNamespace: true,
 			allowUnboundBareCalls: true
 		});
+		const isReactUseEffectCall = (node) => isReactApiCall(node, "useEffect", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true
+		});
 		return { CallExpression(node) {
 			if (!isUseEffect(node)) return;
 			const analysis = getProgramAnalysis(node);
@@ -42258,7 +42434,7 @@ const noPassDataToParent = defineRule({
 			for (const ref of effectFnRefs) {
 				const callExpr = getCallExpr(ref);
 				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall);
+				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall, isReactUseEffectCall);
 				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
 				if (!isSynchronous(ref.identifier, effectFn)) continue;
 				const calleeNode = unwrapChainExpression(callExpr.callee);
@@ -43820,9 +43996,9 @@ const isInsideComponentContext = (node) => {
 	}
 	return false;
 };
-const functionBodyOf = (node) => {
-	if (isFunctionLike$1(node)) return node.body ?? null;
-	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init.body ?? null;
+const getFunctionFromDeclaration = (node) => {
+	if (isFunctionLike$1(node)) return node;
+	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init;
 	return null;
 };
 const isHookCallee = (callee) => {
@@ -43830,23 +44006,43 @@ const isHookCallee = (callee) => {
 	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && isUppercaseName(callee.object.name) && isNodeOfType(callee.property, "Identifier")) return isReactHookName(callee.property.name);
 	return false;
 };
-const containsHookCall = (body) => {
-	let found = false;
-	walkAst(body, (child) => {
-		if (found) return false;
-		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isHookCallee(child.callee)) found = true;
+const containsReachableHookCall = (functionNode, rootFunction, context, visitedFunctions) => {
+	if (!isFunctionLike$1(functionNode) || visitedFunctions.has(functionNode)) return false;
+	visitedFunctions.add(functionNode);
+	let didFindReachableHook = false;
+	walkAst(functionNode.body, (child) => {
+		if (didFindReachableHook) return false;
+		if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
+		if (!isNodeOfType(child, "CallExpression") && !isNodeOfType(child, "NewExpression")) return;
+		if (isNodeOfType(child, "CallExpression")) {
+			if (isHookCallee(child.callee)) {
+				didFindReachableHook = true;
+				return false;
+			}
+			const calledFunction = resolveExactLocalFunction(child.callee, context.scopes);
+			if (calledFunction && isAstDescendant(calledFunction, rootFunction) && containsReachableHookCall(calledFunction, rootFunction, context, visitedFunctions)) {
+				didFindReachableHook = true;
+				return false;
+			}
+		}
+		for (const callArgument of child.arguments ?? []) {
+			if (!executesDuringRender(callArgument, context.scopes)) continue;
+			const callbackFunction = resolveExactLocalFunction(callArgument, context.scopes);
+			if (callbackFunction && isAstDescendant(callbackFunction, rootFunction) && containsReachableHookCall(callbackFunction, rootFunction, context, visitedFunctions)) {
+				didFindReachableHook = true;
+				return false;
+			}
+		}
 	});
-	return found;
+	return didFindReachableHook;
 };
-const isHookCallingRenderHelper = (symbol) => {
+const isHookCallingRenderHelper = (symbol, context) => {
 	if (!symbol) return false;
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "FunctionDeclaration") && !isNodeOfType(declaration, "VariableDeclarator")) return false;
-	const body = functionBodyOf(declaration);
-	if (!body) return false;
-	return containsHookCall(body);
+	const functionNode = getFunctionFromDeclaration(declaration);
+	if (!functionNode) return false;
+	return containsReachableHookCall(functionNode, functionNode, context, /* @__PURE__ */ new Set());
 };
 const noRenderInRender = defineRule({
 	id: "no-render-in-render",
@@ -43861,7 +44057,7 @@ const noRenderInRender = defineRule({
 		const calleeName = expression.callee.name;
 		if (!RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		if (!isInsideComponentContext(node)) return;
-		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee))) return;
+		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee), context)) return;
 		context.report({
 			node: expression,
 			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
@@ -62844,29 +63040,19 @@ const serverNoMutableModuleState = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/server/server-sequential-independent-await.ts
-const collectDeclaredNames = (declaration) => {
-	const names = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(declaration, "VariableDeclaration")) return names;
-	for (const declarator of declaration.declarations ?? []) collectPatternNames(declarator.id, names);
-	return names;
-};
 const declarationStartsWithAwait = (declaration) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) if (isNodeOfType(declarator.init, "AwaitExpression")) return true;
 	return false;
 };
-const declarationReadsAnyName = (declaration, names) => {
-	if (names.size === 0) return false;
+const declarationReadsAnyPatternBinding = (declaration, patterns, context) => {
+	if (patterns.length === 0) return false;
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
-	let didRead = false;
 	for (const declarator of declaration.declarations ?? []) {
 		if (!declarator.init) continue;
-		walkAst(declarator.init, (child) => {
-			if (didRead) return;
-			if (isNodeOfType(child, "Identifier") && names.has(child.name)) didRead = true;
-		});
+		if (expressionReadsPatternBinding(declarator.init, patterns, context.scopes)) return true;
 	}
-	return didRead;
+	return false;
 };
 const GATE_LEADING_VERBS = new Set([
 	"require",
@@ -62940,11 +63126,11 @@ const serverSequentialIndependentAwait = defineRule({
 				const currentStatement = statements[statementIndex];
 				if (!isNodeOfType(currentStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(currentStatement)) continue;
-				const declaredNames = collectDeclaredNames(currentStatement);
+				const declaredPatterns = currentStatement.declarations.map((declarator) => declarator.id);
 				const nextStatement = statements[statementIndex + 1];
 				if (!isNodeOfType(nextStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(nextStatement)) continue;
-				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
+				if (declarationReadsAnyPatternBinding(nextStatement, declaredPatterns, context)) continue;
 				if (declarationAwaitsExistingPromise(nextStatement)) continue;
 				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
 				if (declarationAwaitsGate(currentStatement, context)) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.9aa98b9",
+  "version": "0.7.9-dev.b30fb80",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",