oxlint-plugin-react-doctor 0.7.7-dev.afed801 → 0.7.7-dev.c79c897

package/dist/index.js

@@ -11003,6 +11003,14 @@ const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
 	"catch",
 	"finally"
 ]);
+const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
+const getPromiseChainCallForCallback = (candidate) => {
+	let callbackContainer = candidate.parent;
+	while (callbackContainer && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callbackContainer.type)) callbackContainer = callbackContainer.parent;
+	if (!isNodeOfType(callbackContainer, "CallExpression")) return null;
+	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
+	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
+};
 const collectEffectInvokedFunctions = (effectCallback) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
@@ -11014,7 +11022,6 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 		invokedFunctions.add(strippedCandidate);
 		pendingFunctions.push(strippedCandidate);
 	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
 	while (pendingFunctions.length > 0) {
 		const currentFunction = pendingFunctions.pop();
 		if (!currentFunction) break;
@@ -11844,6 +11851,94 @@ 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, context) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	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, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, context)];
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression") && [
+		"===",
+		"==",
+		"!==",
+		"!="
+	].includes(unwrappedExpression.operator)) {
+		const leftValue = readStaticBoolean(unwrappedExpression.left);
+		const rightValue = readStaticBoolean(unwrappedExpression.right);
+		const booleanValue = leftValue ?? rightValue;
+		const comparedKey = resolveExpressionKey(leftValue === null ? unwrappedExpression.left : unwrappedExpression.right, context);
+		if (booleanValue === null || comparedKey === null) return [];
+		return [{
+			key: comparedKey,
+			value: (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") === blockedExpressionValue ? booleanValue : !booleanValue
+		}];
+	}
+	const expressionKey = resolveExpressionKey(unwrappedExpression, context);
+	return expressionKey === null ? [] : [{
+		key: expressionKey,
+		value: blockedExpressionValue
+	}];
+};
+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$2(callback) || callback.async) return [];
+	const guardStates = [];
+	walkAst(callback.body, (child) => {
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		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, context));
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return guardStates;
+};
+const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
+	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
+	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+	if (!cleanupFunction || !isFunctionLike$2(cleanupFunction) || cleanupFunction.async) return false;
+	let didInvalidateGuard = false;
+	walkAst(cleanupFunction.body, (child) => {
+		if (didInvalidateGuard) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveExpressionKey(child.left, context) === guardState.key && readStaticBoolean(child.right) === guardState.value && context.cfg.isUnconditionalFromEntry(child)) {
+			didInvalidateGuard = true;
+			return false;
+		}
+	});
+	return didInvalidateGuard;
+};
+const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, context) => {
+	const usageStart = getRangeStart(usageNode);
+	if (!isFunctionLike$2(callback) || usageStart === null) return true;
+	let didWriteGuard = false;
+	walkAst(callback.body, (child) => {
+		if (didWriteGuard) return false;
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null || childStart >= usageStart) return;
+		const writtenExpression = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : null;
+		if (writtenExpression && resolveExpressionKey(writtenExpression, context) === guardState.key) {
+			didWriteGuard = true;
+			return false;
+		}
+	});
+	return didWriteGuard;
+};
+const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
+	const usageFunction = findEnclosingFunction(usage.node);
+	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
+	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;
 	if (callback.async) return false;
@@ -11883,6 +11978,7 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 		if (!cleanupFunction || !isFunctionLike$2(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
+	if (hasGuardedDeferredCleanup(callback, usage, matchingCleanupReturns, context)) return true;
 	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
 };
 const findFirstUsageWithoutCleanup = (callback, usages, context) => {
@@ -25449,8 +25545,11 @@ const unwrapUseCallback = (node) => {
 	const callee = node.callee;
 	return isNodeOfType(callee, "Identifier") && callee.name === "useCallback" || isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useCallback" ? node.arguments?.[0] : node;
 };
+const hasParameterDefinition = (ref) => Boolean(ref.resolved?.defs.some((definition) => definition.type === "Parameter"));
 const resolveToFunction = (ref) => {
-	const definitionNode = ref.resolved?.defs[0]?.node;
+	const definition = ref.resolved?.defs[0];
+	if (!definition || hasParameterDefinition(ref)) return null;
+	const definitionNode = definition.node;
 	if (!definitionNode) return null;
 	if (isFunctionLike$2(definitionNode)) return definitionNode;
 	if (isNodeOfType(definitionNode, "VariableDeclarator")) {
@@ -25860,7 +25959,7 @@ const isCleanupReturnArgument = (analysis, node) => {
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const ref = getRef(analysis, node);
-		if (ref && resolveToFunction(ref)) return true;
+		if (ref && (hasParameterDefinition(ref) || resolveToFunction(ref))) return true;
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
 	return false;
@@ -26332,7 +26431,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	if (isNodeOfType(candidate, "Identifier")) {
 		const reference = getRef(analysis, candidate);
 		if (!reference) return null;
-		if (reference.resolved?.defs.some((definition) => definition.type === "Parameter" || definition.type === "ImportBinding")) return null;
+		if (reference.resolved?.defs.some((definition) => definition.type === "ImportBinding")) return null;
 		const resolved = resolveToFunction(reference);
 		if (resolved) return resolved;
 		const definitionNode = reference.resolved?.defs[0]?.node;
@@ -38141,8 +38240,6 @@ const getWrapperHookWrappedFunction = (initializer) => {
 	if (!wrapped || !isFunctionLike$2(wrapped)) return null;
 	return wrapped;
 };
-const hasParameterDef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "Parameter"));
-const resolvesToFunctionBinding = (ref) => !hasParameterDef(ref) && Boolean(resolveToFunction(ref));
 const HANDLER_NAMED_PROP_PATTERN = /^(on|handle)[A-Z]/;
 const wrappedFunctionNotifiesParent = (analysis, wrappedFunction) => getDownstreamRefs(analysis, wrappedFunction).some((innerRef) => {
 	if (!isProp(analysis, innerRef)) return false;
@@ -38463,7 +38560,7 @@ const noPassDataToParent = defineRule({
 					if (isConstant(argRef)) return false;
 					if (isParentWiredHookResultRef(analysis, argRef)) return false;
 					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
+					if (resolveToFunction(argRef)) return false;
 					const argIdentifier = argRef.identifier;
 					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
 					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;

package/package.json

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