oxlint-plugin-react-doctor 0.7.7-dev.1043416 → 0.7.7-dev.287dff7

package/dist/index.js

@@ -11673,25 +11673,6 @@ const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(
 //#region src/plugin/utils/is-event-handler-attribute.ts
 const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
 //#endregion
-//#region src/plugin/utils/is-ast-descendant.ts
-/**
-* True when `inner` is `outer` itself or any descendant in the AST
-* `parent` chain. Walks `inner.parent` upward and stops at either a
-* match (`true`) or the chain's root (`false`).
-*
-* Was duplicated byte-identical in:
-* - exhaustive-deps-symbol-stability.ts
-* - semantic/closure-captures.ts
-*/
-const isAstDescendant = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/utils/react-ref-origin.ts
 const resolveReactRefSymbol = (memberExpression, scopes) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
@@ -12341,39 +12322,26 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	});
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
-const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => {
-	if (usage.handleKey === null) return null;
-	const doesTestRequireLiveHandle = (test) => {
-		if (resolveExpressionKey(test, context) === usage.handleKey) return true;
-		const unwrappedTest = stripParenExpression(test);
-		if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
-		const isNullishOperand = (operand) => {
-			const unwrappedOperand = stripParenExpression(operand);
-			return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
-		};
-		return resolveExpressionKey(unwrappedTest.left, context) === usage.handleKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === usage.handleKey && isNullishOperand(unwrappedTest.left);
-	};
-	let ancestor = releaseCall.parent;
-	while (ancestor && ancestor !== owner) {
-		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (ancestor.alternate !== null || !doesTestRequireLiveHandle(ancestor.test) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
-			return ancestor;
-		}
-		ancestor = ancestor.parent;
-	}
-	return null;
-};
 const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
 	const functionCfg = context.cfg.cfgFor(callback);
 	const usageBlock = functionCfg?.blockOf(usage.node);
 	const usageStart = getRangeStart(usage.node);
 	if (!functionCfg || !usageBlock || usageStart === null) return false;
+	const findHandleGuard = (releaseCall) => {
+		if (usage.handleKey === null) return null;
+		let ancestor = releaseCall.parent;
+		while (ancestor && ancestor !== callback.body) {
+			if (isNodeOfType(ancestor, "IfStatement")) return ancestor.alternate === null && resolveExpressionKey(ancestor.test, context) === usage.handleKey && getRangeStart(ancestor) !== null && (getRangeStart(ancestor) ?? usageStart) < usageStart ? ancestor : null;
+			ancestor = ancestor.parent;
+		}
+		return null;
+	};
 	const matchingReleaseAnchors = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const releaseStart = getRangeStart(child);
-		const handleGuard = findDirectHandleGuardForRelease(child, callback, usage, context);
+		const handleGuard = findHandleGuard(child);
 		if (releaseStart === null || releaseStart >= usageStart || functionCfg.blockOf(child) !== usageBlock && !handleGuard) return;
 		if (doesReleaseCallMatchUsage(child, usage, context)) {
 			matchingReleaseAnchors.push(handleGuard ?? child);
@@ -12403,12 +12371,12 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	return didFindUnmountCleanup;
 };
 const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
-const collectBlockingBooleanStates = (expression, blockedExpressionValue, guardNode, context) => {
+const collectBlockingBooleanStates = (expression, blockedExpressionValue, context) => {
 	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, guardNode, context);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, context);
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
 		if (!(unwrappedExpression.operator === "||" && blockedExpressionValue || unwrappedExpression.operator === "&&" && !blockedExpressionValue)) return [];
-		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, guardNode, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, guardNode, context)];
+		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, context)];
 	}
 	if (isNodeOfType(unwrappedExpression, "BinaryExpression") && [
 		"===",
@@ -12419,59 +12387,35 @@ const collectBlockingBooleanStates = (expression, blockedExpressionValue, guardN
 		const leftValue = readStaticBoolean(unwrappedExpression.left);
 		const rightValue = readStaticBoolean(unwrappedExpression.right);
 		const booleanValue = leftValue ?? rightValue;
-		const comparedExpression = leftValue === null ? unwrappedExpression.left : unwrappedExpression.right;
-		const comparedKey = resolveExpressionKey(comparedExpression, context);
+		const comparedKey = resolveExpressionKey(leftValue === null ? unwrappedExpression.left : unwrappedExpression.right, context);
 		if (booleanValue === null || comparedKey === null) return [];
-		const isEquality = unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==";
 		return [{
-			bindingIdentifier: isNodeOfType(comparedExpression, "Identifier") ? context.scopes.symbolFor(comparedExpression)?.bindingIdentifier ?? null : null,
-			guardNode,
 			key: comparedKey,
-			value: isEquality === blockedExpressionValue ? booleanValue : !booleanValue
+			value: (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") === blockedExpressionValue ? booleanValue : !booleanValue
 		}];
 	}
 	const expressionKey = resolveExpressionKey(unwrappedExpression, context);
 	return expressionKey === null ? [] : [{
-		bindingIdentifier: isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression)?.bindingIdentifier ?? null : null,
-		guardNode,
 		key: expressionKey,
 		value: blockedExpressionValue
 	}];
 };
-const canNodeReachLaterNodeWithinFunction = (sourceNode, targetNode, owner, context) => {
-	const functionCfg = context.cfg.cfgFor(owner);
-	const sourceBlock = functionCfg?.blockOf(sourceNode);
-	const targetBlock = functionCfg?.blockOf(targetNode);
-	const sourceStart = getRangeStart(sourceNode);
-	const targetStart = getRangeStart(targetNode);
-	if (!functionCfg || !sourceBlock || !targetBlock || sourceStart === null || targetStart === null) return true;
-	if (!isNodeReachableWithinFunction(sourceNode, context)) return false;
-	if (sourceBlock === targetBlock) return sourceStart < targetStart;
-	const visitedBlocks = new Set([sourceBlock]);
-	const pendingBlocks = [sourceBlock];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		for (const edge of currentBlock.successors) {
-			if (edge.to === targetBlock) return true;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
+const isDirectEarlyReturnConsequent = (ifStatement) => {
+	if (!isNodeOfType(ifStatement, "IfStatement") || ifStatement.alternate) return false;
+	if (isNodeOfType(ifStatement.consequent, "ReturnStatement")) return true;
+	return isNodeOfType(ifStatement.consequent, "BlockStatement") && ifStatement.consequent.body.length === 1 && isNodeOfType(ifStatement.consequent.body[0], "ReturnStatement");
 };
 const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
 	if (!isFunctionLike$1(callback) || callback.async) return [];
 	const guardStates = [];
 	walkAst(callback.body, (child) => {
 		if (child !== callback.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "IfStatement") && !child.alternate && !canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, callback, context) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, child, context));
+		if (isNodeOfType(child, "IfStatement") && isDirectEarlyReturnConsequent(child) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, context));
 	});
 	let descendant = usageNode;
 	let ancestor = descendant.parent;
 	while (ancestor && ancestor !== callback) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, ancestor, context));
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, context));
 		descendant = ancestor;
 		ancestor = ancestor.parent;
 	}
@@ -12480,7 +12424,7 @@ const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
 const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
 	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
 	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-	if (!cleanupFunction || !isFunctionLike$1(cleanupFunction) || cleanupFunction.async || cleanupFunction.generator) return false;
+	if (!cleanupFunction || !isFunctionLike$1(cleanupFunction) || cleanupFunction.async) return false;
 	let didInvalidateGuard = false;
 	walkAst(cleanupFunction.body, (child) => {
 		if (didInvalidateGuard) return false;
@@ -12509,110 +12453,11 @@ const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, co
 	});
 	return didWriteGuard;
 };
-const canInterruptionReachUsageThroughCatch = (interruptionNode, usageNode, owner, context) => {
-	let descendant = interruptionNode;
-	let ancestor = descendant.parent;
-	while (ancestor && ancestor !== owner) {
-		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === descendant && ancestor.handler && canNodeReachLaterNodeWithinFunction(ancestor.handler.body, usageNode, owner, context)) return true;
-		descendant = ancestor;
-		ancestor = ancestor.parent;
-	}
-	return false;
-};
-const isEffectLocalLifecycleGuard = (callback, guardState, cleanupFunctions, context) => {
-	if (!guardState.bindingIdentifier) return false;
-	const guardSymbol = context.scopes.symbolFor(guardState.bindingIdentifier);
-	if (!guardSymbol || guardSymbol.kind !== "let" && guardSymbol.kind !== "var" || !isNodeOfType(guardSymbol.declarationNode, "VariableDeclarator") || findEnclosingFunction$1(guardSymbol.declarationNode) !== callback) return false;
-	return guardSymbol.references.every((reference) => {
-		if (!isWithinAssignmentTarget(reference.identifier)) return true;
-		const assignmentTarget = findTransparentExpressionRoot(reference.identifier);
-		const assignment = assignmentTarget.parent;
-		return isNodeOfType(assignment, "AssignmentExpression") && assignment.operator === "=" && assignment.left === assignmentTarget && readStaticBoolean(assignment.right) === guardState.value && cleanupFunctions.includes(findEnclosingFunction$1(assignment) ?? assignment);
-	});
-};
-const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, context) => {
-	if (!isFunctionLike$1(callback)) return true;
-	const guardStart = getRangeStart(guardState.guardNode);
-	const usageStart = getRangeStart(usageNode);
-	if (guardStart === null || usageStart === null) return true;
-	let hasPotentialInterruption = false;
-	walkAst(callback.body, (child) => {
-		if (hasPotentialInterruption) return false;
-		if (child !== callback.body && isFunctionLike$1(child)) return false;
-		const childStart = getRangeStart(child);
-		if (childStart === null || childStart <= guardStart || childStart >= usageStart) return;
-		if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression")) {
-			if (canNodeReachLaterNodeWithinFunction(child, usageNode, callback, context) || canInterruptionReachUsageThroughCatch(child, usageNode, callback, context)) {
-				hasPotentialInterruption = true;
-				return false;
-			}
-		}
-	});
-	return hasPotentialInterruption;
-};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
-	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
-	const usageExpression = findTransparentExpressionRoot(usage.node);
-	const usageAssignment = usageExpression.parent;
-	if (!isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !isNodeOfType(usageAssignment.left, "Identifier")) return false;
-	const handleSymbol = context.scopes.symbolFor(usageAssignment.left);
-	if (!handleSymbol || handleSymbol.kind !== "let" && handleSymbol.kind !== "var" || !isNodeOfType(handleSymbol.declarationNode, "VariableDeclarator") || findEnclosingFunction$1(handleSymbol.declarationNode) !== callback) return false;
-	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
-		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
-		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
-	});
-	if (cleanupFunctions.length !== cleanupReturns.length) return false;
-	const globalReleaseProofsByCleanup = /* @__PURE__ */ new Map();
-	for (const cleanupFunction of cleanupFunctions) {
-		if (!isFunctionLike$1(cleanupFunction)) return false;
-		const globalReleaseProofs = [];
-		walkAst(cleanupFunction.body, (child) => {
-			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
-			if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && context.scopes.isGlobalReference(child.callee) && doesReleaseCallMatchUsage(child, usage, context)) {
-				const handleGuard = findDirectHandleGuardForRelease(child, cleanupFunction, usage, context);
-				globalReleaseProofs.push({
-					anchor: handleGuard ?? child,
-					call: child,
-					handleGuard
-				});
-			}
-		});
-		if (!doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
-		globalReleaseProofsByCleanup.set(cleanupFunction, globalReleaseProofs);
-	}
-	const handleAssignments = handleSymbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
-	const hasUsageAssignment = handleAssignments.some((handleAssignment) => findTransparentExpressionRoot(handleAssignment.identifier).parent === usageAssignment);
-	const hasUnsafeHandleAssignment = handleAssignments.some((handleAssignment) => {
-		const assignmentTarget = findTransparentExpressionRoot(handleAssignment.identifier);
-		const assignment = assignmentTarget.parent;
-		if (assignment === usageAssignment) return false;
-		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== assignmentTarget) return true;
-		const assignedValue = stripParenExpression(assignment.right);
-		if (!(isNodeOfType(assignedValue, "Literal") && assignedValue.value === null || isNodeOfType(assignedValue, "Identifier") && assignedValue.name === "undefined" && context.scopes.isGlobalReference(assignedValue))) return true;
-		const cleanupFunction = findEnclosingFunction$1(assignment);
-		const globalReleaseProofs = cleanupFunction ? globalReleaseProofsByCleanup.get(cleanupFunction) : void 0;
-		return !(cleanupFunction && globalReleaseProofs && doMatchingNodesCoverEveryPathBeforeUsage(assignment, globalReleaseProofs.map((releaseProof) => releaseProof.handleGuard && isAstDescendant(assignment, releaseProof.handleGuard.consequent) ? releaseProof.call : releaseProof.anchor), cleanupFunction, context));
-	});
-	if (!hasUsageAssignment || hasUnsafeHandleAssignment) return false;
-	let usageAncestor = usage.node.parent;
-	while (usageAncestor && usageAncestor !== usageFunction) {
-		if (isNodeOfType(usageAncestor, "ForStatement") || isNodeOfType(usageAncestor, "ForInStatement") || isNodeOfType(usageAncestor, "ForOfStatement") || isNodeOfType(usageAncestor, "WhileStatement") || isNodeOfType(usageAncestor, "DoWhileStatement")) return false;
-		usageAncestor = usageAncestor.parent;
-	}
-	let hasPotentialInterruption = false;
-	for (const argument of usage.node.arguments ?? []) walkAst(argument, (argumentChild) => {
-		if (hasPotentialInterruption) return false;
-		if (isFunctionLike$1(argumentChild)) return false;
-		if (isNodeOfType(argumentChild, "CallExpression") || isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression")) {
-			hasPotentialInterruption = true;
-			return false;
-		}
-	});
-	if (hasPotentialInterruption) return false;
-	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => isEffectLocalLifecycleGuard(callback, guardState, cleanupFunctions, context) && !hasPotentialInterruptionAfterGuard(usageFunction, guardState, usage.node, context) && !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
+	if (usage.handleKey === null || !usageFunction || usageFunction === callback || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
+	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
 };
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
@@ -13178,7 +13023,7 @@ const effectNeedsCleanup = defineRule({
 				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without guaranteed cleanup. Return a cleanup function that owns every allocation so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without returning cleanup. Return a cleanup function so it does not leak after unmount.`
 				});
 			},
 			FunctionDeclaration(node) {
@@ -14628,6 +14473,25 @@ const resolveExhaustiveDepsSettings = (settings) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/is-ast-descendant.ts
+/**
+* True when `inner` is `outer` itself or any descendant in the AST
+* `parent` chain. Walks `inner.parent` upward and stops at either a
+* match (`true`) or the chain's root (`false`).
+*
+* Was duplicated byte-identical in:
+* - exhaustive-deps-symbol-stability.ts
+* - semantic/closure-captures.ts
+*/
+const isAstDescendant = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-sole-writer-guard.ts
 const EQUALITY_BINARY_OPERATORS = new Set(["===", "!=="]);
 const getUseStateSetterSymbol = (stateSymbol, scopes) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.7-dev.1043416",
+  "version": "0.7.7-dev.287dff7",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",