oxlint-plugin-react-doctor 0.7.7-dev.bdd1321 → 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) => {
@@ -18333,6 +18429,26 @@ const MEMBERSHIP_COMPARISON_OPERATORS = new Set([
 ]);
 const isNegativeOneLiteral = (expression) => Boolean(expression) && isNodeOfType(expression, "UnaryExpression") && expression.operator === "-" && isNodeOfType(expression.argument, "Literal") && expression.argument.value === 1;
 const isZeroLiteral = (expression) => Boolean(expression) && isNodeOfType(expression, "Literal") && expression.value === 0;
+const isToIntegerOrInfinityZero = (value) => Number.isNaN(value) || Math.trunc(value) === 0;
+const isZeroFromIndex = (expression) => {
+	if (!expression) return false;
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) {
+		if (typeof strippedExpression.value === "number") return isToIntegerOrInfinityZero(strippedExpression.value);
+		if (typeof strippedExpression.value === "string") return isToIntegerOrInfinityZero(Number(strippedExpression.value));
+		return strippedExpression.value === null || strippedExpression.value === false;
+	}
+	if (isNodeOfType(strippedExpression, "UnaryExpression") && strippedExpression.operator === "void") return true;
+	if (isNodeOfType(strippedExpression, "UnaryExpression") && (strippedExpression.operator === "-" || strippedExpression.operator === "+") && isNodeOfType(strippedExpression.argument, "Literal") && typeof strippedExpression.argument.value === "number") return isToIntegerOrInfinityZero(strippedExpression.operator === "-" ? -strippedExpression.argument.value : strippedExpression.argument.value);
+	if (isNodeOfType(strippedExpression, "Identifier")) return (strippedExpression.name === "undefined" || strippedExpression.name === "NaN") && findVariableInitializer(strippedExpression, strippedExpression.name) === null;
+	return isNodeOfType(strippedExpression, "MemberExpression") && !strippedExpression.computed && isNodeOfType(strippedExpression.object, "Identifier") && strippedExpression.object.name === "Number" && isNodeOfType(strippedExpression.property, "Identifier") && strippedExpression.property.name === "NaN" && findVariableInitializer(strippedExpression.object, strippedExpression.object.name) === null;
+};
+const hasSemanticsPreservingIncludesArguments = (node) => {
+	if (node.arguments.length === 1) return !isNodeOfType(node.arguments[0], "SpreadElement");
+	if (node.arguments.length !== 2) return false;
+	if (isNodeOfType(node.arguments[0], "SpreadElement") || isNodeOfType(node.arguments[1], "SpreadElement")) return false;
+	return isZeroFromIndex(node.arguments[1]);
+};
 const PARENT_WRAPPER_TYPES = new Set([
 	"ParenthesizedExpression",
 	"ChainExpression",
@@ -18353,6 +18469,306 @@ const isIndexOfResultUsedAsMembershipTest = (node) => {
 	if (isNegativeOneLiteral(otherOperand)) return true;
 	return isZeroLiteral(otherOperand) && (parent.operator === ">=" || parent.operator === "<");
 };
+const getTypeAnnotation = (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);
+	return null;
+};
+const getArrayElementType = (typeNode) => {
+	if (!typeNode) return null;
+	if (isNodeOfType(typeNode, "TSArrayType")) return typeNode.elementType;
+	if (isNodeOfType(typeNode, "TSTypeReference") && isNodeOfType(typeNode.typeName, "Identifier") && (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray")) return typeNode.typeArguments?.params?.[0] ?? null;
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		const arrayElementTypes = typeNode.types.map(getArrayElementType).filter(Boolean);
+		return arrayElementTypes.length === 1 ? arrayElementTypes[0] : null;
+	}
+	return null;
+};
+const getDestructuredDeclaredType = (identifier) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return null;
+	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);
+	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;
+	const program = findProgramRoot(identifier);
+	if (!program) return null;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (isNodeOfType(declaration, "TSInterfaceDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === propsType.typeName.name) return getDeclaredPropertyType(declaration.body.body, property.key.name);
+		if (isNodeOfType(declaration, "TSTypeAliasDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === propsType.typeName.name && isNodeOfType(declaration.typeAnnotation, "TSTypeLiteral")) return getDeclaredPropertyType(declaration.typeAnnotation.members ?? [], property.key.name);
+	}
+	return null;
+};
+const getIdentifierDeclaredType = (identifier, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding || visitedBindingIdentifiers.has(binding.bindingIdentifier)) return null;
+	visitedBindingIdentifiers.add(binding.bindingIdentifier);
+	const directType = getTypeAnnotation(binding.bindingIdentifier);
+	if (directType) return directType;
+	const initializer = binding.initializer;
+	if (isNodeOfType(initializer, "TSAsExpression") || isNodeOfType(initializer, "TSTypeAssertion") || isNodeOfType(initializer, "TSSatisfiesExpression")) return initializer.typeAnnotation;
+	const destructuredType = getDestructuredDeclaredType(identifier);
+	if (destructuredType) return destructuredType;
+	const declarator = binding.bindingIdentifier.parent;
+	const declaration = declarator?.parent;
+	const forOfStatement = declaration?.parent;
+	if (isNodeOfType(declarator, "VariableDeclarator") && isNodeOfType(declaration, "VariableDeclaration") && isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.left === declaration && isNodeOfType(forOfStatement.right, "Identifier")) return getArrayElementType(getIdentifierDeclaredType(forOfStatement.right, visitedBindingIdentifiers));
+	return null;
+};
+const isNativeIterationIndex = (identifier) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return false;
+	const callback = binding.bindingIdentifier.parent;
+	if (!isInlineFunctionExpression(callback)) return false;
+	const callbackCall = callback.parent;
+	if (!isNodeOfType(callbackCall, "CallExpression") || !isIterationCallbackCall(callbackCall) || !isNodeOfType(callbackCall.callee, "MemberExpression") || !isNodeOfType(callbackCall.callee.property, "Identifier")) return false;
+	const indexParameterPosition = callbackCall.callee.property.name === "reduce" || callbackCall.callee.property.name === "reduceRight" ? 2 : 1;
+	return callback.params?.[indexParameterPosition] === binding.bindingIdentifier;
+};
+const hasSameIdentifierBinding = (leftIdentifier, rightIdentifier) => {
+	if (leftIdentifier.name !== rightIdentifier.name) return false;
+	const leftBinding = findVariableInitializer(leftIdentifier, leftIdentifier.name);
+	const rightBinding = findVariableInitializer(rightIdentifier, rightIdentifier.name);
+	return Boolean(leftBinding && rightBinding && leftBinding.bindingIdentifier === rightBinding.bindingIdentifier);
+};
+const NON_NAN_RELATIONAL_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const testProvesIdentifierIsNotNaN = (test, identifier) => {
+	if (!test) return false;
+	const strippedTest = stripParenExpression(test);
+	if (isNodeOfType(strippedTest, "LogicalExpression") && strippedTest.operator === "&&") return testProvesIdentifierIsNotNaN(strippedTest.left, identifier) || testProvesIdentifierIsNotNaN(strippedTest.right, identifier);
+	if (!isNodeOfType(strippedTest, "BinaryExpression") || !NON_NAN_RELATIONAL_OPERATORS.has(strippedTest.operator)) return false;
+	return isNodeOfType(strippedTest.left, "Identifier") && hasSameIdentifierBinding(strippedTest.left, identifier) || isNodeOfType(strippedTest.right, "Identifier") && hasSameIdentifierBinding(strippedTest.right, identifier);
+};
+const writeTargetContainsIdentifierBinding = (writeTarget, identifier) => {
+	let containsBinding = false;
+	walkAst(writeTarget, (child) => {
+		if (isNodeOfType(child, "Identifier") && hasSameIdentifierBinding(child, identifier)) {
+			containsBinding = true;
+			return false;
+		}
+	});
+	return containsBinding;
+};
+const hasWriteBeforeQuery = (body, identifier) => {
+	const queryStart = getRangeStart(identifier);
+	if (queryStart === null) return true;
+	let hasEarlierWrite = false;
+	walkAst(body, (child) => {
+		if (hasEarlierWrite) return false;
+		const childStart = getRangeStart(child);
+		if (childStart !== null && childStart >= queryStart) return false;
+		if (child !== body && isFunctionLike$2(child)) return false;
+		const writeTarget = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement") ? child.left : null;
+		if (writeTarget && writeTargetContainsIdentifierBinding(writeTarget, identifier)) {
+			hasEarlierWrite = true;
+			return false;
+		}
+	});
+	return hasEarlierWrite;
+};
+const isProtectedByRelationalLoopGuard = (identifier) => {
+	let descendant = identifier;
+	let ancestor = identifier.parent;
+	while (ancestor) {
+		if (isFunctionLike$2(ancestor)) return false;
+		if ((isNodeOfType(ancestor, "ForStatement") || isNodeOfType(ancestor, "WhileStatement")) && ancestor.body === descendant && testProvesIdentifierIsNotNaN(ancestor.test, identifier)) return !hasWriteBeforeQuery(ancestor.body, identifier);
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isKnownSafeIndexOfQuery = (query) => {
+	if (!query) return false;
+	const strippedQuery = stripParenExpression(query);
+	if (isNodeOfType(strippedQuery, "Literal")) return typeof strippedQuery.value !== "number" || Number.isFinite(strippedQuery.value);
+	if (!isNodeOfType(strippedQuery, "Identifier")) return false;
+	if (isNativeIterationIndex(strippedQuery)) return true;
+	return isProtectedByRelationalLoopGuard(strippedQuery);
+};
+const findSameFileTypeAlias = (reference, typeName) => {
+	const program = findProgramRoot(reference);
+	if (!program) return null;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (declaration && isNodeOfType(declaration, "TSTypeAliasDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === typeName) return declaration;
+	}
+	return null;
+};
+const hasDeclaredMembershipMethod = (members, methodName) => members.some((member) => (isNodeOfType(member, "TSMethodSignature") || isNodeOfType(member, "TSPropertySignature")) && isNodeOfType(member.key, "Identifier") && member.key.name === methodName);
+const isKnownUserlandMembershipReceiver = (receiver, methodName) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const declaredType = getIdentifierDeclaredType(receiver);
+	if (!declaredType) return false;
+	if (isNodeOfType(declaredType, "TSTypeLiteral")) return hasDeclaredMembershipMethod(declaredType.members ?? [], methodName);
+	if (!isNodeOfType(declaredType, "TSTypeReference") || !isNodeOfType(declaredType.typeName, "Identifier")) return false;
+	const typeAlias = findSameFileTypeAlias(receiver, declaredType.typeName.name);
+	if (typeAlias && isNodeOfType(typeAlias.typeAnnotation, "TSTypeLiteral")) return hasDeclaredMembershipMethod(typeAlias.typeAnnotation.members ?? [], methodName);
+	const program = findProgramRoot(receiver);
+	if (!program) return false;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (declaration && isNodeOfType(declaration, "TSInterfaceDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === declaredType.typeName.name) return hasDeclaredMembershipMethod(declaration.body.body, methodName);
+	}
+	return false;
+};
+const findTypeParameter = (reference, typeName) => {
+	let ancestor = reference.parent;
+	while (ancestor) {
+		if (isFunctionLike$2(ancestor) || isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) {
+			const matchingTypeParameter = ancestor.typeParameters?.params?.find((typeParameter) => isNodeOfType(typeParameter, "TSTypeParameter") && isNodeOfType(typeParameter.name, "Identifier") && typeParameter.name.name === typeName);
+			if (matchingTypeParameter && isNodeOfType(matchingTypeParameter, "TSTypeParameter")) return matchingTypeParameter;
+		}
+		ancestor = ancestor.parent;
+	}
+	return null;
+};
+const POSSIBLY_NUMERIC_TYPE_REFERENCE_NAMES = new Set(["NonNullable", "PropertyKey"]);
+const buildTypeAliasArguments = (typeAlias, typeReference, inheritedArguments) => {
+	const typeArguments = new Map(inheritedArguments);
+	for (const [index, typeParameter] of (typeAlias.typeParameters?.params ?? []).entries()) {
+		if (!isNodeOfType(typeParameter, "TSTypeParameter")) continue;
+		if (!isNodeOfType(typeParameter.name, "Identifier")) continue;
+		const argument = typeReference.typeArguments?.params?.[index] ?? typeParameter.default;
+		if (argument) typeArguments.set(typeParameter.name.name, argument);
+	}
+	return typeArguments;
+};
+const typeCanHaveSameValueZeroDifference = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSNumberKeyword") || isNodeOfType(typeNode, "TSAnyKeyword") || isNodeOfType(typeNode, "TSUnknownKeyword")) return true;
+	if (isNodeOfType(typeNode, "TSStringKeyword") || isNodeOfType(typeNode, "TSBooleanKeyword") || isNodeOfType(typeNode, "TSBigIntKeyword") || isNodeOfType(typeNode, "TSSymbolKeyword") || isNodeOfType(typeNode, "TSNullKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword") || isNodeOfType(typeNode, "TSObjectKeyword") || isNodeOfType(typeNode, "TSLiteralType") || isNodeOfType(typeNode, "TSFunctionType")) return false;
+	if (isNodeOfType(typeNode, "TSTypeLiteral")) return (typeNode.members?.length ?? 0) === 0;
+	if (isNodeOfType(typeNode, "TSTypeOperator") && typeNode.operator === "keyof") return false;
+	if (isNodeOfType(typeNode, "TSUnionType") || isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => typeCanHaveSameValueZeroDifference(memberType, reference, activeTypeNodes, typeArguments));
+	if (isNodeOfType(typeNode, "TSOptionalType") || isNodeOfType(typeNode, "TSRestType")) return typeCanHaveSameValueZeroDifference(typeNode.typeAnnotation, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSNamedTupleMember")) return typeCanHaveSameValueZeroDifference(typeNode.elementType, reference, activeTypeNodes, typeArguments);
+	if (!isNodeOfType(typeNode, "TSTypeReference")) return true;
+	if (!isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return typeCanHaveSameValueZeroDifference(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	const typeParameter = findTypeParameter(reference, typeNode.typeName.name);
+	if (typeParameter) {
+		if (!typeParameter.constraint || activeTypeNodes.has(typeParameter)) return true;
+		activeTypeNodes.add(typeParameter);
+		const constraintCanDiffer = typeCanHaveSameValueZeroDifference(typeParameter.constraint, reference, activeTypeNodes, typeArguments);
+		activeTypeNodes.delete(typeParameter);
+		return constraintCanDiffer;
+	}
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias) return POSSIBLY_NUMERIC_TYPE_REFERENCE_NAMES.has(typeNode.typeName.name) || /(?:number|numeric)/i.test(typeNode.typeName.name);
+	if (activeTypeNodes.has(typeAlias)) return true;
+	activeTypeNodes.add(typeAlias);
+	const canDiffer = typeCanHaveSameValueZeroDifference(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return canDiffer;
+};
+const arrayTypeCanHaveSameValueZeroDifference = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSArrayType")) return typeCanHaveSameValueZeroDifference(typeNode.elementType, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSTupleType")) return typeNode.elementTypes.some((elementType) => {
+		if (isNodeOfType(elementType, "TSRestType")) return arrayTypeCanHaveSameValueZeroDifference(elementType.typeAnnotation, reference, activeTypeNodes, typeArguments);
+		if (isNodeOfType(elementType, "TSNamedTupleMember")) return typeCanHaveSameValueZeroDifference(elementType.elementType, reference, activeTypeNodes, typeArguments);
+		return typeCanHaveSameValueZeroDifference(elementType, reference, activeTypeNodes, typeArguments);
+	});
+	if (isNodeOfType(typeNode, "TSTypeOperator")) return arrayTypeCanHaveSameValueZeroDifference(typeNode.typeAnnotation ?? null, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSUnionType") || isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => arrayTypeCanHaveSameValueZeroDifference(memberType, reference, activeTypeNodes, typeArguments));
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return arrayTypeCanHaveSameValueZeroDifference(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return typeCanHaveSameValueZeroDifference(typeNode.typeArguments?.params?.[0] ?? null, reference, activeTypeNodes, typeArguments);
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias || activeTypeNodes.has(typeAlias)) return false;
+	activeTypeNodes.add(typeAlias);
+	const canDiffer = arrayTypeCanHaveSameValueZeroDifference(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return canDiffer;
+};
+const isKnownArrayType = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return true;
+	if (isNodeOfType(typeNode, "TSTypeOperator")) return isKnownArrayType(typeNode.typeAnnotation ?? null, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		const nonNullishTypes = typeNode.types.filter((memberType) => !isNodeOfType(memberType, "TSNullKeyword") && !isNodeOfType(memberType, "TSUndefinedKeyword"));
+		return nonNullishTypes.length > 0 && nonNullishTypes.every((memberType) => isKnownArrayType(memberType, reference, activeTypeNodes, typeArguments));
+	}
+	if (isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => isKnownArrayType(memberType, reference, activeTypeNodes, typeArguments));
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return isKnownArrayType(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return true;
+	const typeParameter = findTypeParameter(reference, typeNode.typeName.name);
+	if (typeParameter?.constraint) {
+		if (activeTypeNodes.has(typeParameter)) return false;
+		activeTypeNodes.add(typeParameter);
+		const isConstraintArray = isKnownArrayType(typeParameter.constraint, reference, activeTypeNodes, typeArguments);
+		activeTypeNodes.delete(typeParameter);
+		return isConstraintArray;
+	}
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias || activeTypeNodes.has(typeAlias)) return false;
+	activeTypeNodes.add(typeAlias);
+	const isArray = isKnownArrayType(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return isArray;
+};
+const isKnownNativeArrayReceiver = (receiver) => {
+	if (isNodeOfType(receiver, "ArrayExpression")) return true;
+	if (isNodeOfType(receiver, "Identifier") && isKnownArrayType(getIdentifierDeclaredType(receiver), receiver, /* @__PURE__ */ new Set())) return true;
+	const initializer = getResolvedInitializer(receiver)?.initializer;
+	if (!initializer) return false;
+	const strippedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(strippedInitializer, "ArrayExpression")) return true;
+	if (isNodeOfType(strippedInitializer, "NewExpression") && isNodeOfType(strippedInitializer.callee, "Identifier") && strippedInitializer.callee.name === "Array" && findVariableInitializer(strippedInitializer.callee, strippedInitializer.callee.name) === null) return true;
+	return isNodeOfType(strippedInitializer, "CallExpression") && isNodeOfType(strippedInitializer.callee, "MemberExpression") && isNodeOfType(strippedInitializer.callee.object, "Identifier") && strippedInitializer.callee.object.name === "Array" && isNodeOfType(strippedInitializer.callee.property, "Identifier") && (strippedInitializer.callee.property.name === "from" || strippedInitializer.callee.property.name === "of") && findVariableInitializer(strippedInitializer.callee.object, strippedInitializer.callee.object.name) === null;
+};
+const isKnownDenseArrayReceiver = (receiver) => {
+	const initializer = isNodeOfType(receiver, "Identifier") ? getResolvedInitializer(receiver)?.initializer : receiver;
+	if (!initializer) return false;
+	const strippedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(strippedInitializer, "ArrayExpression")) return (strippedInitializer.elements ?? []).every((element) => element !== null && !isNodeOfType(element, "SpreadElement"));
+	return isNodeOfType(strippedInitializer, "CallExpression") && isNodeOfType(strippedInitializer.callee, "MemberExpression") && isNodeOfType(strippedInitializer.callee.object, "Identifier") && strippedInitializer.callee.object.name === "Array" && isNodeOfType(strippedInitializer.callee.property, "Identifier") && (strippedInitializer.callee.property.name === "from" || strippedInitializer.callee.property.name === "of") && findVariableInitializer(strippedInitializer.callee.object, strippedInitializer.callee.object.name) === null;
+};
+const isKnownUnsafeIndexOfQuery = (query, receiver) => {
+	if (!query) return true;
+	const strippedQuery = stripParenExpression(query);
+	if (isNodeOfType(strippedQuery, "Identifier")) {
+		if (strippedQuery.name === "undefined" && findVariableInitializer(strippedQuery, strippedQuery.name) === null) return !isKnownDenseArrayReceiver(receiver);
+		if (strippedQuery.name === "NaN" && findVariableInitializer(strippedQuery, strippedQuery.name) === null) return true;
+		return typeCanHaveSameValueZeroDifference(getIdentifierDeclaredType(strippedQuery), strippedQuery, /* @__PURE__ */ new Set());
+	}
+	if (isNodeOfType(strippedQuery, "MemberExpression")) return !strippedQuery.computed && isNodeOfType(strippedQuery.object, "Identifier") && strippedQuery.object.name === "Number" && isNodeOfType(strippedQuery.property, "Identifier") && strippedQuery.property.name === "NaN" && findVariableInitializer(strippedQuery.object, strippedQuery.object.name) === null;
+	return true;
+};
+const isKnownUnsafeIndexOfReceiver = (receiver) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	return arrayTypeCanHaveSameValueZeroDifference(getIdentifierDeclaredType(receiver), receiver, /* @__PURE__ */ new Set());
+};
 const ITERATION_CALLBACK_METHOD_NAMES = new Set([
 	"forEach",
 	"map",
@@ -18481,16 +18897,22 @@ const jsSetMapLookups = defineRule({
 			if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
 			const methodName = node.callee.property.name;
 			if (methodName !== "includes" && methodName !== "indexOf") return;
-			if (methodName === "indexOf" && !isIndexOfResultUsedAsMembershipTest(node)) return;
+			if (methodName === "includes" && !hasSemanticsPreservingIncludesArguments(node)) return;
+			if (methodName === "indexOf" && (node.arguments.length !== 1 || isNodeOfType(node.arguments[0], "SpreadElement") || !isIndexOfResultUsedAsMembershipTest(node))) return;
 			const rawReceiver = node.callee.object;
 			if (!rawReceiver) return;
 			const receiver = stripParenExpression(rawReceiver);
+			const isKnownNativeArray = isKnownNativeArrayReceiver(receiver);
+			if (isKnownUserlandMembershipReceiver(receiver, methodName)) return;
+			if (methodName === "includes" && node.arguments.length === 2 && !isKnownNativeArray) return;
+			const query = node.arguments[0];
+			if (methodName === "indexOf" && !isKnownSafeIndexOfQuery(query) && (isKnownUnsafeIndexOfQuery(query, receiver) || isKnownUnsafeIndexOfReceiver(receiver))) return;
 			if (isLikelyStringReceiver(receiver)) return;
 			if (isSmallInlineLiteralArray(receiver)) return;
 			if (isScreamingSnakeCaseConstantReceiver(receiver)) return;
 			if (isSmallFixedListMember(receiver)) return;
-			if (isSubstringSearchLiteral(node.arguments?.[0])) return;
-			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
+			if (isSubstringSearchLiteral(query)) return;
+			if (isIndexedArrayElementWithStringArgument(receiver, query)) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
 				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
@@ -25123,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")) {
@@ -25534,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;
@@ -26006,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;
@@ -37815,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;
@@ -38137,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.bdd1321",
+  "version": "0.7.7-dev.c79c897",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",