oxlint-plugin-react-doctor 0.7.2-dev.08b768b → 0.7.2-dev.11e9c87

package/dist/index.js

@@ -532,12 +532,6 @@ const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
 ]);
 const TIMER_CALLEE_NAMES_REQUIRING_CLEANUP = new Set(["setInterval", "setTimeout"]);
 const TIMER_CLEANUP_CALLEE_NAMES = new Set(["clearInterval", "clearTimeout"]);
-const SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP = new Set([
-	"WebSocket",
-	"EventSource",
-	"BroadcastChannel",
-	"RTCPeerConnection"
-]);
 const MUTABLE_GLOBAL_ROOTS = new Set([
 	"location",
 	"window",
@@ -693,10 +687,7 @@ const GLOBAL_RELEASE_METHOD_NAMES = new Set([
 	"unwatch",
 	"unlisten",
 	"unsub",
-	"abort",
-	"disconnect",
-	"unobserve",
-	"close"
+	"abort"
 ]);
 const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
 	"remove",
@@ -7657,95 +7648,6 @@ const displayName = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-react-hook-name.ts
-const isReactHookName = (name) => {
-	if (!name.startsWith("use")) return false;
-	if (name.length === 3) return true;
-	const fourthCharacter = name.charCodeAt(3);
-	return fourthCharacter >= 65 && fourthCharacter <= 90 || fourthCharacter >= 48 && fourthCharacter <= 57;
-};
-//#endregion
-//#region src/plugin/utils/is-react-component-or-hook-name.ts
-const isReactComponentOrHookName = (name) => isReactComponentName(name) || isReactHookName(name);
-//#endregion
-//#region src/plugin/utils/component-or-hook-display-name.ts
-const hocWrapperCalleeName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const displayNameFromFunctionBinding = (functionNode) => {
-	let current = functionNode;
-	for (;;) {
-		const parent = current.parent;
-		if (parent && isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === current) {
-			const calleeName = hocWrapperCalleeName(parent.callee);
-			if (calleeName && COMPONENT_HOC_WRAPPER_NAMES.has(calleeName)) {
-				current = parent;
-				continue;
-			}
-		}
-		break;
-	}
-	const binding = current.parent;
-	if (binding && isNodeOfType(binding, "VariableDeclarator") && isNodeOfType(binding.id, "Identifier") && binding.init === current) return isReactComponentOrHookName(binding.id.name) ? binding.id.name : null;
-	return null;
-};
-const componentOrHookDisplayNameForFunction = (functionNode) => {
-	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return isReactComponentOrHookName(functionNode.id.name) ? functionNode.id.name : null;
-	return displayNameFromFunctionBinding(functionNode);
-};
-//#endregion
-//#region src/plugin/utils/find-enclosing-function.ts
-const findEnclosingFunction = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$1(cursor)) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/enclosing-component-or-hook-name.ts
-const enclosingComponentOrHookName = (node) => {
-	const functionNode = findEnclosingFunction(node);
-	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
-};
-//#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		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 true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
@@ -7897,17 +7799,6 @@ const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSub
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
-const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
-const RESOURCE_NOUN_BY_KIND = {
-	subscribe: "subscription",
-	timer: "timer",
-	socket: "connection"
-};
-const isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
-const isSubscribeOrObserveCall = (node) => {
-	if (isSubscribeLikeCallExpression(node)) return true;
-	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
-};
 const findSubscribeLikeUsages = (callback) => {
 	const usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
@@ -7919,14 +7810,6 @@ const findSubscribeLikeUsages = (callback) => {
 	}
 	walkAst(callback, (child) => {
 		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
-		if (isSocketConstruction(child)) {
-			usages.push({
-				kind: "socket",
-				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
-			});
-			return;
-		}
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (isNodeOfType(child.callee, "Identifier") && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(child.callee.name)) {
 			usages.push({
@@ -7936,7 +7819,7 @@ const findSubscribeLikeUsages = (callback) => {
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) usages.push({
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) usages.push({
 			kind: "subscribe",
 			node: child,
 			resourceName: child.callee.property.name
@@ -7959,12 +7842,7 @@ const collectCleanupBindings = (effectCallback) => {
 			const bindingName = declarator.id.name;
 			bindings.effectScopeVariableNames.add(bindingName);
 			const init = declarator.init;
-			if (!init) continue;
-			if (isSocketConstruction(init)) {
-				bindings.subscriptionNames.add(bindingName);
-				continue;
-			}
-			if (!isNodeOfType(init, "CallExpression")) continue;
+			if (!init || !isNodeOfType(init, "CallExpression")) continue;
 			if (isSubscribeLikeCallExpression(init)) {
 				bindings.subscriptionNames.add(bindingName);
 				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
@@ -8016,168 +7894,26 @@ const effectHasCleanupReturn = (callback, usages) => {
 	});
 	return didFindCleanupReturn;
 };
-const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
-const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isNodeOfType(property, "Property") && isNodeOfType(property.key, "Identifier") && (property.key.name === "signal" || property.key.name === "once" && isNodeOfType(property.value, "Literal") && property.value.value === true)));
-const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
-	["addEventListener", new Set(["removeEventListener", "abort"])],
-	["addListener", new Set([
-		"removeListener",
-		"off",
-		"abort"
-	])],
-	["on", new Set([
-		"off",
-		"removeListener",
-		"on"
-	])],
-	["subscribe", new Set(["unsubscribe", "unsub"])],
-	["sub", new Set(["unsub", "unsubscribe"])],
-	["watch", new Set(["unwatch", "close"])],
-	["listen", new Set(["unlisten", "close"])],
-	[OBSERVER_REGISTRATION_METHOD_NAME, new Set(["disconnect", "unobserve"])]
-]);
-const UNIVERSAL_RELEASE_VERB_NAMES = new Set([
-	"cleanup",
-	"dispose",
-	"destroy",
-	"teardown"
-]);
-const SOCKET_RELEASE_VERB_NAMES = new Set(["close"]);
-const INTERVAL_RELEASE_VERB_NAMES = new Set(["clearInterval"]);
-const getReleaseVerbName = (node) => {
-	if (!isReleaseLikeCall(node, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return null;
-	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
-	if (!isNodeOfType(callNode, "CallExpression")) return null;
-	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const bodyContainsPairedReleaseCall = (body, pairedVerbNames) => {
-	let didFindPairedRelease = false;
-	walkAst(body, (child) => {
-		if (didFindPairedRelease) return false;
-		if (child !== body && isFunctionLike$1(child)) return false;
-		const releaseVerbName = getReleaseVerbName(child);
-		if (releaseVerbName !== null && matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) {
-			didFindPairedRelease = true;
-			return false;
-		}
-	});
-	return didFindPairedRelease;
-};
-const fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
-const collectFileReleaseVerbNames = (anyNode) => {
-	let programNode = anyNode;
-	while (programNode.parent) programNode = programNode.parent;
-	const cached = fileReleaseVerbNamesCache.get(programNode);
-	if (cached) return cached;
-	const releaseVerbNames = /* @__PURE__ */ new Set();
-	walkAst(programNode, (child) => {
-		const releaseVerbName = getReleaseVerbName(child);
-		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
-	});
-	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
-	return releaseVerbNames;
-};
-const fileContainsPairedReleaseCall = (registrationCall, registrationVerbName) => {
-	const fileReleaseVerbNames = collectFileReleaseVerbNames(registrationCall);
-	const pairedVerbNames = PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(registrationVerbName);
-	if (!pairedVerbNames) return fileReleaseVerbNames.size > 0;
-	for (const releaseVerbName of fileReleaseVerbNames) if (matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return true;
-	return false;
-};
-const findRetainedFunctionLeak = (retainedFunction) => {
-	if (!isFunctionLike$1(retainedFunction)) return null;
-	const body = retainedFunction.body;
-	if (!body) return null;
-	let leak = null;
-	walkAst(body, (child) => {
-		if (leak !== null) return false;
-		if (isFunctionLike$1(child)) return false;
-		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
-			leak = {
-				kind: "socket",
-				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
-			};
-			return false;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
-			leak = {
-				kind: "timer",
-				node: child,
-				resourceName: "setInterval"
-			};
-			return false;
-		}
-		if (isSubscribeOrObserveCall(child) && isResultDiscardedCall(child)) {
-			const registrationVerbName = isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : "subscribe";
-			if (!hasSelfReleasingListenerOptions(child) && !fileContainsPairedReleaseCall(child, registrationVerbName)) leak = {
-				kind: "subscribe",
-				node: child,
-				resourceName: registrationVerbName
-			};
-			return false;
-		}
-	});
-	return leak;
-};
-const isRetainedComponentScopeFunction = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration")) return enclosingComponentOrHookName(functionNode) !== null;
-	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression")) return false;
-	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
-	return enclosingComponentOrHookName(functionNode) !== null;
-};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
 	severity: "error",
 	tags: ["test-noise"],
-	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
-	create: (context) => {
-		const reportRetainedLeak = (retainedFunction) => {
-			const leak = findRetainedFunctionLeak(retainedFunction);
-			if (!leak) return;
-			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
-			context.report({
-				node: leak.node,
-				message: `\`${leak.resourceName}\` creates a ${resourceNoun} in a function that outlives the render, with no cleanup path. Store the handle and release it, or move this into a useEffect that returns cleanup, so it does not leak after unmount.`
-			});
-		};
-		return {
-			CallExpression(node) {
-				if (isHookCall$2(node, "useCallback")) {
-					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback) reportRetainedLeak(retainedCallback);
-					return;
-				}
-				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-				const callback = getEffectCallback(node);
-				if (!callback) return;
-				const usages = findSubscribeLikeUsages(callback);
-				if (usages.length === 0) return;
-				if (effectHasCleanupReturn(callback, usages)) return;
-				const firstUsage = usages[0];
-				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				context.report({
-					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
-				});
-			},
-			FunctionDeclaration(node) {
-				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
-			},
-			ArrowFunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
-			},
-			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
-			}
-		};
-	}
+	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, or `return unsubscribe` if the subscribe call already gave you one.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		const callback = getEffectCallback(node);
+		if (!callback) return;
+		const usages = findSubscribeLikeUsages(callback);
+		if (usages.length === 0) return;
+		if (effectHasCleanupReturn(callback, usages)) return;
+		const firstUsage = usages[0];
+		const resourceKind = firstUsage.kind === "timer" ? "timer" : "subscription";
+		context.report({
+			node,
+			message: `\`${firstUsage.resourceName}\` creates a ${resourceKind} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+		});
+	} })
 });
 //#endregion
 //#region src/plugin/semantic/scope-analysis.ts
@@ -8736,6 +8472,17 @@ const closureCaptures = (functionNode, scopes) => {
 	return computedCaptures;
 };
 //#endregion
+//#region src/plugin/utils/is-react-hook-name.ts
+const isReactHookName = (name) => {
+	if (!name.startsWith("use")) return false;
+	if (name.length === 3) return true;
+	const fourthCharacter = name.charCodeAt(3);
+	return fourthCharacter >= 65 && fourthCharacter <= 90 || fourthCharacter >= 48 && fourthCharacter <= 57;
+};
+//#endregion
+//#region src/plugin/utils/is-react-component-or-hook-name.ts
+const isReactComponentOrHookName = (name) => isReactComponentName(name) || isReactHookName(name);
+//#endregion
 //#region src/plugin/utils/is-react-hoc-callback-argument.ts
 const reactHocCalleeName = (callee) => {
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
@@ -11550,6 +11297,16 @@ const collectHandlerReferencedNames = (root) => {
 	return names;
 };
 //#endregion
+//#region src/plugin/utils/find-enclosing-function.ts
+const findEnclosingFunction = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$1(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
 const getFunctionBindingIdentifier = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
@@ -21354,7 +21111,7 @@ const isObjectUrlLifecycleEffect = (effectFn) => {
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
 	title: "State synced to a prop inside an effect",
-	severity: "warn",
+	severity: "error",
 	tags: ["test-noise"],
 	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
@@ -23722,6 +23479,40 @@ const noCloneElement = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/component-or-hook-display-name.ts
+const hocWrapperCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const displayNameFromFunctionBinding = (functionNode) => {
+	let current = functionNode;
+	for (;;) {
+		const parent = current.parent;
+		if (parent && isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === current) {
+			const calleeName = hocWrapperCalleeName(parent.callee);
+			if (calleeName && COMPONENT_HOC_WRAPPER_NAMES.has(calleeName)) {
+				current = parent;
+				continue;
+			}
+		}
+		break;
+	}
+	const binding = current.parent;
+	if (binding && isNodeOfType(binding, "VariableDeclarator") && isNodeOfType(binding.id, "Identifier") && binding.init === current) return isReactComponentOrHookName(binding.id.name) ? binding.id.name : null;
+	return null;
+};
+const componentOrHookDisplayNameForFunction = (functionNode) => {
+	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return isReactComponentOrHookName(functionNode.id.name) ? functionNode.id.name : null;
+	return displayNameFromFunctionBinding(functionNode);
+};
+//#endregion
+//#region src/plugin/utils/enclosing-component-or-hook-name.ts
+const enclosingComponentOrHookName = (node) => {
+	const functionNode = findEnclosingFunction(node);
+	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
 const MESSAGE$30 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
 const CONTEXT_MODULES = [
@@ -24735,26 +24526,6 @@ const collectValueIdentifierNames = (node, into, localBindingNames = /* @__PURE_
 		} else if (child && typeof child === "object" && "type" in child) collectValueIdentifierNames(child, into, localBindingNames);
 	}
 };
-const flattenGuardedStatements = (statements) => {
-	const flattened = [];
-	for (const statement of statements) {
-		if (isNodeOfType(statement, "ExpressionStatement")) {
-			flattened.push(statement);
-			continue;
-		}
-		if (isNodeOfType(statement, "IfStatement")) {
-			for (const branch of [statement.consequent, statement.alternate]) {
-				if (!branch) continue;
-				const flattenedBranch = flattenGuardedStatements(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch]);
-				if (flattenedBranch === null) return null;
-				flattened.push(...flattenedBranch);
-			}
-			continue;
-		}
-		return null;
-	}
-	return flattened;
-};
 const noDerivedStateEffect = defineRule({
 	id: "no-derived-state-effect",
 	title: "Derived state stored in an effect",
@@ -24786,8 +24557,8 @@ const noDerivedStateEffect = defineRule({
 			}
 		}
 		if (sawAnyDep && allDepsAreInitialOnly) return;
-		const statements = flattenGuardedStatements(getCallbackStatements(callback));
-		if (statements === null || statements.length === 0) return;
+		const statements = getCallbackStatements(callback);
+		if (statements.length === 0) return;
 		if (!statements.every((statement) => {
 			if (!isNodeOfType(statement, "ExpressionStatement")) return false;
 			const expression = statement.expression;
@@ -29266,7 +29037,7 @@ const extractReturnTypeAnnotation = (returnType) => {
 const noJsxElementType = defineRule({
 	id: "no-jsx-element-type",
 	title: "No JSX.Element",
-	severity: "warn",
+	severity: "error",
 	recommendation: "Replace `JSX.Element` with `React.ReactNode`. `JSX.Element` is too narrow: it excludes `null`, strings, numbers, and fragments that components commonly return.",
 	create: (context) => {
 		let isJsxImported = false;
@@ -30308,6 +30079,40 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		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 true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
 const LODASH_MUTATOR_NAMES = new Set([
 	"set",
@@ -30749,7 +30554,7 @@ const noNestedComponentDefinition = defineRule({
 	id: "no-nested-component-definition",
 	title: "Component defined inside another component",
 	tags: ["test-noise", "react-jsx-only"],
-	severity: "warn",
+	severity: "error",
 	category: "Correctness",
 	recommendation: "Move it to module scope or a separate file so React does not recreate the component and erase its state on every parent render.",
 	create: (context) => {
@@ -32641,7 +32446,7 @@ const noReactDomDeprecatedApis = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-react19-deprecated-apis.ts
-const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is dead weight in React 19, since ref is a normal prop now, so drop it & pass ref straight through."]]);
+const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is dead weight in React 19, since ref is a normal prop now, so drop it & pass ref straight through."], ["useContext", "useContext is replaced by `use()` in React 19, which reads context inside ifs & loops too, so switch to `import { use } from 'react'`."]]);
 const isVendoredShadcnUiFilename = (rawFilename) => {
 	if (!rawFilename) return false;
 	const filename = rawFilename.replaceAll("\\", "/");
@@ -32679,7 +32484,7 @@ const noReact19DeprecatedApis = defineRule({
 	requires: ["react:19"],
 	tags: ["test-noise", "migration-hint"],
 	severity: "warn",
-	recommendation: "Pass `ref` as a normal prop on function components, since `forwardRef` isn't needed in React 19. Only runs on React 19+ projects.",
+	recommendation: "Pass `ref` as a normal prop on function components, since `forwardRef` isn't needed in React 19. Replace `useContext(X)` with `use(X)`. Only runs on React 19+ projects.",
 	create: (context) => {
 		if (isVendoredShadcnUiFilename(context.filename)) return {};
 		return deprecatedReactImportRule.create(buildOncePerApiContext(context));
@@ -33003,11 +32808,34 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
+const tracesToPropOrParameter = (symbol, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	if (!symbol || visitedSymbols.has(symbol)) return false;
+	visitedSymbols.add(symbol);
+	if (isComponentParameterSymbol(symbol)) return true;
+	if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+	const source = symbol.initializer;
+	if (!source) return false;
+	return initializerRootsInProps(source, scopes, visitedSymbols);
+};
+const initializerRootsInProps = (node, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	if (isNodeOfType(node, "LogicalExpression")) return initializerRootsInProps(node.left, scopes, visitedSymbols) || initializerRootsInProps(node.right, scopes, visitedSymbols);
+	if (isNodeOfType(node, "ConditionalExpression")) return initializerRootsInProps(node.consequent, scopes, visitedSymbols) || initializerRootsInProps(node.alternate, scopes, visitedSymbols);
+	return rootsInProps(node, scopes, visitedSymbols);
+};
+const rootsInProps = (node, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	let current = node;
+	while (isNodeOfType(current, "MemberExpression")) {
+		if (isNodeOfType(current.object, "ThisExpression") && isNodeOfType(current.property, "Identifier") && current.property.name === "props") return true;
+		current = current.object;
+	}
+	if (isNodeOfType(current, "Identifier")) return tracesToPropOrParameter(scopes.symbolFor(current), scopes, visitedSymbols);
+	return false;
+};
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
+		if (isNodeOfType(cursor, "ClassDeclaration") || isNodeOfType(cursor, "ClassExpression")) return true;
 		if (isFunctionLike$1(cursor) && isComponentFunction$1(cursor)) return true;
-		if (isEs5Component(cursor) || isEs6Component(cursor)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
@@ -33020,21 +32848,21 @@ const functionBodyOf = (node) => {
 const containsHookCall = (body) => {
 	let found = false;
 	walkAst(body, (child) => {
-		if (found) return false;
-		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
+		if (found) return;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const name = getCalleeName$2(child);
 		if (name && isReactHookName(name)) found = true;
 	});
 	return found;
 };
-const isHookCallingRenderHelper = (symbol) => {
+const isModuleScopeHookFreeHelper = (symbol) => {
 	if (!symbol) return false;
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "FunctionDeclaration") && !isNodeOfType(declaration, "VariableDeclarator")) return false;
 	const body = functionBodyOf(declaration);
 	if (!body) return false;
-	return containsHookCall(body);
+	if (findEnclosingFunction(declaration) !== null) return false;
+	return !containsHookCall(body);
 };
 const noRenderInRender = defineRule({
 	id: "no-render-in-render",
@@ -33045,11 +32873,18 @@ const noRenderInRender = defineRule({
 	create: (context) => ({ JSXExpressionContainer(node) {
 		const expression = node.expression;
 		if (!isNodeOfType(expression, "CallExpression")) return;
-		if (!isNodeOfType(expression.callee, "Identifier")) return;
-		const calleeName = expression.callee.name;
-		if (!RENDER_FUNCTION_PATTERN.test(calleeName)) return;
+		let calleeName = null;
+		if (isNodeOfType(expression.callee, "Identifier")) calleeName = expression.callee.name;
+		else if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier")) calleeName = expression.callee.property.name;
+		if (!calleeName || !RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		if (!isInsideComponentContext(node)) return;
-		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee))) return;
+		if (isNodeOfType(expression.callee, "Identifier")) {
+			const calleeSymbol = context.scopes.symbolFor(expression.callee);
+			if (tracesToPropOrParameter(calleeSymbol, context.scopes)) return;
+			if (isModuleScopeHookFreeHelper(calleeSymbol)) return;
+		} else if (isNodeOfType(expression.callee, "MemberExpression")) {
+			if (rootsInProps(expression.callee.object, context.scopes)) return;
+		}
 		context.report({
 			node: expression,
 			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
@@ -36398,28 +36233,6 @@ const isTriviallyCheapExpression = (node) => {
 	if (isNodeOfType(innerExpression, "MemberExpression")) return false;
 	return true;
 };
-const isTrivialContainerLiteral = (node) => {
-	if (!node) return false;
-	const innerExpression = stripParenExpression(node);
-	if (isNodeOfType(innerExpression, "ArrayExpression")) return (innerExpression.elements ?? []).every((element) => element !== null && isSimpleExpression(element));
-	if (isNodeOfType(innerExpression, "ObjectExpression")) return (innerExpression.properties ?? []).every((property) => isNodeOfType(property, "Property") && !property.computed && isSimpleExpression(property.value));
-	return false;
-};
-const isNonEscapingRead = (identifier) => {
-	const parentNode = identifier.parent;
-	return isNodeOfType(parentNode, "MemberExpression") && parentNode.object === identifier;
-};
-const isMemoIdentityUnused = (memoCallNode, scopes) => {
-	const parentNode = memoCallNode.parent;
-	if (isNodeOfType(parentNode, "ExpressionStatement")) return true;
-	if (!isNodeOfType(parentNode, "VariableDeclarator") || parentNode.init !== memoCallNode) return false;
-	const bindingTarget = parentNode.id;
-	if (isNodeOfType(bindingTarget, "ArrayPattern") || isNodeOfType(bindingTarget, "ObjectPattern")) return true;
-	if (!isNodeOfType(bindingTarget, "Identifier")) return false;
-	const symbol = scopes.symbolFor(bindingTarget);
-	if (!symbol) return false;
-	return symbol.references.every((reference) => reference.flag === "read" && isNonEscapingRead(reference.identifier));
-};
 const noUsememoSimpleExpression = defineRule({
 	id: "no-usememo-simple-expression",
 	title: "useMemo on a cheap value",
@@ -36441,17 +36254,9 @@ const noUsememoSimpleExpression = defineRule({
 		let returnExpression = null;
 		if (!isNodeOfType(callback.body, "BlockStatement")) returnExpression = callback.body;
 		else if (callback.body.body?.length === 1 && isNodeOfType(callback.body.body[0], "ReturnStatement")) returnExpression = callback.body.body[0].argument;
-		if (!returnExpression) return;
-		if (isTriviallyCheapExpression(returnExpression)) {
-			context.report({
-				node,
-				message: "This costs more than it saves because useMemo is wrapping a value that's already cheap, so remove the useMemo"
-			});
-			return;
-		}
-		if (isTrivialContainerLiteral(returnExpression) && isMemoIdentityUnused(node, context.scopes)) context.report({
+		if (returnExpression && isTriviallyCheapExpression(returnExpression)) context.report({
 			node,
-			message: "This useMemo rebuilds a tiny literal whose reference is never relied on, so remove the useMemo and build the value inline"
+			message: "This costs more than it saves because useMemo is wrapping a value that's already cheap, so remove the useMemo"
 		});
 	} })
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.2-dev.08b768b",
+  "version": "0.7.2-dev.11e9c87",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",