oxlint-plugin-react-doctor 0.7.4-dev.4a5d9bb → 0.7.4-dev.593824d

package/dist/index.d.ts

@@ -4445,6 +4445,29 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-impure-state-updater";
+  readonly id: "no-impure-state-updater";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-indeterminate-attribute";
   readonly id: "no-indeterminate-attribute";
@@ -13642,6 +13665,29 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-impure-state-updater";
+  readonly id: "no-impure-state-updater";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-indeterminate-attribute";
   readonly id: "no-indeterminate-attribute";

package/dist/index.js

@@ -9968,13 +9968,18 @@ const unwrapExpression$3 = (node) => {
 	return current;
 };
 /**
-* Get the hook name from a call expression's callee, regardless of
-* whether the hook is called as `useFoo()` (Identifier) or
-* `React.useFoo()` (MemberExpression).
+* Get the hook name from a direct, wrapped, namespaced, or immutable
+* React import alias call.
 */
-const getHookName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+const getHookName = (callee, scopes) => {
+	const strippedCallee = unwrapExpression$3(callee);
+	if (isNodeOfType(strippedCallee, "Identifier")) {
+		const resolvedSymbol = scopes ? resolveConstIdentifierAlias(strippedCallee, scopes) : null;
+		const importDeclaration = resolvedSymbol?.declarationNode.parent;
+		if (resolvedSymbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react") return getImportedName(resolvedSymbol.declarationNode) ?? strippedCallee.name;
+		return strippedCallee.name;
+	}
+	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
 	return null;
 };
 const FUNCTION_SCOPE_KINDS = new Set([
@@ -10159,7 +10164,7 @@ const STABLE_IDENTITY_WRAPPER_HOOK_NAMES = new Set([
 *   - primitive-literal local consts (the value never changes
 *     between renders unless the literal does)
 */
-const symbolHasStableHookOrigin = (symbol) => {
+const symbolHasStableHookOrigin = (symbol, scopes) => {
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
 	let declarator = symbol.declarationNode;
 	while (declarator && declarator.type !== "VariableDeclarator") declarator = declarator.parent ?? null;
@@ -10172,7 +10177,7 @@ const symbolHasStableHookOrigin = (symbol) => {
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
 	}
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee);
+	const initializerHookName = getHookName(initializer.callee, scopes);
 	if (!initializerHookName) return false;
 	if (initializerHookName === "useRef") return true;
 	if (initializerHookName === "useEffectEvent") return true;
@@ -10207,7 +10212,7 @@ const symbolHasStableMemoizedOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (!declarator.init) return false;
 	const initializer = unwrapExpression$3(declarator.init);
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee);
+	const initializerHookName = getHookName(initializer.callee, scopes);
 	if (!initializerHookName || !MEMOIZING_HOOK_NAMES.has(initializerHookName)) return false;
 	const depsArgument = initializer.arguments[1];
 	if (!depsArgument || !isAstNode(depsArgument)) return false;
@@ -10237,7 +10242,7 @@ const getObjectPropertyValue = (objectExpression, propertyName) => {
 	}
 	return null;
 };
-const isStableRefContainerCapture = (symbol, depKey) => {
+const isStableRefContainerCapture = (symbol, depKey, scopes) => {
 	if (symbol.kind !== "const") return false;
 	if (!depKey.startsWith(`${symbol.name}.`)) return false;
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
@@ -10251,7 +10256,7 @@ const isStableRefContainerCapture = (symbol, depKey) => {
 		if (!propertyValue) return false;
 		currentValue = propertyValue;
 	}
-	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee) === "useRef";
+	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee, scopes) === "useRef";
 };
 const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return true;
@@ -10269,7 +10274,13 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	}
 	return true;
 };
-const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
+const symbolHasStableImportedAlias = (symbol, scopes) => {
+	if (symbol.kind !== "const") return false;
+	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
+	const resolvedSymbol = resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes);
+	return resolvedSymbol !== null && resolvedSymbol !== symbol && resolvedSymbol.kind === "import";
+};
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
@@ -10457,10 +10468,18 @@ const collectCaptureDepKeys = (callback, scopes) => {
 		}
 		const depKey = computeDepKey(reference);
 		if (!depKey) continue;
-		if (isStableRefContainerCapture(symbol, depKey)) {
+		if (isStableRefContainerCapture(symbol, depKey, scopes)) {
 			stableCapturedNames.add(depKey);
 			continue;
 		}
+		if (depKey === symbol.name) {
+			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
+			if (identitySourceKeys) {
+				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
+				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
+				continue;
+			}
+		}
 		keys.add(depKey);
 	}
 	return {
@@ -10489,12 +10508,60 @@ const hasComputedMemberExpression = (node) => {
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
 };
+const mergeIdentitySourceKeys = (expressions, scopes, visitedSymbolIds) => {
+	const identitySourceKeys = /* @__PURE__ */ new Set();
+	for (const expression of expressions) {
+		const expressionSourceKeys = resolveIdentitySourceKeysFromExpression(expression, scopes, visitedSymbolIds);
+		if (!expressionSourceKeys) return null;
+		for (const expressionSourceKey of expressionSourceKeys) identitySourceKeys.add(expressionSourceKey);
+	}
+	return identitySourceKeys;
+};
+const resolveIdentitySourceKeysFromExpression = (expression, scopes, visitedSymbolIds) => {
+	const stripped = unwrapExpression$3(expression);
+	if (isNodeOfType(stripped, "Literal") && (stripped.value === null || typeof stripped.value === "string" || typeof stripped.value === "number" || typeof stripped.value === "boolean") || isNodeOfType(stripped, "TemplateLiteral") && getStaticTemplateLiteralValue(stripped) !== null) return /* @__PURE__ */ new Set();
+	if (isNodeOfType(stripped, "Identifier")) {
+		const sourceSymbol = scopes.symbolFor(stripped);
+		if (!sourceSymbol) return null;
+		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
+		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((reference) => reference.flag === "read")) {
+			if (visitedSymbolIds.has(sourceSymbol.id)) return null;
+			visitedSymbolIds.add(sourceSymbol.id);
+			const sourceKeys = resolveIdentitySourceKeysFromExpression(sourceSymbol.initializer, scopes, visitedSymbolIds);
+			visitedSymbolIds.delete(sourceSymbol.id);
+			if (sourceKeys) return sourceKeys;
+		}
+		return new Set([sourceSymbol.name]);
+	}
+	if (isNodeOfType(stripped, "MemberExpression")) {
+		if (hasComputedMemberExpression(stripped)) return null;
+		const sourceKey = stringifyMemberChain(stripped);
+		const rootIdentifier = getMemberRootIdentifier(stripped);
+		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
+		if (!sourceKey || !rootSymbol) return null;
+		if (isOutsideAllFunctions(rootSymbol)) return /* @__PURE__ */ new Set();
+		if (isStableRefContainerCapture(rootSymbol, sourceKey, scopes)) return /* @__PURE__ */ new Set();
+		if (symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
+		return new Set([sourceKey]);
+	}
+	if (isNodeOfType(stripped, "LogicalExpression")) return mergeIdentitySourceKeys([stripped.left, stripped.right], scopes, visitedSymbolIds);
+	if (isNodeOfType(stripped, "ConditionalExpression")) return mergeIdentitySourceKeys([
+		stripped.test,
+		stripped.consequent,
+		stripped.alternate
+	], scopes, visitedSymbolIds);
+	return null;
+};
+const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
+	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
+	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
+};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
-	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee) === "useCallback");
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee, scopes) === "useCallback");
 };
-const isExtraEffectDepAllowed = (node, scopes) => {
+const isExtraReactiveDepAllowed = (node, scopes) => {
 	const rootIdentifier = getMemberRootIdentifier(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
@@ -10522,10 +10589,17 @@ const isUnstableInitializer = (node) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
 	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
+const isExtraDepAllowedForHook = (hookName, node, scopes) => {
+	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
+	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
+	if (hookName !== "useMemo") return false;
+	const rootSymbol = getRootSymbol(node, scopes);
+	return Boolean(rootSymbol && !symbolHasStableValue(rootSymbol, scopes) && !isUnstableInitializer(rootSymbol.initializer));
+};
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol) => {
-	if (!symbolHasStableHookOrigin(symbol)) return false;
+const isStableSetterLikeSymbol = (symbol, scopes) => {
+	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
 const findStableSetterReference = (node, scopes) => {
@@ -10535,7 +10609,7 @@ const findStableSetterReference = (node, scopes) => {
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
 			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol)) {
+			if (symbol && isStableSetterLikeSymbol(symbol, scopes)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10651,11 +10725,11 @@ const hasRefCurrentAssignmentInComponent = (refSymbol) => {
 	}
 	return false;
 };
-const isSeededDataRefSymbol = (refSymbol) => {
+const isSeededDataRefSymbol = (refSymbol, scopes) => {
 	if (!refSymbol) return false;
 	const initializer = refSymbol.initializer ? unwrapExpression$3(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getHookName(initializer.callee) !== "useRef") return false;
+	if (getHookName(initializer.callee, scopes) !== "useRef") return false;
 	const firstArgument = initializer.arguments[0];
 	if (!firstArgument || !isAstNode(firstArgument)) return false;
 	const strippedArgument = unwrapExpression$3(firstArgument);
@@ -10695,7 +10769,9 @@ const isOuterFunctionScopeDep = (node, callback, scopes) => {
 	const componentOrHookScope = componentOrHookFunction ? scopes.ownScopeFor(componentOrHookFunction) : null;
 	return Boolean(componentOrHookScope && !isDescendantScope(symbol.scope, componentOrHookScope));
 };
-const hasMemberCallForRoot = (node, rootName) => {
+const hasMemberCallForRoot = (node, rootName, scopes) => {
+	const rootSymbol = closureCaptures(node, scopes).find((reference) => reference.resolvedSymbol?.name === rootName)?.resolvedSymbol ?? null;
+	if (!rootSymbol) return false;
 	let didFindMemberCall = false;
 	const visit = (current) => {
 		if (didFindMemberCall) return;
@@ -10711,7 +10787,7 @@ const hasMemberCallForRoot = (node, rootName) => {
 					}
 					chainObject = unwrapExpression$3(chainObject.object);
 				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName && scopes.symbolFor(chainObject) === rootSymbol) {
 					didFindMemberCall = true;
 					return;
 				}
@@ -10729,9 +10805,11 @@ const hasMemberCallForRoot = (node, rootName) => {
 	visit(node);
 	return didFindMemberCall;
 };
-const addAggregatePropsDependency = (captureKeys, declaredKeys, callback) => {
-	if ([...captureKeys].filter((captureKey) => captureKey.startsWith("props.")).length < 2 || declaredKeys.has("props")) return;
-	if (hasMemberCallForRoot(callback, "props")) captureKeys.add("props");
+const addAggregatePropsDependency = (captureKeys, declaredKeys, callback, scopes) => {
+	const propsCaptureKeys = [...captureKeys].filter((captureKey) => captureKey.startsWith("props."));
+	if (propsCaptureKeys.length < 2 || declaredKeys.has("props")) return;
+	if (propsCaptureKeys.every((captureKey) => [...declaredKeys].some((declaredKey) => isMatchingDepOrPrefix(declaredKey, captureKey)))) return;
+	if (hasMemberCallForRoot(callback, "props", scopes)) captureKeys.add("props");
 };
 const exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
@@ -10786,7 +10864,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		};
 		const isAutoDependenciesHook = (hookName) => settings.experimental_autoDependenciesHooks.includes(hookName);
 		return { CallExpression(node) {
-			const hookName = getHookName(node.callee);
+			const hookName = getHookName(node.callee, context.scopes);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
@@ -10843,7 +10921,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (outerAssignments.length > 0) return;
 				const refCurrentInCleanup = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
 				const shouldCheckRefCleanup = EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) || Boolean(additionalHooksRegex && additionalHooksRegex.test(hookName));
-				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol)) context.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol, context.scopes)) context.report({
 					node: callbackToAnalyze,
 					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
@@ -10942,7 +11020,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const fullChain = stringifyMemberChain(stripped);
 				if (fullChain && fullChain.endsWith(".current") && isNodeOfType(stripped, "MemberExpression") && isNodeOfType(stripped.object, "Identifier")) {
 					const refSymbol = context.scopes.symbolFor(stripped.object);
-					if (refSymbol && symbolHasStableHookOrigin(refSymbol)) {
+					if (refSymbol && symbolHasStableHookOrigin(refSymbol, context.scopes)) {
 						if (!didReportRefCurrentDep) {
 							context.report({
 								node: elementNode,
@@ -10980,7 +11058,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				declaredKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
-			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument);
+			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
 				let isCoveredByDeclared = false;
@@ -11066,7 +11144,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (stableCapturedNames.has(rootName) || stableCapturedNames.has(declaredKey)) continue;
 				if (outerFunctionCapturedNames.has(rootName)) continue;
 				const reportNode = declaredKeyToReportNode.get(declaredKey) ?? depsArgument;
-				if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) && isExtraEffectDepAllowed(reportNode, context.scopes)) continue;
+				if (isExtraDepAllowedForHook(hookName, reportNode, context.scopes)) continue;
 				if (missingCaptureKeys.length > 0 && isOuterFunctionScopeDep(reportNode, callbackToAnalyze ?? callbackArgument, context.scopes)) continue;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
 				if (rootSymbol && missingCaptureKeys.length > 0 && isRecursiveInitializerCapture(rootSymbol, callbackToAnalyze ?? callbackArgument)) continue;
@@ -22292,6 +22370,26 @@ const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
+const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.some((def) => {
+	if (def.type !== "ImportBinding") return false;
+	const declarationNode = def.node;
+	if (!isNodeOfType(declarationNode, "ImportNamespaceSpecifier") && !isNodeOfType(declarationNode, "ImportDefaultSpecifier")) return false;
+	const importDeclaration = declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
+}));
+const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
+	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
+	const callee = stripParenExpression(declarator.init.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const reference = getRef(analysis, callee);
+		if (!reference?.resolved) return callee.name === hookName;
+		return isReactNamedImportReference(reference, hookName);
+	}
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
+	const namespaceReference = getRef(analysis, callee.object);
+	if (!namespaceReference?.resolved) return callee.object.name === "React";
+	return isReactNamespaceImportReference(namespaceReference);
+};
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
@@ -23346,6 +23444,20 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 	}
 	return evidence;
 };
+const collectRenderValueEvidence = (analysis, expression, componentFunction, currentFilename) => {
+	const evidence = collectValueEvidence(analysis, expression, {
+		functionNode: componentFunction,
+		invocation: null,
+		isDeferred: false,
+		introducedBindings: /* @__PURE__ */ new Set(),
+		substitutions: /* @__PURE__ */ new Map(),
+		currentFilename
+	}, 1);
+	return {
+		sourceReferences: evidence.sourceReferences,
+		isExclusivelyRenderKnown: evidence.sourceReferences.size > 0 && !evidence.hasUnknownSource && !evidence.hasDeferredIntroducedValue && !evidence.readsExternalValue
+	};
+};
 const findStateSetterReference = (analysis, callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
@@ -26398,57 +26510,6 @@ const noDefaultProps = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state.ts
-const getStateName$1 = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
-	const stateBinding = stateDeclarator.id.elements?.[0];
-	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
-	const setterBinding = stateDeclarator.id.elements?.[1];
-	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
-	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
-	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
-};
-const noDerivedState = defineRule({
-	id: "no-derived-state",
-	title: "Derived value copied into state",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into useState through a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
-	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
-			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
-			const stateName = getStateName$1(fact.stateDeclarator);
-			context.report({
-				node: fact.callExpression,
-				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
-			});
-		}
-	} })
-});
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
-const noDerivedStateEffect = defineRule({
-	id: "no-derived-state-effect",
-	title: "Derived state stored in an effect",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
-		context.report({
-			node,
-			message: "You pay an extra render for state you can derive from other values."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/utils/is-component-function.ts
 const isFunctionAssignedToComponent = (functionNode) => {
 	let cursor = functionNode.parent ?? null;
@@ -26582,6 +26643,236 @@ const createComponentPropStackTracker = (callbacks) => {
 	};
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/collect-render-state-write-facts.ts
+const findReferenceDeclarator = (reference) => {
+	for (const definition of reference.resolved?.defs ?? []) {
+		const definitionNode = definition.node;
+		if (isNodeOfType(definitionNode, "VariableDeclarator")) return definitionNode;
+	}
+	return null;
+};
+const resolveSimpleRenderSource = (analysis, expression, visitedBindings = /* @__PURE__ */ new Set()) => {
+	const node = stripParenExpression(expression);
+	if (!isNodeOfType(node, "Identifier")) return null;
+	const reference = getRef(analysis, node);
+	if (!reference?.resolved || visitedBindings.has(reference.resolved)) return null;
+	if (isProp(analysis, reference)) {
+		if (isWholePropsObjectReference(analysis, reference)) return null;
+		return { bindingIdentity: reference.resolved };
+	}
+	if (isState(analysis, reference)) {
+		const stateDeclarator = getUseStateDecl(analysis, reference);
+		if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || isExternallyDrivenState(analysis, reference)) return null;
+		return { bindingIdentity: reference.resolved };
+	}
+	if (reference.resolved.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init)) return null;
+	const declarator = findReferenceDeclarator(reference);
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return null;
+	const nextVisitedBindings = new Set(visitedBindings);
+	nextVisitedBindings.add(reference.resolved);
+	return resolveSimpleRenderSource(analysis, declarator.init, nextVisitedBindings);
+};
+const doesEvidenceMatchSource = (evidence, source) => evidence.isExclusivelyRenderKnown && evidence.sourceReferences.size > 0 && [...evidence.sourceReferences].every((sourceReference) => sourceReference.resolved === source.bindingIdentity);
+const getDirectBranchStatements = (branch) => {
+	if (isNodeOfType(branch, "BlockStatement")) return branch.body ?? [];
+	return [branch];
+};
+const getDirectCallExpression = (statement) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
+	const expression = stripParenExpression(statement.expression);
+	return isNodeOfType(expression, "CallExpression") ? expression : null;
+};
+const getDirectAssignmentExpression = (statement) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
+	const expression = stripParenExpression(statement.expression);
+	return isNodeOfType(expression, "AssignmentExpression") && expression.operator === "=" ? expression : null;
+};
+const findDirectStateSetterReference = (analysis, callExpression) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return null;
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const reference = getRef(analysis, callee);
+	return reference && isStateSetter(analysis, reference) ? reference : null;
+};
+const getStaticRefCurrentReference = (analysis, expression) => {
+	const node = stripParenExpression(expression);
+	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.object, "Identifier") || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return null;
+	const reference = getRef(analysis, node.object);
+	if (!reference) return null;
+	const declarator = findReferenceDeclarator(reference);
+	return declarator && isGenuineReactHookDeclarator(analysis, declarator, "useRef") ? reference : null;
+};
+const getStateTracker = (analysis, expression) => {
+	const node = stripParenExpression(expression);
+	if (!isNodeOfType(node, "Identifier")) return null;
+	const reference = getRef(analysis, node);
+	if (!reference || !isState(analysis, reference)) return null;
+	const declarator = getUseStateDecl(analysis, reference);
+	if (!declarator || !isGenuineReactHookDeclarator(analysis, declarator, "useState")) return null;
+	return {
+		kind: "state",
+		declarator
+	};
+};
+const getRefTracker = (analysis, expression) => {
+	const reference = getStaticRefCurrentReference(analysis, expression);
+	return reference ? {
+		kind: "ref",
+		reference
+	} : null;
+};
+const getTrackerInitializer = (tracker) => {
+	const declarator = tracker.kind === "state" ? tracker.declarator : findReferenceDeclarator(tracker.reference);
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return null;
+	const initializer = declarator.init.arguments?.[0];
+	return initializer ? initializer : null;
+};
+const isTrackerSynchronized = (analysis, guard) => {
+	for (const statement of guard.statements) {
+		if (guard.tracker.kind === "state") {
+			const callExpression = getDirectCallExpression(statement);
+			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
+			const setterReference = findDirectStateSetterReference(analysis, callExpression);
+			if (!setterReference || getUseStateDecl(analysis, setterReference) !== guard.tracker.declarator || (callExpression.arguments ?? []).length !== 1) continue;
+			const writtenValue = callExpression.arguments?.[0];
+			if (writtenValue && resolveSimpleRenderSource(analysis, writtenValue)?.bindingIdentity === guard.source.bindingIdentity) return true;
+			continue;
+		}
+		const assignmentExpression = getDirectAssignmentExpression(statement);
+		if (!assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression")) continue;
+		if (getStaticRefCurrentReference(analysis, assignmentExpression.left)?.resolved !== guard.tracker.reference.resolved) continue;
+		if (resolveSimpleRenderSource(analysis, assignmentExpression.right)?.bindingIdentity === guard.source.bindingIdentity) return true;
+	}
+	return false;
+};
+const parseRenderTrackerGuard = (analysis, statement) => {
+	if (!isNodeOfType(statement, "IfStatement") || statement.alternate || !isNodeOfType(statement.test, "BinaryExpression") || statement.test.operator !== "!==" || !isNodeOfType(statement.consequent, "BlockStatement")) return null;
+	const left = statement.test.left;
+	const right = statement.test.right;
+	const candidates = [{
+		sourceExpression: left,
+		trackerExpression: right
+	}, {
+		sourceExpression: right,
+		trackerExpression: left
+	}];
+	for (const candidate of candidates) {
+		const source = resolveSimpleRenderSource(analysis, candidate.sourceExpression);
+		if (!source) continue;
+		const tracker = getStateTracker(analysis, candidate.trackerExpression) ?? getRefTracker(analysis, candidate.trackerExpression);
+		if (!tracker) continue;
+		const trackerInitializer = getTrackerInitializer(tracker);
+		if (!trackerInitializer || resolveSimpleRenderSource(analysis, trackerInitializer)?.bindingIdentity !== source.bindingIdentity) continue;
+		const guard = {
+			source,
+			tracker,
+			statements: getDirectBranchStatements(statement.consequent)
+		};
+		return isTrackerSynchronized(analysis, guard) ? guard : null;
+	}
+	return null;
+};
+const isExclusiveDestinationSetterReference = (setterReference, callExpression) => {
+	if (!setterReference.resolved || !isNodeOfType(callExpression, "CallExpression")) return false;
+	const references = setterReference.resolved.references.filter((reference) => !reference.init);
+	if (references.length !== 1) return false;
+	return references[0].identifier === callExpression.callee;
+};
+const getStateInitializer = (stateDeclarator) => {
+	if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression")) return null;
+	const initializer = stateDeclarator.init.arguments?.[0];
+	return initializer ? initializer : null;
+};
+const collectRenderStateWriteFacts = (analysis, componentBody, currentFilename) => {
+	if (!isNodeOfType(componentBody, "BlockStatement") || !componentBody.parent || !isFunctionLike$1(componentBody.parent)) return [];
+	const componentFunction = componentBody.parent;
+	const facts = [];
+	for (const statement of componentBody.body ?? []) {
+		const guard = parseRenderTrackerGuard(analysis, statement);
+		if (!guard) continue;
+		for (const branchStatement of guard.statements) {
+			const callExpression = getDirectCallExpression(branchStatement);
+			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
+			const setterReference = findDirectStateSetterReference(analysis, callExpression);
+			if (!setterReference || (callExpression.arguments ?? []).length !== 1 || !isExclusiveDestinationSetterReference(setterReference, callExpression)) continue;
+			const stateDeclarator = getUseStateDecl(analysis, setterReference);
+			if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || guard.tracker.kind === "state" && stateDeclarator === guard.tracker.declarator) continue;
+			const writtenValue = callExpression.arguments?.[0];
+			const initializer = getStateInitializer(stateDeclarator);
+			if (!writtenValue || !initializer || isFunctionLike$1(writtenValue) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, writtenValue, componentFunction, currentFilename), guard.source) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, initializer, componentFunction, currentFilename), guard.source)) continue;
+			facts.push({
+				callExpression,
+				stateDeclarator
+			});
+		}
+	}
+	return facts;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state.ts
+const getStateName$1 = (stateDeclarator) => {
+	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
+	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
+	const stateBinding = stateDeclarator.id.elements?.[0];
+	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
+	const setterBinding = stateDeclarator.id.elements?.[1];
+	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
+	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
+	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
+};
+const noDerivedState = defineRule({
+	id: "no-derived-state",
+	title: "Derived value copied into state",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into state and synchronizing it during render or through an effect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
+	create: (context) => {
+		const reportStateWrite = (callExpression, stateDeclarator) => {
+			const stateName = getStateName$1(stateDeclarator);
+			context.report({
+				node: callExpression,
+				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
+			});
+		};
+		return {
+			...createComponentPropStackTracker({ onComponentEnter: (componentBody) => {
+				if (!componentBody) return;
+				const analysis = getProgramAnalysis(componentBody);
+				if (!analysis) return;
+				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
+			} }).visitors,
+			CallExpression(node) {
+				if (!isUseEffect(node)) return;
+				const analysis = getProgramAnalysis(node);
+				if (!analysis) return;
+				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+					reportStateWrite(fact.callExpression, fact.stateDeclarator);
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
+const noDerivedStateEffect = defineRule({
+	id: "no-derived-state-effect",
+	title: "Derived state stored in an effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		context.report({
+			node,
+			message: "You pay an extra render for state you can derive from other values."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/is-initial-only-prop-name.ts
 const isInitialOnlyPropName = (propName) => {
 	if (propName === "initialValue" || propName === "defaultValue" || propName === "seedValue") return true;
@@ -30603,6 +30894,131 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
+const TIMER_FUNCTION_NAMES = new Set([
+	"cancelAnimationFrame",
+	"clearInterval",
+	"clearTimeout",
+	"queueMicrotask",
+	"requestAnimationFrame",
+	"setInterval",
+	"setTimeout"
+]);
+const STORAGE_MUTATION_METHOD_NAMES = new Set([
+	"clear",
+	"removeItem",
+	"setItem"
+]);
+const STORAGE_RECEIVER_NAMES = new Set(["localStorage", "sessionStorage"]);
+const EXTERNAL_READ_METHOD_NAMES = new Set(["getBoundingClientRect", "getClientRects"]);
+const NOTIFICATION_RECEIVER_NAMES = new Set([
+	"message",
+	"notification",
+	"toast"
+]);
+const NOTIFICATION_METHOD_NAMES = new Set([
+	"error",
+	"info",
+	"loading",
+	"open",
+	"show",
+	"success",
+	"warning"
+]);
+const getMemberCall = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
+	return {
+		methodName: node.callee.property.name,
+		receiver: stripParenExpression(node.callee.object)
+	};
+};
+const isNotificationReceiver = (receiver, scopes) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
+	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);
+};
+const getKnownImpureCall = (callExpression, scopes) => {
+	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.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}()`;
+	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;
+	if (!rootIdentifier) return null;
+	const updaterScope = scopes.ownScopeFor(updater);
+	if (!updaterScope) return null;
+	const symbol = scopes.symbolFor(rootIdentifier);
+	if (!symbol) return `the external value "${rootIdentifier.name}"`;
+	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 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 (isNodeOfType(child, "CallExpression")) {
+			if (isNodeOfType(child.callee, "Identifier") && analysis) {
+				const calleeReference = getRef(analysis, child.callee);
+				if (calleeReference && isStateSetterCall(analysis, calleeReference)) {
+					operation = `the nested state update "${child.callee.name}()"`;
+					return false;
+				}
+			}
+			const impureCall = getKnownImpureCall(child, scopes);
+			if (impureCall) {
+				operation = impureCall;
+				return false;
+			}
+		}
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			operation = getExternalAssignmentDescription(child.left, updater, scopes);
+			if (operation) return false;
+		}
+		if (isNodeOfType(child, "UpdateExpression")) {
+			operation = getExternalAssignmentDescription(child.argument, updater, scopes);
+			if (operation) return false;
+		}
+	});
+	return operation;
+};
+const noImpureStateUpdater = defineRule({
+	id: "no-impure-state-updater",
+	title: "State updater has side effects",
+	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 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;
+		const operation = findImpureUpdaterOperation(updater, context.scopes);
+		if (!operation) return;
+		context.report({
+			node: updater,
+			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.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/correctness/no-indeterminate-attribute.ts
 const MESSAGE$21 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
 const REACT_USE_REF_OPTIONS = {
@@ -33771,6 +34187,166 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
 	}));
 };
+const getDeclarationKind = (declarator) => {
+	const declaration = declarator.parent;
+	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
+};
+const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
+const getDestructuredPropertyName = (bindingIdentifier) => {
+	const property = bindingIdentifier.parent;
+	if (!property || !isNodeOfType(property, "Property")) return null;
+	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
+	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
+};
+const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const callbackReference = getRef(analysis, unwrappedExpression);
+		const callbackVariable = callbackReference?.resolved;
+		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable)) return null;
+		if (isProp(analysis, callbackReference)) {
+			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
+			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
+			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
+		}
+		if (hasMutableBindingWrite(callbackReference)) return null;
+		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
+		if (definitions.length !== 1) return null;
+		const declarator = definitions[0];
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return null;
+		visitedVariables.add(callbackVariable);
+		if (isNodeOfType(declarator.id, "ObjectPattern")) {
+			const bindingIdentifier = callbackVariable.defs[0]?.name;
+			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
+			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
+			return propertyName && propsReference ? propertyName : null;
+		}
+		if (!isNodeOfType(declarator.id, "Identifier")) return null;
+		return getParentCallbackPropName(analysis, declarator.init, visitedVariables);
+	}
+	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
+	const callbackName = getStaticMemberPropertyName(unwrappedExpression);
+	if (!callbackName) return null;
+	const receiver = stripParenExpression(unwrappedExpression.object);
+	if (!isNodeOfType(receiver, "Identifier")) return null;
+	const receiverReference = getRef(analysis, receiver);
+	if (!receiverReference || !isWholePropsObjectReference(analysis, receiverReference)) return null;
+	return callbackName;
+};
+const isNullishRefInitializer = (initializer) => {
+	if (!initializer) return true;
+	const unwrappedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(unwrappedInitializer, "Literal")) return unwrappedInitializer.value === null;
+	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return false;
+	return unwrappedInitializer.name === "undefined";
+};
+const getDirectComponentBodyStatement = (node, componentBody) => {
+	let current = node;
+	while (current?.parent && current.parent !== componentBody) current = current.parent;
+	return current?.parent === componentBody ? current : null;
+};
+const getVariableForDeclarator = (analysis, declarator) => {
+	for (const scope of analysis.scopeManager.scopes) {
+		const variable = scope.variables.find((candidateVariable) => candidateVariable.defs.some((definition) => definition.node === declarator));
+		if (variable) return variable;
+	}
+	return null;
+};
+const getRefMember = (identifier) => {
+	const receiver = findTransparentExpressionRoot(identifier);
+	const member = receiver.parent;
+	if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== receiver) return null;
+	return member;
+};
+const getRefMemberAssignment = (identifier) => {
+	const member = getRefMember(identifier);
+	if (!member) return null;
+	const memberRoot = findTransparentExpressionRoot(member);
+	const assignment = memberRoot.parent;
+	if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== memberRoot) return null;
+	return assignment;
+};
+const getRefAliasDeclarator = (identifier) => {
+	const initializer = findTransparentExpressionRoot(identifier);
+	const declarator = initializer.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.id, "Identifier") || getDeclarationKind(declarator) !== "const") return null;
+	return declarator;
+};
+const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
+	if (!isNodeOfType(receiver, "Identifier")) return null;
+	const receiverReference = getRef(analysis, receiver);
+	if (!receiverReference?.resolved || hasMutableBindingWrite(receiverReference)) return null;
+	const variables = /* @__PURE__ */ new Set();
+	let currentVariable = receiverReference.resolved;
+	let refCall = null;
+	while (currentVariable && !variables.has(currentVariable)) {
+		variables.add(currentVariable);
+		const definitions = currentVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
+		if (definitions.length !== 1) return null;
+		const declarator = definitions[0];
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) return null;
+		if (isNodeOfType(declarator.init, "CallExpression") && isReactUseRefCall(declarator.init)) {
+			refCall = declarator.init;
+			break;
+		}
+		if (getDeclarationKind(declarator) !== "const" || !isNodeOfType(stripParenExpression(declarator.init), "Identifier")) return null;
+		const upstreamReference = getRef(analysis, stripParenExpression(declarator.init));
+		if (!upstreamReference?.resolved || hasMutableBindingWrite(upstreamReference)) return null;
+		currentVariable = upstreamReference.resolved;
+	}
+	if (!refCall) return null;
+	const pendingVariables = [...variables];
+	while (pendingVariables.length > 0) {
+		const variable = pendingVariables.pop();
+		if (!variable) continue;
+		for (const candidateReference of variable.references) {
+			const aliasDeclarator = getRefAliasDeclarator(candidateReference.identifier);
+			if (!aliasDeclarator) continue;
+			const aliasVariable = getVariableForDeclarator(analysis, aliasDeclarator);
+			if (!aliasVariable || variables.has(aliasVariable)) continue;
+			if (aliasVariable.references.some((aliasReference) => aliasReference.isWrite() && !aliasReference.init)) return null;
+			variables.add(aliasVariable);
+			pendingVariables.push(aliasVariable);
+		}
+	}
+	return {
+		refCall,
+		variables
+	};
+};
+const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || getStaticMemberPropertyName(callee) !== "current") return null;
+	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
+	if (!bindingProvenance) return null;
+	const { refCall, variables } = bindingProvenance;
+	const componentFunction = findEnclosingFunction(effectCall);
+	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
+	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
+	const callbackPropNames = /* @__PURE__ */ new Set();
+	const initializer = refCall.arguments?.[0];
+	const initializerCallbackName = initializer ? getParentCallbackPropName(analysis, initializer) : null;
+	if (initializerCallbackName) callbackPropNames.add(initializerCallbackName);
+	else if (!isNullishRefInitializer(initializer)) return null;
+	for (const variable of variables) for (const candidateReference of variable.references) {
+		if (candidateReference.init) continue;
+		if (candidateReference.isWrite()) return null;
+		const identifier = candidateReference.identifier;
+		if (getRefAliasDeclarator(identifier)) continue;
+		const member = getRefMember(identifier);
+		if (!member || getStaticMemberPropertyName(member) !== "current") return null;
+		const memberParent = findTransparentExpressionRoot(member).parent;
+		if (memberParent && (isNodeOfType(memberParent, "UpdateExpression") || isNodeOfType(memberParent, "UnaryExpression") && memberParent.operator === "delete")) return null;
+		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;
+		const assignedCallbackName = getParentCallbackPropName(analysis, assignment.right);
+		if (!assignedCallbackName) return null;
+		callbackPropNames.add(assignedCallbackName);
+	}
+	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
+};
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -33826,71 +34402,79 @@ const noPassDataToParent = defineRule({
 	severity: "warn",
 	tags: ["test-noise"],
 	recommendation: "Fetch the data in the parent and pass it down as a prop (or return it from the hook), instead of handing it back up through a prop callback in a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent",
-	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		if (hasCleanup(analysis, node)) return;
-		const effectFnRefs = getEffectFnRefs(analysis, node);
-		if (!effectFnRefs) return;
-		const effectFn = getEffectFn(analysis, node);
-		if (!effectFn) return;
-		for (const ref of effectFnRefs) {
-			const callExpr = getCallExpr(ref);
-			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-			if (isRefCall(analysis, ref)) continue;
-			if (!isSynchronous(ref.identifier, effectFn)) continue;
-			const calleeNode = unwrapChainExpression$1(callExpr.callee);
-			const identifier = ref.identifier;
-			if (calleeNode === identifier) {
-				if (!isDirectParentCallbackRef(analysis, ref)) continue;
-				if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
-			} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
-				if (!isWholePropsObjectReference(analysis, ref)) continue;
-				if (isCustomHookParameter(ref)) continue;
-			} else continue;
-			const methodName = getCallMethodName(calleeNode);
-			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
-			if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
-			if (isNamespacedApiCallee(calleeNode)) continue;
-			const calleeName = isNodeOfType(identifier, "Identifier") ? identifier.name : methodName;
-			const isSetterNamedCallee = Boolean(calleeName && SETTER_NAMED_PROP_PATTERN.test(calleeName));
-			const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
-			const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
-				if (isFunctionLike$1(argument)) {
-					if (!isSetterNamedCallee) return [];
-					return getFunctionalUpdaterDataRefs(analysis, argument);
-				}
-				if (isHandlerBagArgument(analysis, argument)) return [];
-				if (isParentWiredHookResultArgument(analysis, argument)) return [];
-				if (isNodeOfType(argument, "Identifier")) {
-					const argumentRef = getRef(analysis, argument);
-					if (argumentRef && resolveToFunction(argumentRef)) return [];
-				}
-				return getDownstreamRefs(analysis, argument);
-			}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-			if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
-			if (!argsUpstreamRefs.some((argRef) => {
-				if (isUseStateIdentifier(argRef.identifier)) return false;
-				if (isProp(analysis, argRef)) return false;
-				if (isUseRefIdentifier(argRef.identifier)) return false;
-				if (isRefCurrent(argRef)) return false;
-				if (isConstant(argRef)) return false;
-				if (isParentWiredHookResultRef(analysis, argRef)) return false;
-				if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-				if (resolvesToFunctionBinding(argRef)) return false;
-				const argIdentifier = argRef.identifier;
-				if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
-				if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
-				return true;
-			})) continue;
-			context.report({
-				node: callExpr,
-				message: "Handing data back to a parent from a useEffect costs your users an extra render."
-			});
-		}
-	} })
+	create: (context) => {
+		const isReactUseRefCall = (node) => isReactApiCall(node, "useRef", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true
+		});
+		return { CallExpression(node) {
+			if (!isUseEffect(node)) return;
+			const analysis = getProgramAnalysis(node);
+			if (!analysis) return;
+			if (hasCleanup(analysis, node)) return;
+			const effectFnRefs = getEffectFnRefs(analysis, node);
+			if (!effectFnRefs) return;
+			const effectFn = getEffectFn(analysis, node);
+			if (!effectFn) return;
+			for (const ref of effectFnRefs) {
+				const callExpr = getCallExpr(ref);
+				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall);
+				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
+				if (!isSynchronous(ref.identifier, effectFn)) continue;
+				const calleeNode = unwrapChainExpression$1(callExpr.callee);
+				const identifier = ref.identifier;
+				if (callbackRefProvenance) {
+					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
+				} else if (calleeNode === identifier) {
+					if (!isDirectParentCallbackRef(analysis, ref)) continue;
+					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
+				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
+					if (!isWholePropsObjectReference(analysis, ref)) continue;
+					if (isCustomHookParameter(ref)) continue;
+				} else continue;
+				const methodName = getCallMethodName(calleeNode);
+				const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
+				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
+				if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
+				if (!callbackRefProvenance && isNamespacedApiCallee(calleeNode)) continue;
+				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
+				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
+				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
+					if (isFunctionLike$1(argument)) {
+						if (!isSetterNamedCallee) return [];
+						return getFunctionalUpdaterDataRefs(analysis, argument);
+					}
+					if (isHandlerBagArgument(analysis, argument)) return [];
+					if (isParentWiredHookResultArgument(analysis, argument)) return [];
+					if (isNodeOfType(argument, "Identifier")) {
+						const argumentRef = getRef(analysis, argument);
+						if (argumentRef && resolveToFunction(argumentRef)) return [];
+					}
+					return getDownstreamRefs(analysis, argument);
+				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+				if (!argsUpstreamRefs.some((argRef) => {
+					if (isUseStateIdentifier(argRef.identifier)) return false;
+					if (isProp(analysis, argRef)) return false;
+					if (isUseRefIdentifier(argRef.identifier)) return false;
+					if (isRefCurrent(argRef)) return false;
+					if (isConstant(argRef)) return false;
+					if (isParentWiredHookResultRef(analysis, argRef)) return false;
+					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
+					if (resolvesToFunctionBinding(argRef)) return false;
+					const argIdentifier = argRef.identifier;
+					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
+					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
+					return true;
+				})) continue;
+				context.report({
+					node: callExpr,
+					message: "Handing data back to a parent from a useEffect costs your users an extra render."
+				});
+			}
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/utils/is-call-result-consumed-as-argument.ts
@@ -56100,6 +56684,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noImgLazyWithHighFetchpriority.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-impure-state-updater",
+		id: "no-impure-state-updater",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noImpureStateUpdater,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noImpureStateUpdater.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-indeterminate-attribute",
 		id: "no-indeterminate-attribute",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.4-dev.4a5d9bb",
+  "version": "0.7.4-dev.593824d",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",