oxlint-plugin-react-doctor 0.7.4-dev.5113067 → 0.7.4-dev.593824d

package/dist/index.js

@@ -22370,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")) {
@@ -23424,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);
@@ -26476,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;
@@ -26660,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;

package/package.json

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