oxlint-plugin-react-doctor 0.2.11-dev.402c7ea → 0.2.11-dev.d0f5206

package/dist/index.d.ts

@@ -3400,6 +3400,23 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-self-updating-effect";
+  readonly id: "no-self-updating-effect";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "State & Effects";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-set-state";
   readonly id: "no-set-state";
@@ -8855,6 +8872,23 @@ declare const RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-self-updating-effect";
+  readonly id: "no-self-updating-effect";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "State & Effects";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-set-state";
   readonly id: "no-set-state";

package/dist/index.js

@@ -21089,6 +21089,363 @@ const noSecretsInClientCode = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-self-updating-effect.ts
+const doesConstructFreshReference = (node) => isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "Literal") && "regex" in node;
+const expressionReadsStateValue = (node, stateName) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")) return false;
+	if (isNodeOfType(node, "Identifier")) return node.name === stateName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		if (expressionReadsStateValue(node.object, stateName)) return true;
+		return node.computed ? expressionReadsStateValue(node.property, stateName) : false;
+	}
+	if (isNodeOfType(node, "Property")) {
+		if (node.computed && expressionReadsStateValue(node.key, stateName)) return true;
+		return expressionReadsStateValue(node.value, stateName);
+	}
+	const nodeRecord = node;
+	for (const childKey of Object.keys(nodeRecord)) {
+		if (childKey === "parent" || childKey === "type") continue;
+		const childValue = nodeRecord[childKey];
+		if (Array.isArray(childValue)) {
+			for (const childArrayItem of childValue) if (isAstNode(childArrayItem) && expressionReadsStateValue(childArrayItem, stateName)) return true;
+		} else if (isAstNode(childValue) && expressionReadsStateValue(childValue, stateName)) return true;
+	}
+	return false;
+};
+const isNonSettlingSetterArgument = (setterCall, stateName) => {
+	const firstArgument = setterCall.arguments?.[0];
+	if (!firstArgument) return false;
+	const argument = stripParenExpression(firstArgument);
+	if (isNodeOfType(argument, "Identifier") && argument.name === stateName) return false;
+	if (isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression")) return true;
+	if (doesConstructFreshReference(argument)) return true;
+	return expressionReadsStateValue(argument, stateName);
+};
+const getUnconditionalSetterCall = (statement, setterNames) => {
+	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	if (!isNodeOfType(expression.callee, "Identifier")) return null;
+	if (!setterNames.has(expression.callee.name)) return null;
+	return expression;
+};
+const collectDependencyStateNames = (depsNode) => {
+	const dependencyNames = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(depsNode, "ArrayExpression")) return dependencyNames;
+	for (const element of depsNode.elements ?? []) if (isNodeOfType(element, "Identifier")) dependencyNames.add(element.name);
+	return dependencyNames;
+};
+const isEarlyReturnGuard = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement")) return false;
+	const consequent = statement.consequent;
+	if (isNodeOfType(consequent, "ReturnStatement")) return true;
+	if (isNodeOfType(consequent, "BlockStatement")) return (consequent.body ?? []).some((inner) => isNodeOfType(inner, "ReturnStatement"));
+	return false;
+};
+const numericLiteralValue = (node) => {
+	if (isNodeOfType(node, "Literal") && typeof node.value === "number") return node.value;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "-" && isNodeOfType(node.argument, "Literal") && typeof node.argument.value === "number") return -node.argument.value;
+	return null;
+};
+const isStateLength = (node, stateName) => {
+	const member = isNodeOfType(node, "ChainExpression") ? node.expression : node;
+	return isNodeOfType(member, "MemberExpression") && !member.computed && isNodeOfType(member.property, "Identifier") && member.property.name === "length" && expressionReadsStateValue(member.object, stateName);
+};
+const isNullishLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined";
+const numericComparisonHolds = (operator, left, right) => {
+	switch (operator) {
+		case "<": return left < right;
+		case "<=": return left <= right;
+		case ">": return left > right;
+		case ">=": return left >= right;
+		case "===":
+		case "==": return left === right;
+		case "!==":
+		case "!=": return left !== right;
+		default: return false;
+	}
+};
+const guardExitsWhenStateEmpty = (test, stateName) => {
+	const node = isNodeOfType(test, "ChainExpression") ? test.expression : test;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return isStateLength(node.argument, stateName);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "||") return guardExitsWhenStateEmpty(node.left, stateName) || guardExitsWhenStateEmpty(node.right, stateName);
+		if (node.operator === "&&") return guardExitsWhenStateEmpty(node.left, stateName) && guardExitsWhenStateEmpty(node.right, stateName);
+		return false;
+	}
+	if (isNodeOfType(node, "BinaryExpression")) {
+		const leftIsLength = isStateLength(node.left, stateName);
+		const rightIsLength = isStateLength(node.right, stateName);
+		if (leftIsLength || rightIsLength) {
+			const other = numericLiteralValue(leftIsLength ? node.right : node.left);
+			if (other === null) return false;
+			return leftIsLength ? numericComparisonHolds(node.operator, 0, other) : numericComparisonHolds(node.operator, other, 0);
+		}
+		if (node.operator === "==" || node.operator === "===") {
+			if (expressionReadsStateValue(node.left, stateName) && isNullishLiteral(node.right)) return true;
+			if (expressionReadsStateValue(node.right, stateName) && isNullishLiteral(node.left)) return true;
+		}
+		return false;
+	}
+	return false;
+};
+const isEmptyOrFalsyValue = (node) => {
+	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).length === 0;
+	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).length === 0;
+	if (isNodeOfType(node, "Literal")) return node.value === null || node.value === "" || node.value === 0 || node.value === false;
+	if (isNodeOfType(node, "Identifier")) return node.name === "undefined";
+	return false;
+};
+const functionReturnExpression = (fn) => {
+	if (!isNodeOfType(fn, "ArrowFunctionExpression") && !isNodeOfType(fn, "FunctionExpression")) return null;
+	if (!isNodeOfType(fn.body, "BlockStatement")) return fn.body ? stripParenExpression(fn.body) : null;
+	for (const statement of fn.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) return stripParenExpression(statement.argument);
+	return null;
+};
+const isLengthReducingUpdater = (node) => {
+	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
+	const firstParameter = node.params?.[0];
+	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
+	const returned = functionReturnExpression(node);
+	if (!returned || !isNodeOfType(returned, "CallExpression")) return false;
+	const callee = returned.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== firstParameter.name) return false;
+	if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "slice") return false;
+	const sliceStart = numericLiteralValue(returned.arguments?.[0]);
+	return sliceStart !== null && sliceStart >= 1;
+};
+const writeProvablyConverges = (setterArgument, stateName, earlyReturnGuardTests) => {
+	if (!isEmptyOrFalsyValue(setterArgument) && !isLengthReducingUpdater(setterArgument)) return false;
+	return earlyReturnGuardTests.some((test) => guardExitsWhenStateEmpty(test, stateName));
+};
+const SYMBOLIC_DEPTH_LIMIT = 16;
+const unwrapChain = (node) => {
+	let current = node;
+	for (;;) {
+		const withoutParens = stripParenExpression(current);
+		if (withoutParens !== current) {
+			current = withoutParens;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression")) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+};
+const isUndefinedValue = (node) => isNodeOfType(node, "Identifier") && node.name === "undefined" || isNodeOfType(node, "Literal") && node.value === null;
+const literalsEqual = (a, b) => isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal") && a.value === b.value;
+const resolveValueNode = (node, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return null;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "Identifier")) {
+		if (seen.has(current.name)) return null;
+		const written = writes.get(current.name);
+		if (written) return resolveValueNode(written, writes, depth + 1, new Set(seen).add(current.name));
+		return current;
+	}
+	if (isNodeOfType(current, "Literal") || isNodeOfType(current, "ArrayExpression") || isNodeOfType(current, "ObjectExpression")) return current;
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier")) {
+		const objectValue = resolveValueNode(current.object, writes, depth + 1, seen);
+		if (objectValue && isNodeOfType(objectValue, "ObjectExpression")) {
+			const propertyKey = current.property.name;
+			const properties = objectValue.properties ?? [];
+			for (let index = properties.length - 1; index >= 0; index--) {
+				const property = properties[index];
+				if (isNodeOfType(property, "SpreadElement")) return null;
+				if (isNodeOfType(property, "Property") && !property.computed && (isNodeOfType(property.key, "Identifier") && property.key.name === propertyKey || isNodeOfType(property.key, "Literal") && property.key.value === propertyKey)) return resolveValueNode(property.value, writes, depth + 1, seen);
+			}
+		}
+		return null;
+	}
+	return null;
+};
+const resolveToNumber = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value && isNodeOfType(value, "Literal") && typeof value.value === "number") return value.value;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier") && current.property.name === "length") {
+		const objectValue = resolveValueNode(current.object, writes, depth, seen);
+		if (objectValue && isNodeOfType(objectValue, "ArrayExpression")) {
+			const elements = objectValue.elements ?? [];
+			if (!elements.some((element) => element && isNodeOfType(element, "SpreadElement"))) return elements.length;
+		}
+	}
+	return null;
+};
+const provablyEqualAfterWrites = (left, right, writes, depth, seen) => {
+	const leftNumber = resolveToNumber(left, writes, depth, seen);
+	const rightNumber = resolveToNumber(right, writes, depth, seen);
+	if (leftNumber !== null && rightNumber !== null) return leftNumber === rightNumber;
+	const a = resolveValueNode(left, writes, depth, seen);
+	const b = resolveValueNode(right, writes, depth, seen);
+	if (!a || !b) return false;
+	if (literalsEqual(a, b)) return true;
+	if (isUndefinedValue(a) && isUndefinedValue(b)) return true;
+	return isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier") && a.name === b.name;
+};
+const provablyFalsyAfterWrites = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value) {
+		if (isUndefinedValue(value)) return true;
+		if (isNodeOfType(value, "Literal")) return value.value === null || value.value === 0 || value.value === false || value.value === "";
+	}
+	return resolveToNumber(node, writes, depth, seen) === 0;
+};
+const guardProvenAfterWrites = (test, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return false;
+	const node = unwrapChain(test);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "&&") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) && guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		if (node.operator === "||") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) || guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		return false;
+	}
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return provablyFalsyAfterWrites(node.argument, writes, depth + 1, seen);
+	if (isNodeOfType(node, "BinaryExpression")) {
+		if (node.operator === "===" || node.operator === "==") return provablyEqualAfterWrites(node.left, node.right, writes, depth + 1, seen);
+		const leftNumber = resolveToNumber(node.left, writes, depth + 1, seen);
+		const rightNumber = resolveToNumber(node.right, writes, depth + 1, seen);
+		if (leftNumber !== null && rightNumber !== null) return numericComparisonHolds(node.operator, leftNumber, rightNumber);
+		return false;
+	}
+	const value = resolveValueNode(node, writes, depth + 1, seen);
+	if (value) {
+		if (isNodeOfType(value, "ArrayExpression") || isNodeOfType(value, "ObjectExpression")) return true;
+		if (isNodeOfType(value, "Literal")) return Boolean(value.value);
+	}
+	return false;
+};
+const collectTopLevelWrites = (statements, setterNameToStateName, setterNames) => {
+	const writes = /* @__PURE__ */ new Map();
+	const setterCallNodes = /* @__PURE__ */ new Set();
+	for (const statement of statements) {
+		const setterCall = getUnconditionalSetterCall(statement, setterNames);
+		if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+		setterCallNodes.add(setterCall);
+		const stateName = setterNameToStateName.get(setterCall.callee.name);
+		if (!stateName) continue;
+		const argument = setterCall.arguments?.[0];
+		if (!argument) continue;
+		const newValue = isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression") ? functionReturnExpression(argument) : stripParenExpression(argument);
+		if (newValue) writes.set(stateName, newValue);
+	}
+	return {
+		writes,
+		setterCallNodes
+	};
+};
+const everySetterCall = (root, setterName, inspect) => {
+	let ok = true;
+	const visit = (node) => {
+		if (!ok) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === setterName && !inspect(node)) {
+			ok = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!ok) return;
+		}
+	};
+	visit(root);
+	return ok;
+};
+const everyWriteToStateDrivesTowardEmpty = (callbackBody, setterName) => everySetterCall(callbackBody, setterName, (call) => {
+	const argument = call.arguments?.[0];
+	if (!argument) return true;
+	const value = stripParenExpression(argument);
+	return isEmptyOrFalsyValue(value) || isLengthReducingUpdater(value);
+});
+const everySetterCallIsTopLevel = (callbackBody, setterNames, topLevelSetterCalls) => {
+	let safe = true;
+	const visit = (node) => {
+		if (!safe) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && setterNames.has(node.callee.name) && !topLevelSetterCalls.has(node)) {
+			safe = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!safe) return;
+		}
+	};
+	visit(callbackBody);
+	return safe;
+};
+const noSelfUpdatingEffect = defineRule({
+	id: "no-self-updating-effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Remove the feedback loop: derive the value during render, move the write into an event handler, or guard the update so it reaches a fixed point. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => {
+		const checkFunctionScope = (functionBody) => {
+			if (!functionBody || !isNodeOfType(functionBody, "BlockStatement")) return;
+			const useStateBindings = collectUseStateBindings(functionBody);
+			if (useStateBindings.length === 0) return;
+			const setterNameToStateName = /* @__PURE__ */ new Map();
+			for (const binding of useStateBindings) setterNameToStateName.set(binding.setterName, binding.valueName);
+			const setterNames = new Set(setterNameToStateName.keys());
+			for (const statement of functionBody.body ?? []) {
+				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
+				const effectCall = statement.expression;
+				if (!isNodeOfType(effectCall, "CallExpression")) continue;
+				if (!isHookCall$1(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if ((effectCall.arguments?.length ?? 0) < 2) continue;
+				const dependencyStateNames = collectDependencyStateNames(effectCall.arguments[1]);
+				if (dependencyStateNames.size === 0) continue;
+				const callback = getEffectCallback(effectCall);
+				if (!callback) continue;
+				const callbackStatements = getCallbackStatements(callback);
+				const firstWriteIndex = callbackStatements.findIndex((candidate) => getUnconditionalSetterCall(candidate, setterNames) !== null);
+				const guardCutoff = firstWriteIndex < 0 ? callbackStatements.length : firstWriteIndex;
+				const earlyReturnGuardTests = callbackStatements.slice(0, guardCutoff).filter(isEarlyReturnGuard).map((guard) => guard.test);
+				const { writes: topLevelWrites, setterCallNodes } = collectTopLevelWrites(callbackStatements, setterNameToStateName, setterNames);
+				if (everySetterCallIsTopLevel(callback, setterNames, setterCallNodes) && earlyReturnGuardTests.some((test) => guardProvenAfterWrites(test, topLevelWrites, 0, /* @__PURE__ */ new Set()))) continue;
+				const reportedStateNames = /* @__PURE__ */ new Set();
+				for (const callbackStatement of callbackStatements) {
+					const setterCall = getUnconditionalSetterCall(callbackStatement, setterNames);
+					if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+					const stateName = setterNameToStateName.get(setterCall.callee.name);
+					if (!stateName || !dependencyStateNames.has(stateName)) continue;
+					if (reportedStateNames.has(stateName)) continue;
+					if (!isNonSettlingSetterArgument(setterCall, stateName)) continue;
+					const firstArgument = setterCall.arguments?.[0];
+					if (firstArgument && writeProvablyConverges(stripParenExpression(firstArgument), stateName, earlyReturnGuardTests) && everyWriteToStateDrivesTowardEmpty(callback, setterCall.callee.name)) continue;
+					reportedStateNames.add(stateName);
+					context.report({
+						node: setterCall,
+						message: `${setterCall.callee.name}() runs unconditionally inside this effect, which depends on \`${stateName}\` — setting the same state the effect reacts to re-runs the effect on every commit and causes a render loop. Derive the value during render, move the write into an event handler, or guard the update so it settles.`
+					});
+				}
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				const functionName = node.id?.name;
+				if (!functionName || !isUppercaseName(functionName) && !isReactHookName(functionName)) return;
+				checkFunctionScope(node.body);
+			},
+			VariableDeclarator(node) {
+				const isHookAssignment = isNodeOfType(node.id, "Identifier") && isReactHookName(node.id.name) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+				if (!isComponentAssignment(node) && !isHookAssignment) return;
+				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
+				checkFunctionScope(node.init.body);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/utils/get-parent-component.ts
 const getParentComponent = (node) => {
 	let ancestor = node.parent;
@@ -35115,6 +35472,17 @@ const reactDoctorRules = [
 			category: "Security"
 		}
 	},
+	{
+		key: "react-doctor/no-self-updating-effect",
+		id: "no-self-updating-effect",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noSelfUpdatingEffect,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/no-set-state",
 		id: "no-set-state",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.11-dev.402c7ea",
+  "version": "0.2.11-dev.d0f5206",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",