oxlint-plugin-react-doctor 0.7.4-dev.2b5a18e → 0.7.4-dev.5113067

package/dist/index.d.ts

@@ -5296,29 +5296,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-prop-callback-in-render";
-  readonly id: "no-prop-callback-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-prop-types";
   readonly id: "no-prop-types";
@@ -5503,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";
@@ -14562,29 +14516,6 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-prop-callback-in-render";
-  readonly id: "no-prop-callback-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-prop-types";
   readonly id: "no-prop-types";
@@ -14769,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

@@ -10589,19 +10589,6 @@ 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 isPotentiallyFreshComparedValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = unwrapExpression$3(node);
-	if (isUnstableInitializer(candidate)) return true;
-	if (isNodeOfType(candidate, "ConditionalExpression")) return isPotentiallyFreshComparedValue(candidate.consequent, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.alternate, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "LogicalExpression")) return isPotentiallyFreshComparedValue(candidate.left, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.right, scopes, visitedSymbolIds);
-	if (!isNodeOfType(candidate, "Identifier")) return false;
-	const symbol = scopes.symbolFor(candidate);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if (symbol.kind === "let" || symbol.kind === "var") return true;
-	if (symbol.kind !== "const" || !symbol.initializer) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isPotentiallyFreshComparedValue(symbol.initializer, scopes, visitedSymbolIds);
-};
 const isExtraDepAllowedForHook = (hookName, node, scopes) => {
 	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
 	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
@@ -10615,52 +10602,6 @@ const isStableSetterLikeSymbol = (symbol, scopes) => {
 	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
-const isConvergingFunctionalUpdater = (node, scopes) => {
-	const updater = unwrapExpression$3(node);
-	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
-	const previousValueParameter = updater.params?.[0];
-	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
-	let returnedExpression = updater.body;
-	if (isNodeOfType(updater.body, "BlockStatement")) {
-		returnedExpression = null;
-		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
-			returnedExpression = statement.argument;
-			break;
-		}
-	}
-	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
-	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
-	const test = unwrapExpression$3(conditional.test);
-	if (!isNodeOfType(test, "BinaryExpression") || ![
-		"===",
-		"!==",
-		"==",
-		"!="
-	].includes(test.operator)) return false;
-	const isPreviousValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
-	};
-	let comparedValue = null;
-	if (isPreviousValue(test.left)) comparedValue = test.right;
-	else if (isPreviousValue(test.right)) comparedValue = test.left;
-	if (!comparedValue) return false;
-	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
-	const isSameComparedValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		const compared = unwrapExpression$3(comparedValue);
-		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
-		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
-		return false;
-	};
-	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
-};
-const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
-	const parent = identifier.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
-	const writtenValue = parent.arguments?.[0];
-	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
-};
 const findStableSetterReference = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
@@ -10668,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, scopes) && !isGuardedStableSetterCall(current, symbol, scopes)) {
+			if (symbol && isStableSetterLikeSymbol(symbol, scopes)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -22429,26 +22370,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")) {
@@ -23503,20 +23424,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);
@@ -26569,6 +26476,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;
@@ -26702,236 +26660,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;
@@ -30295,26 +30023,28 @@ const noGiantComponent = defineRule({
 			const lineCount = bodyNode.loc.end.line - bodyNode.loc.start.line + 1;
 			return lineCount > 300 ? lineCount : null;
 		};
-		const reportOversizedComponent = (nameNode, componentName) => {
+		const reportOversizedComponent = (nameNode, componentName, lineCount) => {
 			context.report({
 				node: nameNode,
-				message: `Component "${componentName}" is over 300 lines long, which is hard to read & change. Split it into a few smaller components.`
+				message: `Component "${componentName}" is ${lineCount} lines long, which is hard to read & change. Split it into a few smaller components.`
 			});
 		};
 		return {
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-				if (getOversizedComponentLineCount(node) === null) return;
+				const lineCount = getOversizedComponentLineCount(node);
+				if (lineCount === null) return;
 				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name);
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			},
 			VariableDeclarator(node) {
 				if (!isNodeOfType(node.id, "Identifier") || !isUppercaseName(node.id.name)) return;
 				const functionNode = unwrapReactHocFunction(node.init);
 				if (!functionNode) return;
-				if (getOversizedComponentLineCount(functionNode) === null) return;
+				const lineCount = getOversizedComponentLineCount(functionNode);
+				if (lineCount === null) return;
 				if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name);
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			}
 		};
 	}
@@ -35085,66 +34815,6 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
-const isPreservedThroughConciseArrow = (callExpression, scopes) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return false;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (!isNodeOfType(parent, "ArrowFunctionExpression") || parent.body !== node) return !isResultDiscardedCall(node);
-		const invocation = parent.parent;
-		if (!isNodeOfType(invocation, "CallExpression") || !executesDuringRender(parent, scopes)) return true;
-		if (invocation.arguments?.[0] === parent || invocation.arguments?.[1] === parent) {
-			const callee = stripParenExpression(invocation.callee);
-			return !(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" && invocation.arguments[0] === parent);
-		}
-		node = invocation;
-		parent = node.parent;
-	}
-	return false;
-};
-const noPropCallbackInRender = defineRule({
-	id: "no-prop-callback-in-render",
-	title: "Prop callback invoked during render",
-	severity: "error",
-	recommendation: "Invoke the callback from the event or asynchronous operation that produced the value, or from an effect when synchronizing with an external system. Render must stay pure because React can replay or discard it.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isResultDiscardedCall(node)) return;
-		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
-		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		const callee = stripParenExpression(node.callee);
-		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
-		context.report({
-			node,
-			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -35839,63 +35509,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;
@@ -57286,18 +56899,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noPropCallbackInEffect.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-prop-callback-in-render",
-		id: "no-prop-callback-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noPropCallbackInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noPropCallbackInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-prop-types",
 		id: "no-prop-types",
@@ -57389,18 +56990,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.2b5a18e",
+  "version": "0.7.4-dev.5113067",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",