oxlint-plugin-react-doctor 0.7.4-dev.7bbb792 → 0.7.4-dev.98005f2

package/dist/index.d.ts

@@ -5480,29 +5480,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-ref-current-in-render";
-  readonly id: "no-ref-current-in-render";
-  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-render-in-render";
   readonly id: "no-render-in-render";
@@ -14723,29 +14700,6 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-ref-current-in-render";
-  readonly id: "no-ref-current-in-render";
-  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-render-in-render";
   readonly id: "no-render-in-render";

package/dist/index.js

@@ -9968,18 +9968,13 @@ const unwrapExpression$3 = (node) => {
 	return current;
 };
 /**
-* Get the hook name from a direct, wrapped, namespaced, or immutable
-* React import alias call.
+* Get the hook name from a call expression's callee, regardless of
+* whether the hook is called as `useFoo()` (Identifier) or
+* `React.useFoo()` (MemberExpression).
 */
-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;
+const getHookName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
 const FUNCTION_SCOPE_KINDS = new Set([
@@ -10164,7 +10159,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, scopes) => {
+const symbolHasStableHookOrigin = (symbol) => {
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
 	let declarator = symbol.declarationNode;
 	while (declarator && declarator.type !== "VariableDeclarator") declarator = declarator.parent ?? null;
@@ -10177,7 +10172,7 @@ const symbolHasStableHookOrigin = (symbol, scopes) => {
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
 	}
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName) return false;
 	if (initializerHookName === "useRef") return true;
 	if (initializerHookName === "useEffectEvent") return true;
@@ -10212,7 +10207,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, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName || !MEMOIZING_HOOK_NAMES.has(initializerHookName)) return false;
 	const depsArgument = initializer.arguments[1];
 	if (!depsArgument || !isAstNode(depsArgument)) return false;
@@ -10242,7 +10237,7 @@ const getObjectPropertyValue = (objectExpression, propertyName) => {
 	}
 	return null;
 };
-const isStableRefContainerCapture = (symbol, depKey, scopes) => {
+const isStableRefContainerCapture = (symbol, depKey) => {
 	if (symbol.kind !== "const") return false;
 	if (!depKey.startsWith(`${symbol.name}.`)) return false;
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
@@ -10256,7 +10251,7 @@ const isStableRefContainerCapture = (symbol, depKey, scopes) => {
 		if (!propertyValue) return false;
 		currentValue = propertyValue;
 	}
-	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee, scopes) === "useRef";
+	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee) === "useRef";
 };
 const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return true;
@@ -10274,13 +10269,7 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	}
 	return true;
 };
-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);
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || 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) => {
@@ -10468,18 +10457,10 @@ const collectCaptureDepKeys = (callback, scopes) => {
 		}
 		const depKey = computeDepKey(reference);
 		if (!depKey) continue;
-		if (isStableRefContainerCapture(symbol, depKey, scopes)) {
+		if (isStableRefContainerCapture(symbol, depKey)) {
 			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 {
@@ -10508,60 +10489,12 @@ 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, scopes) === "useCallback");
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee) === "useCallback");
 };
-const isExtraReactiveDepAllowed = (node, scopes) => {
+const isExtraEffectDepAllowed = (node, scopes) => {
 	const rootIdentifier = getMemberRootIdentifier(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
@@ -10589,17 +10522,10 @@ 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, scopes) => {
-	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
+const isStableSetterLikeSymbol = (symbol) => {
+	if (!symbolHasStableHookOrigin(symbol)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
 const findStableSetterReference = (node, scopes) => {
@@ -10609,7 +10535,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, scopes)) {
+			if (symbol && isStableSetterLikeSymbol(symbol)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10725,11 +10651,11 @@ const hasRefCurrentAssignmentInComponent = (refSymbol) => {
 	}
 	return false;
 };
-const isSeededDataRefSymbol = (refSymbol, scopes) => {
+const isSeededDataRefSymbol = (refSymbol) => {
 	if (!refSymbol) return false;
 	const initializer = refSymbol.initializer ? unwrapExpression$3(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getHookName(initializer.callee, scopes) !== "useRef") return false;
+	if (getHookName(initializer.callee) !== "useRef") return false;
 	const firstArgument = initializer.arguments[0];
 	if (!firstArgument || !isAstNode(firstArgument)) return false;
 	const strippedArgument = unwrapExpression$3(firstArgument);
@@ -10769,9 +10695,7 @@ const isOuterFunctionScopeDep = (node, callback, scopes) => {
 	const componentOrHookScope = componentOrHookFunction ? scopes.ownScopeFor(componentOrHookFunction) : null;
 	return Boolean(componentOrHookScope && !isDescendantScope(symbol.scope, componentOrHookScope));
 };
-const hasMemberCallForRoot = (node, rootName, scopes) => {
-	const rootSymbol = closureCaptures(node, scopes).find((reference) => reference.resolvedSymbol?.name === rootName)?.resolvedSymbol ?? null;
-	if (!rootSymbol) return false;
+const hasMemberCallForRoot = (node, rootName) => {
 	let didFindMemberCall = false;
 	const visit = (current) => {
 		if (didFindMemberCall) return;
@@ -10787,7 +10711,7 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 					}
 					chainObject = unwrapExpression$3(chainObject.object);
 				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName && scopes.symbolFor(chainObject) === rootSymbol) {
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
 					didFindMemberCall = true;
 					return;
 				}
@@ -10805,11 +10729,9 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 	visit(node);
 	return didFindMemberCall;
 };
-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 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 exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
@@ -10864,7 +10786,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, context.scopes);
+			const hookName = getHookName(node.callee);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
@@ -10921,7 +10843,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.scopes)) context.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol)) context.report({
 					node: callbackToAnalyze,
 					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
@@ -11020,7 +10942,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, context.scopes)) {
+					if (refSymbol && symbolHasStableHookOrigin(refSymbol)) {
 						if (!didReportRefCurrentDep) {
 							context.report({
 								node: elementNode,
@@ -11058,7 +10980,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, context.scopes);
+			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
 				let isCoveredByDeclared = false;
@@ -11144,7 +11066,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 (isExtraDepAllowedForHook(hookName, reportNode, context.scopes)) continue;
+				if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) && isExtraEffectDepAllowed(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;
@@ -22370,26 +22292,6 @@ 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")) {
@@ -23444,20 +23346,6 @@ 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);
@@ -26510,6 +26398,57 @@ 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;
@@ -26643,236 +26582,6 @@ 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;
@@ -35722,63 +35431,6 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
-const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
-	const receiver = stripParenExpression(node.object);
-	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
-};
-const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
-	let descendant = assignmentExpression;
-	let ancestor = descendant.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
-			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
-		}
-		descendant = ancestor;
-		ancestor = descendant.parent;
-	}
-	return false;
-};
-const noRefCurrentInRender = defineRule({
-	id: "no-ref-current-in-render",
-	title: "Ref mutated during render",
-	severity: "error",
-	recommendation: "Move ref writes into an event handler or effect. Render must stay pure because React can replay or discard it. The predictable null-guarded lazy initialization pattern remains supported.",
-	create: (context) => {
-		const report = (memberExpression) => {
-			if (!resolveReactRefSymbol(memberExpression, context.scopes)) return;
-			if (!findRenderPhaseComponentOrHook(memberExpression, context.scopes)) return;
-			context.report({
-				node: memberExpression,
-				message: "This ref is mutated during render. React can replay or discard render work, so the mutation can leak from UI that never commits."
-			});
-		};
-		return {
-			AssignmentExpression(node) {
-				const refSymbol = resolveReactRefSymbol(node.left, context.scopes);
-				if (!refSymbol) return;
-				if (isDocumentedLazyInitialization(node, refSymbol, context.scopes)) return;
-				report(node.left);
-			},
-			UpdateExpression(node) {
-				report(node.argument);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
@@ -57260,18 +56912,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-ref-current-in-render",
-		id: "no-ref-current-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noRefCurrentInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noRefCurrentInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-render-in-render",
 		id: "no-render-in-render",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.4-dev.7bbb792",
+  "version": "0.7.4-dev.98005f2",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",