oxlint-plugin-react-doctor 0.7.7-dev.6e5c240 → 0.7.7-dev.760a3b0

package/dist/index.js

@@ -4573,6 +4573,23 @@ const hasPossibleStaticPropertyWrite = (identifier, propertyName, scopes) => {
 		return writtenPropertyName === null || writtenPropertyName === propertyName;
 	}));
 };
+const canExecuteBefore = (candidateNode, referenceNode, scopes) => {
+	const candidateBoundary = findExecutionBoundary(candidateNode);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!candidateBoundary || !referenceBoundary) return true;
+	if (candidateBoundary === referenceBoundary) return candidateNode.range[0] < referenceNode.range[0];
+	if (!isFunctionLike$1(candidateBoundary)) return true;
+	return isFunctionSynchronouslyInvokedBefore(candidateBoundary, referenceNode, scopes);
+};
+const hasPossibleStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => {
+		const writeTarget = getMemberWriteTarget(reference.identifier);
+		if (!writeTarget || !canExecuteBefore(writeTarget, referenceNode, scopes)) return false;
+		const writtenPropertyName = getResolvedStaticPropertyName(writeTarget, scopes);
+		return writtenPropertyName === null || writtenPropertyName === propertyName;
+	}));
+};
 const hasPossibleStaticPropertyMutationOrEscape = (identifier, propertyName, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
 	if (hasPossibleStaticPropertyWrite(identifier, propertyName, scopes)) return true;
@@ -14609,7 +14626,7 @@ const buildAsyncEffectMessage = (hookName) => `\`${hookName}\` was given an asyn
 const buildUnknownCallbackMessage = (hookName) => `\`${hookName}\`'s callback is defined elsewhere, so dependencies can't be checked and stale values can slip through.`;
 const buildUnstableDepMessage = (hookName, depName) => `\`${depName}\` is rebuilt every render, so \`${hookName}\` runs every time.`;
 const buildForwardedUnstableDepMessage = (depName) => `\`${depName}\` is rebuilt every render and reaches a Hook dependency inside this custom Hook.`;
-const buildSetStateWithoutDepsMessage = (hookName, setterName) => `\`${hookName}\` calls \`${setterName}\` with no dependency array, so it can loop forever & freeze the component.`;
+const buildSetStateWithoutDepsMessage = (hookName, setterName) => `\`${hookName}\` calls \`${setterName}\` with a value that can change on every render and no dependency array, so it can keep triggering renders.`;
 const buildRefCleanupMessage = (depName) => `Your cleanup may read the wrong node since the ref \`${depName}\` can change before it runs.`;
 const buildAssignmentMessage = (name) => `Assigning to \`${name}\` inside a hook is thrown away after each render, so the next render reads the old value.`;
 //#endregion
@@ -15369,26 +15386,125 @@ const isExtraDepAllowedForHook = (hookName, node, scopes) => {
 };
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol, scopes) => {
-	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
-	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
+const FRESH_STATE_CONSTRUCTOR_NAMES = new Set([
+	"Array",
+	"Date",
+	"Error",
+	"Map",
+	"Object",
+	"RegExp",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+]);
+const getBindingIdentifier = (node) => {
+	if (!node) return null;
+	const candidate = isNodeOfType(node, "AssignmentPattern") ? node.left : node;
+	return isNodeOfType(candidate, "Identifier") ? candidate : null;
 };
-const isConvergingFunctionalUpdater = (node, scopes) => {
-	const updater = unwrapExpression$3(node);
-	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
-	const previousValueParameter = updater.params?.[0];
-	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
-	let returnedExpression = updater.body;
-	if (isNodeOfType(updater.body, "BlockStatement")) {
-		returnedExpression = null;
-		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
-			returnedExpression = statement.argument;
-			break;
+const resolveStateSetterSymbol = (identifier, scopes) => {
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = scopes.symbolFor(identifier);
+	while (symbol?.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier && symbol.initializer) {
+		if (visitedSymbolIds.has(symbol.id)) return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = unwrapExpression$3(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return symbol;
+		symbol = scopes.symbolFor(initializer);
+	}
+	return symbol;
+};
+const getStateSetterDescriptor = (identifier, scopes) => {
+	const setterSymbol = resolveStateSetterSymbol(identifier, scopes);
+	if (!setterSymbol || !isNodeOfType(setterSymbol.declarationNode, "VariableDeclarator")) return null;
+	const declarator = setterSymbol.declarationNode;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return null;
+	const setterElement = declarator.id.elements?.[1];
+	const setterBinding = isAstNode(setterElement) ? getBindingIdentifier(setterElement) : null;
+	if (!setterBinding || setterBinding !== setterSymbol.bindingIdentifier) return null;
+	const initializer = declarator.init ? unwrapExpression$3(declarator.init) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression") || !isReactApiCall(initializer, "useState", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	})) return null;
+	const stateElement = declarator.id.elements?.[0];
+	const stateBinding = isAstNode(stateElement) ? getBindingIdentifier(stateElement) : null;
+	return {
+		setterSymbol,
+		stateSymbol: stateBinding ? scopes.symbolFor(stateBinding) : null
+	};
+};
+const expressionReadsSymbol = (node, symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!symbol) return false;
+	const candidate = unwrapExpression$3(node);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const reference = scopes.referenceFor(candidate);
+		if (reference?.flag !== "write" && reference?.resolvedSymbol?.id === symbol.id) return true;
+		const candidateSymbol = reference?.resolvedSymbol;
+		if (candidateSymbol?.kind === "const" && candidateSymbol.initializer && !isOutsideAllFunctions(candidateSymbol) && !visitedSymbolIds.has(candidateSymbol.id)) {
+			const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+			nextVisitedSymbolIds.add(candidateSymbol.id);
+			return expressionReadsSymbol(candidateSymbol.initializer, symbol, scopes, nextVisitedSymbolIds);
 		}
+		return false;
+	}
+	const record = candidate;
+	for (const key of Object.keys(record)) {
+		if (key === "parent") continue;
+		const child = record[key];
+		if (Array.isArray(child)) {
+			if (child.some((item) => isAstNode(item) && expressionReadsSymbol(item, symbol, scopes))) return true;
+		} else if (isAstNode(child) && expressionReadsSymbol(child, symbol, scopes)) return true;
 	}
-	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
-	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
-	const test = unwrapExpression$3(conditional.test);
+	return false;
+};
+const isGuaranteedFreshStateValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = unwrapExpression$3(node);
+	if (isNodeOfType(candidate, "ObjectExpression") || isNodeOfType(candidate, "ArrayExpression") || isNodeOfType(candidate, "JSXElement") || isNodeOfType(candidate, "JSXFragment") || isRegExpLiteral(candidate)) return true;
+	if (isNodeOfType(candidate, "SequenceExpression")) {
+		const finalExpression = candidate.expressions.at(-1);
+		return Boolean(finalExpression && isGuaranteedFreshStateValue(finalExpression, scopes));
+	}
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isGuaranteedFreshStateValue(candidate.consequent, scopes, visitedSymbolIds) && isGuaranteedFreshStateValue(candidate.alternate, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "LogicalExpression")) return isGuaranteedFreshStateValue(candidate.left, scopes, visitedSymbolIds) && isGuaranteedFreshStateValue(candidate.right, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "CallExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		return isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee) && (callee.name === "Array" || callee.name === "Object") && (callee.name === "Array" || candidate.arguments.length === 0);
+	}
+	if (isNodeOfType(candidate, "NewExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		return isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee) && FRESH_STATE_CONSTRUCTOR_NAMES.has(callee.name) && (callee.name !== "Object" || candidate.arguments.length === 0);
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || isOutsideAllFunctions(symbol) || visitedSymbolIds.has(symbol.id)) return false;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	return isGuaranteedFreshStateValue(symbol.initializer, scopes, nextVisitedSymbolIds);
+};
+const isNonZeroLiteral = (node) => {
+	const candidate = unwrapExpression$3(node);
+	return isNodeOfType(candidate, "Literal") && (typeof candidate.value === "number" && candidate.value !== 0 || typeof candidate.value === "bigint" && candidate.value !== 0n || typeof candidate.value === "string" && candidate.value.length > 0);
+};
+const isProvablyChangingExpression = (node, previousValueSymbol, scopes) => {
+	const candidate = unwrapExpression$3(node);
+	if (isGuaranteedFreshStateValue(candidate, scopes)) return true;
+	if (isNodeOfType(candidate, "ConditionalExpression")) {
+		const isConsequentChanging = isProvablyChangingExpression(candidate.consequent, previousValueSymbol, scopes);
+		const isAlternateChanging = isProvablyChangingExpression(candidate.alternate, previousValueSymbol, scopes);
+		return expressionReadsSymbol(candidate.test, previousValueSymbol, scopes) ? isConsequentChanging && isAlternateChanging : isConsequentChanging || isAlternateChanging;
+	}
+	if (!expressionReadsSymbol(candidate, previousValueSymbol, scopes)) return false;
+	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator === "!";
+	if (isNodeOfType(candidate, "UpdateExpression")) return true;
+	if (!isNodeOfType(candidate, "BinaryExpression")) return false;
+	return (candidate.operator === "+" || candidate.operator === "-") && expressionReadsSymbol(candidate.left, previousValueSymbol, scopes) && isNonZeroLiteral(candidate.right);
+};
+const isFreshEqualityGuardUpdater = (node, previousValueSymbol, scopes) => {
+	const candidate = unwrapExpression$3(node);
+	if (!isNodeOfType(candidate, "ConditionalExpression")) return false;
+	const test = unwrapExpression$3(candidate.test);
 	if (!isNodeOfType(test, "BinaryExpression") || ![
 		"===",
 		"!==",
@@ -15396,38 +15512,50 @@ const isConvergingFunctionalUpdater = (node, scopes) => {
 		"!="
 	].includes(test.operator)) return false;
 	const isPreviousValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
+		const expressionCandidate = unwrapExpression$3(expression);
+		return isNodeOfType(expressionCandidate, "Identifier") && scopes.symbolFor(expressionCandidate)?.id === previousValueSymbol?.id;
 	};
 	let comparedValue = null;
 	if (isPreviousValue(test.left)) comparedValue = test.right;
-	else if (isPreviousValue(test.right)) comparedValue = test.left;
-	if (!comparedValue) return false;
-	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
-	const isSameComparedValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		const compared = unwrapExpression$3(comparedValue);
-		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
-		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
-		return false;
+	if (isPreviousValue(test.right)) comparedValue = test.left;
+	if (!comparedValue || !isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
+	const isComparedValue = (expression) => {
+		const expressionCandidate = unwrapExpression$3(expression);
+		const comparedCandidate = unwrapExpression$3(comparedValue);
+		if (isNodeOfType(expressionCandidate, "Identifier")) return isNodeOfType(comparedCandidate, "Identifier") && scopes.symbolFor(expressionCandidate)?.id === scopes.symbolFor(comparedCandidate)?.id;
+		return isNodeOfType(expressionCandidate, "Literal") && isNodeOfType(comparedCandidate, "Literal") && expressionCandidate.value === comparedCandidate.value;
 	};
-	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
-};
-const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
-	const parent = identifier.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
-	const writtenValue = parent.arguments?.[0];
-	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
+	return test.operator === "===" || test.operator === "==" ? isPreviousValue(candidate.consequent) && isComparedValue(candidate.alternate) : isComparedValue(candidate.consequent) && isPreviousValue(candidate.alternate);
 };
-const findStableSetterReference = (node, scopes) => {
+const isProvablyChangingFunctionalUpdater = (node, scopes) => {
+	const updater = unwrapExpression$3(node);
+	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
+	const previousValueParameter = updater.params?.[0];
+	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
+	const previousValueSymbol = scopes.symbolFor(previousValueParameter);
+	if (!isNodeOfType(updater.body, "BlockStatement")) return isFreshEqualityGuardUpdater(updater.body, previousValueSymbol, scopes) || isProvablyChangingExpression(updater.body, previousValueSymbol, scopes);
+	if (updater.body.body.length !== 1) return false;
+	const soleStatement = updater.body.body[0];
+	if (!isNodeOfType(soleStatement, "ReturnStatement") || !isAstNode(soleStatement.argument)) return false;
+	return isFreshEqualityGuardUpdater(soleStatement.argument, previousValueSymbol, scopes) || isProvablyChangingExpression(soleStatement.argument, previousValueSymbol, scopes);
+};
+const isProvablyRenderChangingSetterCall = (identifier, scopes) => {
+	const setterCall = identifier.parent;
+	if (!setterCall || !isNodeOfType(setterCall, "CallExpression") || setterCall.callee !== identifier) return false;
+	const descriptor = getStateSetterDescriptor(identifier, scopes);
+	const writtenValue = setterCall.arguments?.[0];
+	if (!descriptor || !writtenValue || !isAstNode(writtenValue)) return false;
+	return isProvablyChangingFunctionalUpdater(writtenValue, scopes) ? true : isProvablyChangingExpression(writtenValue, descriptor.stateSymbol, scopes);
+};
+const findRenderChangingStateSetterName = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
 		if (setterName) return;
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
-			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol, scopes) && !isGuardedStableSetterCall(current, symbol, scopes)) {
-				setterName = symbol.name;
+			const descriptor = getStateSetterDescriptor(current, scopes);
+			if (descriptor && isProvablyRenderChangingSetterCall(current, scopes)) {
+				setterName = descriptor.setterSymbol.name;
 				return;
 			}
 		}
@@ -15754,7 +15882,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 			}
 			if (!depsArgumentRaw) {
 				if (callbackToAnalyze && EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) {
-					const setterName = findStableSetterReference(callbackToAnalyze, context.scopes);
+					const setterName = findRenderChangingStateSetterName(callbackToAnalyze, context.scopes);
 					if (setterName) {
 						context.report({
 							node: callbackToAnalyze,
@@ -20147,14 +20275,14 @@ const isIndexOfResultUsedAsMembershipTest = (node) => {
 	if (isNegativeOneLiteral(otherOperand)) return true;
 	return isZeroLiteral(otherOperand) && (parent.operator === ">=" || parent.operator === "<");
 };
-const getTypeAnnotation = (node) => {
+const getTypeAnnotation$1 = (node) => {
 	if (!node || !("typeAnnotation" in node)) return null;
 	const annotation = node.typeAnnotation;
 	if (!annotation || !isNodeOfType(annotation, "TSTypeAnnotation")) return null;
 	return annotation.typeAnnotation;
 };
 const getDeclaredPropertyType = (members, propertyName) => {
-	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation(member);
+	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation$1(member);
 	return null;
 };
 const getArrayElementType = (typeNode) => {
@@ -20173,7 +20301,7 @@ const getDestructuredDeclaredType = (identifier) => {
 	const property = binding.bindingIdentifier.parent;
 	const objectPattern = property?.parent;
 	if (!isNodeOfType(property, "Property") || !isNodeOfType(property.key, "Identifier") || !isNodeOfType(objectPattern, "ObjectPattern")) return null;
-	const propsType = getTypeAnnotation(objectPattern);
+	const propsType = getTypeAnnotation$1(objectPattern);
 	if (!propsType) return null;
 	if (isNodeOfType(propsType, "TSTypeLiteral")) return getDeclaredPropertyType(propsType.members ?? [], property.key.name);
 	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return null;
@@ -20190,7 +20318,7 @@ const getIdentifierDeclaredType = (identifier, visitedBindingIdentifiers = /* @_
 	const binding = findVariableInitializer(identifier, identifier.name);
 	if (!binding || visitedBindingIdentifiers.has(binding.bindingIdentifier)) return null;
 	visitedBindingIdentifiers.add(binding.bindingIdentifier);
-	const directType = getTypeAnnotation(binding.bindingIdentifier);
+	const directType = getTypeAnnotation$1(binding.bindingIdentifier);
 	if (directType) return directType;
 	const initializer = binding.initializer;
 	if (isNodeOfType(initializer, "TSAsExpression") || isNodeOfType(initializer, "TSTypeAssertion") || isNodeOfType(initializer, "TSSatisfiesExpression")) return initializer.typeAnnotation;
@@ -27355,6 +27483,211 @@ const computeExternallyDriven = (analysis, declarator) => {
 	return hasDeferredCallSite;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/is-proven-native-read-method.ts
+const ARRAY_READ_METHOD_NAMES$1 = new Set([
+	"at",
+	"concat",
+	"entries",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flat",
+	"flatMap",
+	"forEach",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"slice",
+	"some",
+	"toLocaleString",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+const MAP_READ_METHOD_NAMES = new Set([
+	"entries",
+	"forEach",
+	"get",
+	"has",
+	"keys",
+	"values"
+]);
+const SET_READ_METHOD_NAMES = new Set([
+	"difference",
+	"entries",
+	"forEach",
+	"has",
+	"intersection",
+	"isDisjointFrom",
+	"isSubsetOf",
+	"isSupersetOf",
+	"keys",
+	"symmetricDifference",
+	"union",
+	"values"
+]);
+const FUNCTION_READ_METHOD_NAMES = new Set(["bind"]);
+const PROMISE_READ_METHOD_NAMES = new Set([
+	"catch",
+	"finally",
+	"then"
+]);
+const STRING_READ_METHOD_NAMES$1 = new Set([
+	"at",
+	"charAt",
+	"charCodeAt",
+	"codePointAt",
+	"concat",
+	"endsWith",
+	"includes",
+	"indexOf",
+	"isWellFormed",
+	"lastIndexOf",
+	"localeCompare",
+	"match",
+	"matchAll",
+	"normalize",
+	"padEnd",
+	"padStart",
+	"repeat",
+	"replace",
+	"replaceAll",
+	"search",
+	"slice",
+	"split",
+	"startsWith",
+	"substring",
+	"toLocaleLowerCase",
+	"toLocaleUpperCase",
+	"toLowerCase",
+	"toString",
+	"toUpperCase",
+	"toWellFormed",
+	"trim",
+	"trimEnd",
+	"trimStart",
+	"valueOf"
+]);
+const NATIVE_TYPE_NAMES = new Set([
+	"Array",
+	"Map",
+	"Promise",
+	"PromiseLike",
+	"ReadonlyArray",
+	"ReadonlyMap",
+	"ReadonlySet",
+	"Set"
+]);
+const nativeTypeDeclarationsByProgram = /* @__PURE__ */ new WeakMap();
+const shadowedNativeTypeNamesByBinding = /* @__PURE__ */ new WeakMap();
+const isWithinNode = (node, ancestor) => {
+	let current = node;
+	while (current) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const findTypeDeclarationScope = (declaration) => {
+	let current = declaration.parent;
+	while (current) {
+		if (isNodeOfType(current, "Program") || isNodeOfType(current, "BlockStatement") || isNodeOfType(current, "TSModuleBlock") || isNodeOfType(current, "StaticBlock")) return current;
+		current = current.parent;
+	}
+	return null;
+};
+const getDeclaredTypeName = (declaration) => {
+	if (!isNodeOfType(declaration, "ClassDeclaration") && !isNodeOfType(declaration, "TSEnumDeclaration") && !isNodeOfType(declaration, "TSImportEqualsDeclaration") && !isNodeOfType(declaration, "TSInterfaceDeclaration") && !isNodeOfType(declaration, "TSModuleDeclaration") && !isNodeOfType(declaration, "TSTypeAliasDeclaration")) return null;
+	return declaration.id && isNodeOfType(declaration.id, "Identifier") ? declaration.id.name : null;
+};
+const getNativeTypeDeclarations = (program) => {
+	const cachedDeclarations = nativeTypeDeclarationsByProgram.get(program);
+	if (cachedDeclarations) return cachedDeclarations;
+	const declarations = [];
+	walkAst(program, (candidate) => {
+		if (isNodeOfType(candidate, "ImportDeclaration")) {
+			for (const specifier of candidate.specifiers) if (NATIVE_TYPE_NAMES.has(specifier.local.name)) declarations.push({
+				name: specifier.local.name,
+				scope: program
+			});
+			return;
+		}
+		const declaredTypeName = getDeclaredTypeName(candidate);
+		if (!declaredTypeName || !NATIVE_TYPE_NAMES.has(declaredTypeName)) return;
+		const declarationScope = findTypeDeclarationScope(candidate);
+		if (declarationScope) declarations.push({
+			name: declaredTypeName,
+			scope: declarationScope
+		});
+	});
+	nativeTypeDeclarationsByProgram.set(program, declarations);
+	return declarations;
+};
+const getShadowedNativeTypeNames = (binding) => {
+	const cachedNames = shadowedNativeTypeNamesByBinding.get(binding);
+	if (cachedNames) return cachedNames;
+	const shadowedNames = /* @__PURE__ */ new Set();
+	for (const typeName of NATIVE_TYPE_NAMES) if (hasEnclosingTypeParameterNamed(binding, typeName)) shadowedNames.add(typeName);
+	const program = findProgramRoot(binding);
+	if (program) {
+		for (const declaration of getNativeTypeDeclarations(program)) if (isWithinNode(binding, declaration.scope)) shadowedNames.add(declaration.name);
+	}
+	shadowedNativeTypeNamesByBinding.set(binding, shadowedNames);
+	return shadowedNames;
+};
+const getParameterBinding = (definitionName) => {
+	if (isNodeOfType(definitionName, "Identifier")) return definitionName;
+	if (!isNodeOfType(definitionName, "AssignmentPattern")) return null;
+	return isNodeOfType(definitionName.left, "Identifier") ? definitionName.left : null;
+};
+const getTypeAnnotation = (binding) => {
+	if (!isNodeOfType(binding, "Identifier")) return null;
+	const annotation = binding.typeAnnotation;
+	return annotation && isNodeOfType(annotation, "TSTypeAnnotation") ? annotation.typeAnnotation : null;
+};
+const isNullishType = (typeNode) => isNodeOfType(typeNode, "TSNullKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword");
+const isNativeReadMethod = (typeNode, methodName, shadowedTypeNames) => {
+	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return ARRAY_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSStringKeyword")) return STRING_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSFunctionType")) return FUNCTION_READ_METHOD_NAMES.has(methodName);
+	if (isNodeOfType(typeNode, "TSLiteralType") && isNodeOfType(typeNode.literal, "Literal") && typeof typeNode.literal.value === "string") return STRING_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSTypeOperator") && typeNode.operator === "readonly" && typeNode.typeAnnotation) return isNativeReadMethod(typeNode.typeAnnotation, methodName, shadowedTypeNames);
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		let hasNonNullishMember = false;
+		for (const memberType of typeNode.types) {
+			if (isNullishType(memberType)) continue;
+			hasNonNullishMember = true;
+			if (!isNativeReadMethod(memberType, methodName, shadowedTypeNames)) return false;
+		}
+		return hasNonNullishMember;
+	}
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	if (shadowedTypeNames.has(typeNode.typeName.name)) return false;
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return ARRAY_READ_METHOD_NAMES$1.has(methodName);
+	if (typeNode.typeName.name === "Map" || typeNode.typeName.name === "ReadonlyMap") return MAP_READ_METHOD_NAMES.has(methodName);
+	if (typeNode.typeName.name === "Set" || typeNode.typeName.name === "ReadonlySet") return SET_READ_METHOD_NAMES.has(methodName);
+	if (typeNode.typeName.name === "Promise" || typeNode.typeName.name === "PromiseLike") return PROMISE_READ_METHOD_NAMES.has(methodName);
+	return false;
+};
+const isProvenNativeReadMethod = (ref, methodName) => Boolean(ref.resolved?.defs.some((definition) => {
+	if (definition.type !== "Parameter") return false;
+	const parameterBinding = getParameterBinding(definition.name);
+	if (!parameterBinding) return false;
+	const typeAnnotation = getTypeAnnotation(parameterBinding);
+	return Boolean(typeAnnotation && isNativeReadMethod(typeAnnotation, methodName, getShadowedNativeTypeNames(parameterBinding)));
+}));
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
@@ -27581,7 +27914,132 @@ const isRefCurrent = (ref) => {
 const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
 const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(analysis, ref) && isSynchronous(ref.identifier, effectFn) && !resolvesToAsyncFunction(ref);
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
-const isPropCallbackInvocationRef = (analysis, ref) => {
+const SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD = new Map([
+	["every", 0],
+	["filter", 0],
+	["find", 0],
+	["findIndex", 0],
+	["findLast", 0],
+	["findLastIndex", 0],
+	["flatMap", 0],
+	["forEach", 0],
+	["map", 0],
+	["reduce", 0],
+	["reduceRight", 0],
+	["replace", 1],
+	["replaceAll", 1],
+	["some", 0]
+]);
+const addSimpleBindingNames = (pattern, names) => {
+	if (isNodeOfType(pattern, "Identifier")) {
+		if (names.has(pattern.name)) return false;
+		names.add(pattern.name);
+		return true;
+	}
+	if (isNodeOfType(pattern, "AssignmentPattern")) return addSimpleBindingNames(pattern.left, names);
+	if (isNodeOfType(pattern, "RestElement")) return addSimpleBindingNames(pattern.argument, names);
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		let didAddName = false;
+		for (const property of pattern.properties) didAddName = addSimpleBindingNames(isNodeOfType(property, "Property") ? property.value : property, names) || didAddName;
+		return didAddName;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		let didAddName = false;
+		for (const element of pattern.elements) if (element) didAddName = addSimpleBindingNames(element, names) || didAddName;
+		return didAddName;
+	}
+	return false;
+};
+const getSimpleParameterNames = (callback) => {
+	if (!isFunctionLike$1(callback)) return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const parameter of callback.params ?? []) addSimpleBindingNames(parameter, names);
+	return names;
+};
+const inlineCallbackInvokesParameter = (callback) => {
+	const parameterNames = getSimpleParameterNames(callback);
+	if (parameterNames.size === 0 || !isFunctionLike$1(callback)) return false;
+	let didAddAlias = true;
+	while (didAddAlias) {
+		didAddAlias = false;
+		walkAst(callback.body, (candidate) => {
+			if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+			if (isNodeOfType(candidate, "AssignmentExpression") && candidate.operator === "=" && isNodeOfType(candidate.left, "Identifier")) {
+				const assignedValueRoot = getRootIdentifier$1(candidate.right);
+				if (isNodeOfType(assignedValueRoot, "Identifier") && parameterNames.has(assignedValueRoot.name) && !parameterNames.has(candidate.left.name)) {
+					parameterNames.add(candidate.left.name);
+					didAddAlias = true;
+				}
+				return;
+			}
+			if (!isNodeOfType(candidate, "VariableDeclarator") || !candidate.init) return;
+			const initializerRoot = getRootIdentifier$1(candidate.init);
+			if (!isNodeOfType(initializerRoot, "Identifier") || !parameterNames.has(initializerRoot.name)) return;
+			if (addSimpleBindingNames(candidate.id, parameterNames)) didAddAlias = true;
+		});
+	}
+	let didInvokeParameter = false;
+	walkAst(callback.body, (candidate) => {
+		if (didInvokeParameter) return false;
+		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "CallExpression")) return;
+		const callee = stripParenExpression(candidate.callee);
+		if (isNodeOfType(callee, "Identifier") && parameterNames.has(callee.name)) {
+			didInvokeParameter = true;
+			return false;
+		}
+		if (isNodeOfType(callee, "MemberExpression")) {
+			const receiverRoot = getRootIdentifier$1(callee.object);
+			if (receiverRoot && parameterNames.has(receiverRoot.name)) {
+				didInvokeParameter = true;
+				return false;
+			}
+		}
+	});
+	return didInvokeParameter;
+};
+const callbackInvokesPropCallback = (analysis, callback) => {
+	if (!isFunctionLike$1(callback)) return false;
+	let didInvokePropCallback = false;
+	walkAst(callback.body, (candidate) => {
+		if (didInvokePropCallback) return false;
+		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "CallExpression")) return;
+		if (getDownstreamRefs(analysis, stripParenExpression(candidate.callee)).some((reference) => isPropCallbackInvocationRef(analysis, reference))) {
+			didInvokePropCallback = true;
+			return false;
+		}
+	});
+	return didInvokePropCallback;
+};
+const isNativeMethodSuppressionSafe = (analysis, callExpression, methodName, scopes) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const receiverSymbol = scopes.symbolFor(receiver);
+	if (!receiverSymbol || hasSymbolWriteBefore(receiverSymbol, callExpression, scopes) || hasPossibleStaticPropertyWriteBefore(receiver, methodName, callExpression, scopes)) return false;
+	let callResult = callExpression;
+	let callResultConsumer = callResult.parent;
+	while (callResultConsumer && (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callResultConsumer.type) && "expression" in callResultConsumer && callResultConsumer.expression === callResult || isNodeOfType(callResultConsumer, "MemberExpression") && callResultConsumer.object === callResult)) {
+		callResult = callResultConsumer;
+		callResultConsumer = callResult.parent;
+	}
+	if (isNodeOfType(callResultConsumer, "CallExpression") && callResultConsumer.callee === callResult) return false;
+	const callbackArgumentIndex = SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD.get(methodName);
+	if (callbackArgumentIndex === void 0) return true;
+	const callbackArgument = callExpression.arguments?.[callbackArgumentIndex];
+	if (!callbackArgument) return true;
+	const callbackValue = stripParenExpression(callbackArgument);
+	if (isFunctionLike$1(callbackValue)) return !inlineCallbackInvokesParameter(callbackValue) && !callbackInvokesPropCallback(analysis, callbackValue);
+	if (!isNodeOfType(callbackValue, "Identifier")) return false;
+	const callbackRef = getRef(analysis, callbackValue);
+	if (!callbackRef || isPropAlias(analysis, callbackRef)) return false;
+	const callbackFunction = resolveToFunction(callbackRef);
+	return Boolean(callbackFunction && isFunctionLike$1(callbackFunction) && !inlineCallbackInvokesParameter(callbackFunction) && !callbackInvokesPropCallback(analysis, callbackFunction));
+};
+const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
 	if (!isPropAlias(analysis, ref)) return false;
 	let effectiveNode = ref.identifier;
 	let parent = effectiveNode.parent;
@@ -27594,7 +28052,9 @@ const isPropCallbackInvocationRef = (analysis, ref) => {
 	if (isNodeOfType(parent, "MemberExpression") && parent.object === effectiveNode) {
 		const memberParent = parent.parent;
 		if (isNodeOfType(memberParent, "CallExpression") && memberParent.callee === parent) {
-			if (!parent.computed && isNodeOfType(parent.property, "Identifier") && HANDLER_NAMED_METHOD_PATTERN.test(parent.property.name)) return true;
+			const propertyName = getStaticPropertyName(parent);
+			if (propertyName && HANDLER_NAMED_METHOD_PATTERN.test(propertyName)) return true;
+			if (options.nativeMethodScopes && isCustomHookParameter(ref) && propertyName && isProvenNativeReadMethod(ref, propertyName) && isNativeMethodSuppressionSafe(analysis, memberParent, propertyName, options.nativeMethodScopes)) return false;
 			return isWholePropsObjectReference(analysis, ref);
 		}
 	}
@@ -41065,7 +41525,7 @@ const noPropCallbackInRender = defineRule({
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
 		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
+		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference, { nativeMethodScopes: context.scopes }))) return;
 		context.report({
 			node,
 			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
@@ -59029,6 +59489,78 @@ const inferDestructureSourceKey = (bindingIdentifier) => {
 	return null;
 };
 const isReactUseHook = (hookName) => hookName === "use";
+const isReactHookCapabilityValue = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (symbol.kind === "import") return isReactImport(symbol) && isReactHookName(getImportedName(symbol.declarationNode) ?? "");
+		if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		if (destructuredPropertyName) {
+			const namespaceExpression = stripParenExpression(symbol.initializer);
+			return isReactHookName(destructuredPropertyName) && isNodeOfType(namespaceExpression, "Identifier") && isReactNamespaceImport(namespaceExpression, scopes) && !hasPossibleStaticPropertyMutationOrEscape(namespaceExpression, destructuredPropertyName, scopes);
+		}
+		if (symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
+		return isReactHookCapabilityValue(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(unwrappedExpression);
+	if (!propertyName || !isReactHookName(propertyName)) return false;
+	const namespaceExpression = stripParenExpression(unwrappedExpression.object);
+	return isNodeOfType(namespaceExpression, "Identifier") && isReactNamespaceImport(namespaceExpression, scopes) && !hasPossibleStaticPropertyMutationOrEscape(namespaceExpression, propertyName, scopes);
+};
+const isReactHookCapabilityComparisonOperand = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isReactHookCapabilityValue(unwrappedExpression, scopes)) return true;
+	return isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "typeof" && isReactHookCapabilityValue(unwrappedExpression.argument, scopes);
+};
+const isStaticCapabilityComparisonValue = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal")) return true;
+	return isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression);
+};
+const CAPABILITY_COMPARISON_OPERATORS = new Set([
+	"==",
+	"!=",
+	"===",
+	"!=="
+]);
+const isInvariantReactHookCapabilityCondition = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isReactHookCapabilityValue(unwrappedExpression, scopes)) return true;
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return isInvariantReactHookCapabilityCondition(unwrappedExpression.argument, scopes);
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return isInvariantReactHookCapabilityCondition(unwrappedExpression.left, scopes) && isInvariantReactHookCapabilityCondition(unwrappedExpression.right, scopes);
+	if (!isNodeOfType(unwrappedExpression, "BinaryExpression") || !CAPABILITY_COMPARISON_OPERATORS.has(unwrappedExpression.operator)) return false;
+	return isReactHookCapabilityComparisonOperand(unwrappedExpression.left, scopes) && isStaticCapabilityComparisonValue(unwrappedExpression.right, scopes) || isReactHookCapabilityComparisonOperand(unwrappedExpression.right, scopes) && isStaticCapabilityComparisonValue(unwrappedExpression.left, scopes);
+};
+const statementContainsOwnAbruptCompletion = (statement) => {
+	let doesContainAbruptCompletion = false;
+	walkAst(statement, (child) => {
+		if (child !== statement && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement")) {
+			doesContainAbruptCompletion = true;
+			return false;
+		}
+	});
+	return doesContainAbruptCompletion;
+};
+const isInvariantReactHookCapabilityExit = (statement, scopes) => isNodeOfType(statement, "IfStatement") && statement.alternate === null && statementAlwaysExits(statement.consequent) && isInvariantReactHookCapabilityCondition(statement.test, scopes);
+const isAfterOnlyInvariantReactHookCapabilityExits = (node, enclosingFunction, scopes) => {
+	if (!isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
+	let containingStatement = node;
+	while (containingStatement.parent && containingStatement.parent !== enclosingFunction.body) {
+		if (isFunctionLike$1(containingStatement.parent)) return false;
+		if (isNodeOfType(containingStatement.parent, "IfStatement") || isNodeOfType(containingStatement.parent, "SwitchStatement") || isNodeOfType(containingStatement.parent, "SwitchCase") || isNodeOfType(containingStatement.parent, "ConditionalExpression") || isNodeOfType(containingStatement.parent, "LogicalExpression")) return false;
+		containingStatement = containingStatement.parent;
+	}
+	if (containingStatement.parent !== enclosingFunction.body) return false;
+	const statementIndex = enclosingFunction.body.body.findIndex((statement) => statement === containingStatement);
+	if (statementIndex <= 0) return false;
+	const bypassingStatements = enclosingFunction.body.body.slice(0, statementIndex).filter((statement) => statementContainsOwnAbruptCompletion(statement));
+	return bypassingStatements.length > 0 && bypassingStatements.every((statement) => isInvariantReactHookCapabilityExit(statement, scopes));
+};
 const getCallExpressionCalleeName = (callExpression) => {
 	const callee = callExpression.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
@@ -59324,7 +59856,7 @@ const rulesOfHooks = defineRule({
 					});
 					return;
 				}
-				if (!context.cfg.isUnconditionalFromEntry(node)) context.report({
+				if (!context.cfg.isUnconditionalFromEntry(node) && !isAfterOnlyInvariantReactHookCapabilityExits(node, enclosing.node, context.scopes)) context.report({
 					node: node.callee,
 					message: buildConditionalMessage(hookName)
 				});

package/package.json

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