oxlint-plugin-react-doctor 0.7.6-dev.55cebeb → 0.7.6-dev.5699529

package/README.md

@@ -63,7 +63,7 @@ Each rule can be set to `"error"`, `"warn"`, or `"off"`:
 ```jsonc
 {
   "rules": {
-    "react-doctor/no-cascading-set-state": "error",
+    "react-doctor/effect-needs-cleanup": "error",
     "react-doctor/no-array-index-as-key": "warn",
   },
 }

package/dist/index.js

@@ -10948,7 +10948,7 @@ const findDeclaratorForBinding = (bindingIdentifier) => {
 };
 //#endregion
 //#region src/plugin/utils/executes-during-render.ts
-const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
 	"map",
 	"filter",
 	"forEach",
@@ -10984,7 +10984,7 @@ const executesDuringRender = (functionNode, scopes) => {
 	if (parent.callee === functionNode) return true;
 	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
 	if (scopes && parent.arguments?.[1] === functionNode && (isGlobalArrayFromMember(parent.callee, scopes) || isConstAliasOfGlobalArrayFrom(parent.callee, scopes))) return true;
-	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
 };
 //#endregion
 //#region src/plugin/utils/find-render-phase-component-or-hook.ts
@@ -15826,7 +15826,7 @@ const jotaiTqUseRawQueryAtom = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-async-reduce-without-awaited-acc.ts
-const isAsyncFunctionLike$1 = (node) => {
+const isAsyncFunctionLike = (node) => {
 	if (!node) return false;
 	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
 	return node.async === true;
@@ -15893,7 +15893,7 @@ const jsAsyncReduceWithoutAwaitedAcc = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reducerCandidate = stripParenExpression(args[0]);
-		if (!isAsyncFunctionLike$1(reducerCandidate)) return;
+		if (!isAsyncFunctionLike(reducerCandidate)) return;
 		const reducer = reducerCandidate;
 		if (!containsDirectAwait(reducer.body)) return;
 		const firstParameter = classifyFirstParameter(reducer);
@@ -28479,271 +28479,21 @@ const noCallComponentAsFunction = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-setter-identifier.ts
-const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
-//#endregion
-//#region src/plugin/utils/is-setter-call.ts
-const isSetterCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && isSetterIdentifier(node.callee.name);
-//#endregion
-//#region src/plugin/utils/is-hook-binding-in-scope.ts
-const isHookBindingInScope = (node, query) => {
-	const { bindingName, hookName, destructureIndex } = query;
-	let cursor = node;
-	while (cursor) {
-		if (isNodeOfType(cursor, "BlockStatement") || isNodeOfType(cursor, "Program")) for (const statement of cursor.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-			for (const declarator of statement.declarations ?? []) {
-				if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-				if (!isHookCall$2(declarator.init, hookName)) continue;
-				if (destructureIndex !== void 0) {
-					if (!isNodeOfType(declarator.id, "ArrayPattern")) continue;
-					const elements = declarator.id.elements ?? [];
-					if (elements.length <= destructureIndex) continue;
-					const element = elements[destructureIndex];
-					if (isNodeOfType(element, "Identifier") && element.name === bindingName) return true;
-				} else if (isNodeOfType(declarator.id, "Identifier") && declarator.id.name === bindingName) return true;
-			}
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-use-state-setter-in-scope.ts
-const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node, {
-	bindingName: setterName,
-	hookName: "useState",
-	destructureIndex: 1
+//#region src/plugin/utils/define-retired-rule.ts
+const defineRetiredRule = (rule) => defineRule({
+	...rule,
+	defaultEnabled: false,
+	lifecycle: "retired",
+	create: () => ({})
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-cascading-set-state.ts
-const isAsyncFunctionLike = (node) => {
-	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.async);
-	return false;
-};
-const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
-	"forEach",
-	"map",
-	"filter",
-	"reduce",
-	"reduceRight",
-	"flatMap",
-	"some",
-	"every",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"sort"
-]);
-const runsOnEffectDispatch = (functionNode) => {
-	const parent = functionNode.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
-	const callee = parent.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(callee.property.name);
-};
-const isTerminatingStatement = (statement) => isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement");
-const analyzeBranchStatements = (branch, context) => analyzeStatementSequence(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch], context);
-const analyzeStatementSequence = (statements, context) => {
-	let fallThroughCount = 0;
-	let maxTerminatedCount = 0;
-	for (const statement of statements) {
-		if (isNodeOfType(statement, "IfStatement")) {
-			fallThroughCount += countMaxPathSetStateCalls(statement.test, context);
-			const thenSummary = analyzeBranchStatements(statement.consequent, context);
-			const elseSummary = statement.alternate ? analyzeBranchStatements(statement.alternate, context) : {
-				fallThroughCount: 0,
-				maxTerminatedCount: 0,
-				doAllPathsTerminate: false
-			};
-			maxTerminatedCount = Math.max(maxTerminatedCount, fallThroughCount + thenSummary.maxTerminatedCount, fallThroughCount + elseSummary.maxTerminatedCount);
-			if (thenSummary.doAllPathsTerminate && elseSummary.doAllPathsTerminate) return {
-				fallThroughCount: 0,
-				maxTerminatedCount,
-				doAllPathsTerminate: true
-			};
-			const fallThroughBranchCounts = [...thenSummary.doAllPathsTerminate ? [] : [thenSummary.fallThroughCount], ...elseSummary.doAllPathsTerminate ? [] : [elseSummary.fallThroughCount]];
-			fallThroughCount += Math.max(...fallThroughBranchCounts);
-			continue;
-		}
-		if (isTerminatingStatement(statement)) {
-			const terminatedPathCount = fallThroughCount + countMaxPathSetStateCalls(statement, context);
-			return {
-				fallThroughCount: 0,
-				maxTerminatedCount: Math.max(maxTerminatedCount, terminatedPathCount),
-				doAllPathsTerminate: true
-			};
-		}
-		fallThroughCount += countMaxPathSetStateCalls(statement, context);
-	}
-	return {
-		fallThroughCount,
-		maxTerminatedCount,
-		doAllPathsTerminate: false
-	};
-};
-const countStatementSequenceSetStateCalls = (statements, context) => {
-	const summary = analyzeStatementSequence(statements, context);
-	return Math.max(summary.fallThroughCount, summary.maxTerminatedCount);
-};
-const collectLocalHelperFunctions = (root) => {
-	const helpersByName = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		if (isNodeOfType(node, "FunctionDeclaration") && node.id) helpersByName.set(node.id.name, node);
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isFunctionLike$2(node.init)) helpersByName.set(node.id.name, node.init);
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isNodeOfType(node.init, "CallExpression") && isNodeOfType(node.init.callee, "Identifier") && node.init.callee.name === "useCallback" && node.init.arguments?.[0] && isFunctionLike$2(node.init.arguments[0])) helpersByName.set(node.id.name, node.init.arguments[0]);
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (item && typeof item === "object" && "type" in item) visit(item);
-			} else if (child && typeof child === "object" && "type" in child) visit(child);
-		}
-	};
-	visit(root);
-	return helpersByName;
-};
-const isWholesaleDelegationCall = (callNode, effectCallback) => {
-	const parent = callNode.parent;
-	if (!parent) return false;
-	if (parent === effectCallback) return true;
-	if (!isNodeOfType(parent, "ExpressionStatement")) return false;
-	return parent.parent === effectCallback.body;
-};
-const countFunctionBodySetStateCalls = (functionNode, context) => {
-	if (isAsyncFunctionLike(functionNode)) return 0;
-	const body = functionNode.body;
-	if (!body) return 0;
-	return countMaxPathSetStateCalls(body, context);
-};
-const countMaxPathSetStateCalls = (node, context) => {
-	if (!node || typeof node !== "object") return 0;
-	if (isFunctionLike$2(node)) return 0;
-	if (isNodeOfType(node, "BlockStatement") || isNodeOfType(node, "Program")) return countStatementSequenceSetStateCalls(node.body ?? [], context);
-	if (isNodeOfType(node, "IfStatement") || isNodeOfType(node, "ConditionalExpression")) {
-		const consequent = node.consequent;
-		const alternate = node.alternate;
-		const testCount = countMaxPathSetStateCalls(node.test, context);
-		const thenCount = countMaxPathSetStateCalls(consequent, context);
-		const elseCount = alternate ? countMaxPathSetStateCalls(alternate, context) : 0;
-		return testCount + Math.max(thenCount, elseCount);
-	}
-	if (isNodeOfType(node, "SwitchStatement")) {
-		let maxRunSetters = 0;
-		let currentRunSetters = 0;
-		for (const switchCase of node.cases ?? []) {
-			const consequent = switchCase.consequent ?? [];
-			let caseSetters = 0;
-			let runEnds = false;
-			for (const statement of consequent) {
-				caseSetters += countMaxPathSetStateCalls(statement, context);
-				if (isTerminatingStatement(statement)) runEnds = true;
-			}
-			currentRunSetters += caseSetters;
-			if (runEnds) {
-				if (currentRunSetters > maxRunSetters) maxRunSetters = currentRunSetters;
-				currentRunSetters = 0;
-			}
-		}
-		if (currentRunSetters > maxRunSetters) maxRunSetters = currentRunSetters;
-		return maxRunSetters;
-	}
-	if (isNodeOfType(node, "TryStatement")) {
-		const tryCount = countMaxPathSetStateCalls(node.block, context);
-		const catchCount = node.handler ? countMaxPathSetStateCalls(node.handler.body, context) : 0;
-		const finallyCount = node.finalizer ? countMaxPathSetStateCalls(node.finalizer, context) : 0;
-		return Math.max(tryCount, catchCount) + finallyCount;
-	}
-	if (isNodeOfType(node, "CallExpression") && isSetterCall(node) && isNodeOfType(node.callee, "Identifier") && isUseStateSetterInScope(node, node.callee.name)) {
-		let nestedSettersInArgs = 0;
-		for (const argument of node.arguments ?? []) nestedSettersInArgs += isFunctionLike$2(argument) ? countFunctionBodySetStateCalls(argument, context) : countMaxPathSetStateCalls(argument, context);
-		return 1 + nestedSettersInArgs;
-	}
-	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier")) {
-		const helperFunction = context.helpersByName.get(node.callee.name);
-		if (helperFunction && !context.activeHelpers.has(helperFunction) && isWholesaleDelegationCall(node, context.effectCallback)) {
-			context.activeHelpers.add(helperFunction);
-			let helperCount = countFunctionBodySetStateCalls(helperFunction, context);
-			context.activeHelpers.delete(helperFunction);
-			for (const argument of node.arguments ?? []) helperCount += countMaxPathSetStateCalls(argument, context);
-			return helperCount;
-		}
-	}
-	const countChild = (child) => {
-		if (isFunctionLike$2(child)) return runsOnEffectDispatch(child) ? countFunctionBodySetStateCalls(child, context) : 0;
-		return countMaxPathSetStateCalls(child, context);
-	};
-	let total = 0;
-	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
-		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && "type" in item) total += countChild(item);
-		} else if (child && typeof child === "object" && "type" in child) total += countChild(child);
-	}
-	return total;
-};
-const isInitOnlyEffect = (node) => {
-	const depsArg = node.arguments?.[1];
-	if (!depsArg) return false;
-	if (!isNodeOfType(depsArg, "ArrayExpression")) return false;
-	return (depsArg.elements ?? []).length === 0;
-};
-const DEV_ENV_FLAG_NAMES = new Set([
-	"DEV",
-	"PROD",
-	"MODE",
-	"NODE_ENV"
-]);
-const mentionsDevEnvFlag = (node) => {
-	if (!node || typeof node !== "object") return false;
-	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && DEV_ENV_FLAG_NAMES.has(node.property.name) && isNodeOfType(node.object, "MemberExpression") && isNodeOfType(node.object.property, "Identifier") && node.object.property.name === "env") return true;
-	const record = node;
-	for (const key of Object.keys(record)) {
-		if (key === "parent") continue;
-		const child = record[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && "type" in item && mentionsDevEnvFlag(item)) return true;
-		} else if (child && typeof child === "object" && "type" in child && mentionsDevEnvFlag(child)) return true;
-	}
-	return false;
-};
-const isDevOnlyGuardedEffect = (callback) => {
-	const body = callback.body;
-	if (!body || !isNodeOfType(body, "BlockStatement")) return false;
-	const firstStatement = (body.body ?? [])[0];
-	if (!firstStatement) return false;
-	if (!isNodeOfType(firstStatement, "IfStatement") || firstStatement.alternate) return false;
-	const consequent = firstStatement.consequent;
-	if (!(isTerminatingStatement(consequent) || isNodeOfType(consequent, "BlockStatement") && (consequent.body ?? []).some((inner) => isTerminatingStatement(inner)))) return false;
-	return mentionsDevEnvFlag(firstStatement.test);
-};
-const noCascadingSetState = defineRule({
+const noCascadingSetState = defineRetiredRule({
 	id: "no-cascading-set-state",
 	title: "Multiple setState calls in one effect",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Combine related updates in `useReducer` so one effect does not redraw the screen once per `setState` call.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		if (isInitOnlyEffect(node)) return;
-		const callback = getEffectCallback(node, context.scopes);
-		if (!callback) return;
-		if (isDevOnlyGuardedEffect(callback)) return;
-		const setStateCallCount = countFunctionBodySetStateCalls(callback, {
-			helpersByName: collectLocalHelperFunctions(findProgramRoot(node) ?? callback),
-			activeHelpers: /* @__PURE__ */ new Set(),
-			effectCallback: callback
-		});
-		if (setStateCallCount >= 3) context.report({
-			node,
-			message: `${setStateCallCount} setState calls in one useEffect redraw your screen each time they run together.`
-		});
-	} })
+	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
@@ -30617,6 +30367,9 @@ const noDirectMutationState = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/is-setter-identifier.ts
+const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-use-state-bindings.ts
 const collectUseStateBindings = (componentBody) => {
 	const bindings = [];
@@ -32887,6 +32640,9 @@ const noEventTriggerState = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-setter-call.ts
+const isSetterCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && isSetterIdentifier(node.callee.name);
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-fetch-in-effect.ts
 const IMPORT_INITIALIZER_TYPES = new Set([
 	"ImportSpecifier",
@@ -47248,6 +47004,37 @@ const containsLocaleEnvironmentRead = (expression) => {
 	return readsLocaleEnvironment;
 };
 //#endregion
+//#region src/plugin/utils/is-hook-binding-in-scope.ts
+const isHookBindingInScope = (node, query) => {
+	const { bindingName, hookName, destructureIndex } = query;
+	let cursor = node;
+	while (cursor) {
+		if (isNodeOfType(cursor, "BlockStatement") || isNodeOfType(cursor, "Program")) for (const statement of cursor.body ?? []) {
+			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
+			for (const declarator of statement.declarations ?? []) {
+				if (!isNodeOfType(declarator.init, "CallExpression")) continue;
+				if (!isHookCall$2(declarator.init, hookName)) continue;
+				if (destructureIndex !== void 0) {
+					if (!isNodeOfType(declarator.id, "ArrayPattern")) continue;
+					const elements = declarator.id.elements ?? [];
+					if (elements.length <= destructureIndex) continue;
+					const element = elements[destructureIndex];
+					if (isNodeOfType(element, "Identifier") && element.name === bindingName) return true;
+				} else if (isNodeOfType(declarator.id, "Identifier") && declarator.id.name === bindingName) return true;
+			}
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-use-state-setter-in-scope.ts
+const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node, {
+	bindingName: setterName,
+	hookName: "useState",
+	destructureIndex: 1
+});
+//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
@@ -48937,14 +48724,6 @@ const rerenderTransitionsScroll = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/define-retired-rule.ts
-const defineRetiredRule = (rule) => defineRule({
-	...rule,
-	defaultEnabled: false,
-	lifecycle: "retired",
-	create: () => ({})
-});
-//#endregion
 //#region src/plugin/rules/react-native/rn-animate-layout-property.ts
 const rnAnimateLayoutProperty = defineRetiredRule({
 	id: "rn-animate-layout-property",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.55cebeb",
+  "version": "0.7.6-dev.5699529",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",