oxlint-plugin-react-doctor 0.9.2-dev.3bc63ea → 0.9.2-dev.444e177

package/dist/index.js

@@ -388,7 +388,7 @@ const SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?)$/i;
 const SCRIPT_SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?|py|php)$/i;
 const DATABASE_SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?|py)$/i;
 const SERVER_CONTEXT_PATTERN = /(?:^|\/)(?:api|backend|server|servers|middleware|route|routes|functions|lambdas|workers)(?:\/|$)|(?:^|\/)[^/]+\.server\.[cm]?[jt]sx?$/i;
-const TEST_CONTEXT_PATTERN = /(?:^|\/)(?:__fixtures__|__mocks__|__tests__|__integration__|fixtures|mocks|test|tests|testdata|test-data|e2e|playwright|cypress|specs?)(?:\/|$)|^(?:test|spec)-[^/]+\.[cm]?[jt]sx?$|\.(?:test|spec|e2e|e2e-spec|integration-test|fixture|fixtures|stories|story)\.[cm]?[jt]sx?$|(?:^|\/)(?:playwright|cypress|vitest|jest|karma)[^/]*\.conf(?:ig)?\.[cm]?[jt]s$|(?:^|\/)(?:test_[^/]+|[^/]+_test|conftest)\.py$|\.env\.[^/]*(?:test|e2e)[^/]*$/i;
+const TEST_CONTEXT_PATTERN = /(?:^|\/)(?:__fixtures__|__mocks__|__tests__|__integration__|fixtures|mocks|test|tests|testdata|test-data|e2e|playwright|cypress|specs?)(?:\/|$)|\.(?:test|spec|e2e|e2e-spec|integration-test|fixture|fixtures|stories|story)\.[cm]?[jt]sx?$|(?:^|\/)(?:playwright|cypress|vitest|jest|karma)[^/]*\.conf(?:ig)?\.[cm]?[jt]s$|(?:^|\/)(?:test_[^/]+|[^/]+_test|conftest)\.py$|\.env\.[^/]*(?:test|e2e)[^/]*$/i;
 const BUILD_CONFIG_FILE_PATTERN = /(?:^|\/)(?:vite|next|nuxt|astro|remix|webpack|rollup|rspack|rsbuild|esbuild|tsup|metro|expo|babel|tailwind|postcss|svelte|farm|parcel|snowpack)[^/]*\.config\.[cm]?[jt]sx?$/i;
 const BUILD_SCRIPT_CONTEXT_PATTERN = /(?:^|\/)scripts(?:\/|$)/i;
 const DEMO_CONTEXT_PATTERN = /(?:^|\/)(?:examples?|tutorials?|demos?|samples?|playgrounds?)(?:\/|$)/i;
@@ -5887,7 +5887,6 @@ const isInlineFunctionExpression = (node) => Boolean(node && (isNodeOfType(node,
 //#endregion
 //#region src/plugin/rules/js-performance/async-await-in-loop.ts
 const LOOP_STATEMENT_TYPES$1 = new Set(LOOP_TYPES);
-const ORDERED_OUTPUT_INSERTION_METHOD_NAMES = new Set(["push", "unshift"]);
 const findFirstAwaitOutsideNestedFunctions = (block, skipNestedLoops = false) => {
 	let firstAwait = null;
 	walkAst(block, (child) => {
@@ -5954,151 +5953,7 @@ const isAwaitingManualPromiseWait = (awaitNode) => {
 	});
 	return isWaitLike;
 };
-const getRootObjectIdentifierName = (node) => {
-	let current = node;
-	while (isNodeOfType(current, "MemberExpression")) current = current.object;
-	return isNodeOfType(current, "Identifier") ? current.name : null;
-};
-const isScopeWithinFunction = (candidateScope, functionScope) => {
-	let currentScope = candidateScope;
-	while (currentScope) {
-		if (currentScope === functionScope) return true;
-		currentScope = currentScope.parent;
-	}
-	return false;
-};
-const isSymbolDirectlyReturned = (symbol, callerFunction) => Boolean(callerFunction) && symbol.references.some((reference) => {
-	const expressionRoot = findTransparentExpressionRoot(reference.identifier);
-	const parent = expressionRoot.parent;
-	return isNodeOfType(parent, "ReturnStatement") && parent.argument === expressionRoot && findEnclosingFunction$1(parent) === callerFunction;
-});
-const collectPatternBindingSymbolIds = (pattern, scopes, target) => {
-	if (isNodeOfType(pattern, "Identifier")) {
-		const symbol = scopes.symbolFor(pattern);
-		if (symbol) target.add(symbol.id);
-		return;
-	}
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		for (const property of pattern.properties ?? []) if (isNodeOfType(property, "Property") && property.value) collectPatternBindingSymbolIds(property.value, scopes, target);
-		else if (isNodeOfType(property, "RestElement") && property.argument) collectPatternBindingSymbolIds(property.argument, scopes, target);
-		return;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements ?? []) if (element) collectPatternBindingSymbolIds(element, scopes, target);
-		return;
-	}
-	if (isNodeOfType(pattern, "AssignmentPattern") && pattern.left) collectPatternBindingSymbolIds(pattern.left, scopes, target);
-};
-const collectReferencedSymbolIds = (expression, scopes) => {
-	const referencedSymbolIds = /* @__PURE__ */ new Set();
-	walkAst(expression, (child) => {
-		if (child !== expression && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "Identifier")) return;
-		const symbol = scopes.symbolFor(child);
-		if (symbol) referencedSymbolIds.add(symbol.id);
-	});
-	return referencedSymbolIds;
-};
-const collectAwaitDerivedSymbolIds = (block, scopes) => {
-	const awaitDerivedSymbolIds = /* @__PURE__ */ new Set();
-	const bindingDependencies = [];
-	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && child.id && child.init) {
-			const declaredSymbolIds = /* @__PURE__ */ new Set();
-			collectPatternBindingSymbolIds(child.id, scopes, declaredSymbolIds);
-			if (containsDirectAwait(child.init)) for (const symbolId of declaredSymbolIds) awaitDerivedSymbolIds.add(symbolId);
-			const referencedSymbolIds = collectReferencedSymbolIds(child.init, scopes);
-			for (const declaredSymbolId of declaredSymbolIds) bindingDependencies.push({
-				declaredSymbolId,
-				referencedSymbolIds
-			});
-			return;
-		}
-		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
-			const assignedSymbolIds = /* @__PURE__ */ new Set();
-			collectPatternBindingSymbolIds(child.left, scopes, assignedSymbolIds);
-			if (containsDirectAwait(child.right)) for (const symbolId of assignedSymbolIds) awaitDerivedSymbolIds.add(symbolId);
-			const referencedSymbolIds = collectReferencedSymbolIds(child.right, scopes);
-			for (const assignedSymbolId of assignedSymbolIds) bindingDependencies.push({
-				declaredSymbolId: assignedSymbolId,
-				referencedSymbolIds
-			});
-		}
-	});
-	let didGrow = true;
-	while (didGrow) {
-		didGrow = false;
-		for (const { declaredSymbolId, referencedSymbolIds } of bindingDependencies) {
-			if (awaitDerivedSymbolIds.has(declaredSymbolId)) continue;
-			for (const referencedSymbolId of referencedSymbolIds) {
-				if (!awaitDerivedSymbolIds.has(referencedSymbolId)) continue;
-				awaitDerivedSymbolIds.add(declaredSymbolId);
-				didGrow = true;
-				break;
-			}
-		}
-	}
-	return awaitDerivedSymbolIds;
-};
-const getSimpleParameterIdentifier = (parameter) => {
-	if (isNodeOfType(parameter, "Identifier")) return parameter;
-	if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) return parameter.left;
-	return null;
-};
-const doesAwaitedLocalCallInsertAwaitDerivedOutput = (awaitNode, context) => {
-	if (!isNodeOfType(awaitNode, "AwaitExpression")) return false;
-	const callExpression = awaitNode.argument;
-	if (!isNodeOfType(callExpression, "CallExpression")) return false;
-	const localFunction = resolveStaticLocalCallFunction(callExpression, context.scopes);
-	if (!isFunctionLike$1(localFunction)) return false;
-	const callerFunction = findEnclosingFunction$1(callExpression);
-	const functionScope = context.scopes.ownScopeFor(localFunction);
-	if (!functionScope) return false;
-	const awaitDerivedSymbolIds = collectAwaitDerivedSymbolIds(localFunction.body, context.scopes);
-	const externallyReachableParameterSymbolIds = /* @__PURE__ */ new Set();
-	for (const [parameterIndex, parameter] of localFunction.params.entries()) {
-		const parameterIdentifier = getSimpleParameterIdentifier(parameter);
-		if (!parameterIdentifier) continue;
-		const argument = callExpression.arguments[parameterIndex];
-		if (!isNodeOfType(argument, "Identifier")) continue;
-		const parameterSymbol = context.scopes.symbolFor(parameterIdentifier);
-		const argumentSymbol = context.scopes.symbolFor(argument);
-		if (parameterSymbol && argumentSymbol && (isSymbolDirectlyReturned(argumentSymbol, callerFunction) || argumentSymbol.id === parameterSymbol.id)) externallyReachableParameterSymbolIds.add(parameterSymbol.id);
-	}
-	let doesInsertAwaitDerivedOutput = false;
-	walkAst(localFunction.body, (child) => {
-		if (doesInsertAwaitDerivedOutput) return false;
-		if (child !== localFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !ORDERED_OUTPUT_INSERTION_METHOD_NAMES.has(callee.property.name)) return;
-		let doesMutationConsumeAwaitedValue = false;
-		for (const mutationArgument of child.arguments ?? []) {
-			if (containsDirectAwait(mutationArgument)) {
-				doesMutationConsumeAwaitedValue = true;
-				break;
-			}
-			const referencedSymbolIds = collectReferencedSymbolIds(mutationArgument, context.scopes);
-			for (const referencedSymbolId of referencedSymbolIds) if (awaitDerivedSymbolIds.has(referencedSymbolId)) {
-				doesMutationConsumeAwaitedValue = true;
-				break;
-			}
-			if (doesMutationConsumeAwaitedValue) break;
-		}
-		if (!doesMutationConsumeAwaitedValue) return;
-		let receiverIdentifier = callee.object;
-		while (isNodeOfType(receiverIdentifier, "MemberExpression")) receiverIdentifier = receiverIdentifier.object;
-		if (!isNodeOfType(receiverIdentifier, "Identifier")) return;
-		const receiverSymbol = context.scopes.symbolFor(receiverIdentifier);
-		if (receiverSymbol && (externallyReachableParameterSymbolIds.has(receiverSymbol.id) || !isScopeWithinFunction(receiverSymbol.scope, functionScope) && isSymbolDirectlyReturned(receiverSymbol, callerFunction))) {
-			doesInsertAwaitDerivedOutput = true;
-			return false;
-		}
-	});
-	return doesInsertAwaitDerivedOutput;
-};
-const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode) || doesAwaitedLocalCallInsertAwaitDerivedOutput(awaitNode, context);
+const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
 const collectPatternIdentifiers = (pattern, target) => {
 	if (isNodeOfType(pattern, "Identifier")) target.add(pattern.name);
 	else if (isNodeOfType(pattern, "ObjectPattern")) {
@@ -6244,6 +6099,11 @@ const loopBodyHasAwaitDependentEarlyExit = (block, loopLabelName) => {
 	});
 	return hasAwaitDependentExit;
 };
+const getRootObjectIdentifierName = (node) => {
+	let current = node;
+	while (isNodeOfType(current, "MemberExpression")) current = current.object;
+	return isNodeOfType(current, "Identifier") ? current.name : null;
+};
 const MUTATING_ARRAY_METHOD_NAMES$2 = new Set([
 	...ARRAY_MUTATION_METHOD_NAMES,
 	"pop",
@@ -30674,8 +30534,7 @@ const STRING_TYPED_PROPERTY_NAMES = new Set([
 	"code",
 	"label",
 	"slug",
-	"prefix",
-	"__html"
+	"prefix"
 ]);
 const STRING_TYPED_IDENTIFIER_SUFFIXES = [
 	"Text",
@@ -30793,25 +30652,13 @@ const STRING_TYPED_IDENTIFIER_NAMES = new Set([
 	"title"
 ]);
 const STRING_RETURNING_CALLEE_PREFIX_PATTERN = /^(?:normalize|format|stringify|serialize)/;
-const FRESH_ARRAY_METHOD_NAMES$2 = new Set([
-	"concat",
-	"filter",
-	"flat",
-	"flatMap",
-	"map",
-	"slice",
-	"split"
-]);
 const isLikelyStringReceiver = (receiver) => {
 	if (!receiver) return false;
-	const unwrappedReceiver = stripParenExpression(receiver);
-	if (unwrappedReceiver !== receiver) return isLikelyStringReceiver(unwrappedReceiver);
 	if (isNodeOfType(receiver, "Literal") && typeof receiver.value === "string") return true;
 	if (isNodeOfType(receiver, "TemplateLiteral")) return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "Identifier") && receiver.callee.name === "String") return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "MemberExpression") && isNodeOfType(receiver.callee.property, "Identifier") && STRING_RETURNING_METHODS.has(receiver.callee.property.name)) return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "Identifier") && STRING_RETURNING_CALLEE_PREFIX_PATTERN.test(receiver.callee.name)) return true;
-	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "MemberExpression") && isNodeOfType(receiver.callee.property, "Identifier") && (receiver.callee.property.name === "concat" || receiver.callee.property.name === "slice") && isLikelyStringReceiver(receiver.callee.object)) return true;
 	if (isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.property, "Identifier")) {
 		if (STRING_TYPED_PROPERTY_NAMES.has(receiver.property.name)) return true;
 	}
@@ -30829,46 +30676,8 @@ const isLikelyStringReceiver = (receiver) => {
 	}
 	if (isNodeOfType(receiver, "BinaryExpression") && receiver.operator === "+") return isLikelyStringReceiver(receiver.left) || isLikelyStringReceiver(receiver.right);
 	if (isNodeOfType(receiver, "ConditionalExpression")) return isLikelyStringReceiver(receiver.consequent) && isLikelyStringReceiver(receiver.alternate);
-	if (isNodeOfType(receiver, "LogicalExpression")) return isLikelyStringReceiver(receiver.left) && isLikelyStringReceiver(receiver.right);
 	return false;
 };
-const isFreshArrayReceiver = (receiver) => {
-	const unwrappedReceiver = stripParenExpression(receiver);
-	if (unwrappedReceiver !== receiver) return isFreshArrayReceiver(unwrappedReceiver);
-	if (!isNodeOfType(receiver, "CallExpression") || !isNodeOfType(receiver.callee, "MemberExpression") || !isNodeOfType(receiver.callee.property, "Identifier")) return false;
-	if (!FRESH_ARRAY_METHOD_NAMES$2.has(receiver.callee.property.name)) return false;
-	if (receiver.callee.property.name === "split") return isLikelyStringReceiver(receiver.callee.object);
-	const sourceReceiver = stripParenExpression(receiver.callee.object);
-	return isKnownNativeArrayReceiver(sourceReceiver) || isFreshArrayReceiver(sourceReceiver);
-};
-const isSmallRestHelperOmissionList = (node) => {
-	if (!node) return false;
-	const candidate = stripParenExpression(node);
-	if (!isNodeOfType(candidate, "ArrayExpression")) return false;
-	const elements = candidate.elements ?? [];
-	return elements.length <= 8 && elements.every((element) => element === null || !isNodeOfType(element, "SpreadElement"));
-};
-const isTypeScriptRestHelperLookup = (lookupCall, receiver, scopes) => {
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const enclosingFunction = findEnclosingFunction$1(lookupCall);
-	if (!isNodeOfType(enclosingFunction, "FunctionExpression") || !isNodeOfType(enclosingFunction.params?.[1], "Identifier") || enclosingFunction.params[1].name !== receiver.name) return false;
-	let bindingIdentifier = null;
-	let ancestor = enclosingFunction.parent;
-	while (ancestor && !isFunctionLike$1(ancestor)) {
-		if (isNodeOfType(ancestor, "VariableDeclarator") && isNodeOfType(ancestor.id, "Identifier") && ancestor.id.name === "__rest") {
-			bindingIdentifier = ancestor.id;
-			break;
-		}
-		ancestor = ancestor.parent;
-	}
-	if (!bindingIdentifier) return false;
-	const helperSymbol = scopes.symbolFor(bindingIdentifier);
-	if (!helperSymbol || helperSymbol.references.length === 0) return false;
-	return helperSymbol.references.every((reference) => {
-		const callExpression = reference.identifier.parent;
-		return isNodeOfType(callExpression, "CallExpression") && callExpression.callee === reference.identifier && isSmallRestHelperOmissionList(callExpression.arguments?.[1]);
-	});
-};
 const INDEX_LIKE_IDENTIFIER_NAMES = new Set([
 	"i",
 	"j",
@@ -31465,8 +31274,6 @@ const jsSetMapLookups = defineRule({
 			const query = node.arguments[0];
 			if (methodName === "indexOf" && !isKnownSafeIndexOfQuery(query) && (isKnownUnsafeIndexOfQuery(query, receiver) || isKnownUnsafeIndexOfReceiver(receiver))) return;
 			if (isLikelyStringReceiver(receiver)) return;
-			if (isFreshArrayReceiver(receiver)) return;
-			if (isTypeScriptRestHelperLookup(node, receiver, context.scopes)) return;
 			if (isSmallInlineLiteralArray(receiver)) return;
 			if (isScreamingSnakeCaseConstantReceiver(receiver)) return;
 			if (isSmallFixedListMember(receiver)) return;
@@ -46908,101 +46715,6 @@ const isLoopCounterDeclarator = (declarator, referenceNode, indexName) => {
 	}
 	return isBindingReassignedOrMutated(referenceNode, indexName);
 };
-const findEnclosingWhileLoop = (node) => {
-	let current = node.parent;
-	while (current) {
-		if (isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return current;
-		if (isFunctionLike$1(current) || isNodeOfType(current, "Program")) return null;
-		current = current.parent;
-	}
-	return null;
-};
-const isStaticMemberChain = (expression) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "ThisExpression")) return true;
-	return Boolean(isNodeOfType(candidate, "MemberExpression") && !candidate.computed && isNodeOfType(candidate.property, "Identifier") && isStaticMemberChain(candidate.object));
-};
-const findLengthBoundCollections = (expression) => {
-	const collections = [];
-	walkAst(expression, (child) => {
-		if (isNodeOfType(child, "MemberExpression") && !child.computed && isStaticMemberChain(child.object) && isNodeOfType(child.property, "Identifier") && child.property.name === "length") collections.push(child.object);
-	});
-	return collections;
-};
-const areSameBoundStaticMemberChains = (first, second) => isStaticMemberChain(first) && isStaticMemberChain(second) && areExpressionsStructurallyEqual(first, second, { areIdentifiersEqual: (firstIdentifier, secondIdentifier) => {
-	if (!isNodeOfType(firstIdentifier, "Identifier") || !isNodeOfType(secondIdentifier, "Identifier") || firstIdentifier.name !== secondIdentifier.name) return false;
-	const firstBinding = findVariableInitializer(firstIdentifier, firstIdentifier.name);
-	const secondBinding = findVariableInitializer(secondIdentifier, secondIdentifier.name);
-	return firstBinding?.bindingIdentifier === secondBinding?.bindingIdentifier;
-} });
-const RELATIONAL_BOUND_OPERATORS = new Set([
-	"<",
-	"<=",
-	">",
-	">="
-]);
-const loopTestBoundsCounterByLength = (expression, indexName, bindingIdentifier) => {
-	const readsCounter = (candidate) => {
-		let didReadCounter = false;
-		walkAst(candidate, (child) => {
-			if (didReadCounter) return false;
-			if (isNodeOfType(child, "Identifier") && child.name === indexName && findVariableInitializer(child, indexName)?.bindingIdentifier === bindingIdentifier) {
-				didReadCounter = true;
-				return false;
-			}
-		});
-		return didReadCounter;
-	};
-	const readsLength = (candidate) => {
-		let didReadLength = false;
-		walkAst(candidate, (child) => {
-			if (didReadLength) return false;
-			if (isNodeOfType(child, "MemberExpression") && !child.computed && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
-				didReadLength = true;
-				return false;
-			}
-		});
-		return didReadLength;
-	};
-	let didFindLengthBound = false;
-	walkAst(expression, (child) => {
-		if (didFindLengthBound) return false;
-		if (!isNodeOfType(child, "BinaryExpression") || !RELATIONAL_BOUND_OPERATORS.has(child.operator)) return;
-		if (readsCounter(child.left) && readsLength(child.right) || readsCounter(child.right) && readsLength(child.left)) {
-			didFindLengthBound = true;
-			return false;
-		}
-	});
-	return didFindLengthBound;
-};
-const isDataIndexedWhileLoopCounter = (referenceNode, bindingIdentifier, indexName) => {
-	if (!INDEX_PARAMETER_NAMES.has(indexName)) return false;
-	const loop = findEnclosingWhileLoop(referenceNode);
-	if (!loop) return false;
-	let doesTestReadCounter = false;
-	walkAst(loop.test, (child) => {
-		if (doesTestReadCounter) return false;
-		if (!isNodeOfType(child, "Identifier") || child.name !== indexName) return;
-		if (findVariableInitializer(child, indexName)?.bindingIdentifier === bindingIdentifier) {
-			doesTestReadCounter = true;
-			return false;
-		}
-	});
-	if (!doesTestReadCounter) return false;
-	const lengthBoundCollections = findLengthBoundCollections(loop.test);
-	if (lengthBoundCollections.length === 0) return false;
-	let didFindIndexedCollectionRead = false;
-	walkAst(loop.body, (child) => {
-		if (didFindIndexedCollectionRead) return false;
-		if (isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "MemberExpression") || !child.computed || !isNodeOfType(child.property, "Identifier") || child.property.name !== indexName) return;
-		if (findVariableInitializer(child.property, indexName)?.bindingIdentifier === bindingIdentifier && lengthBoundCollections.some((collection) => areSameBoundStaticMemberChains(collection, child.object))) {
-			didFindIndexedCollectionRead = true;
-			return false;
-		}
-	});
-	return didFindIndexedCollectionRead;
-};
 /**
 * Resolves whether an identifier is PROVABLY the positional array
 * index, by classifying its binding. Per the official rule prompt,
@@ -47053,12 +46765,6 @@ const resolvePositionalIndexBinding = (identifierNode, depth) => {
 	}
 	const declarator = binding.bindingIdentifier.parent;
 	if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declarator.id === binding.bindingIdentifier && declarator.init) {
-		if (isDataIndexedWhileLoopCounter(identifierNode, binding.bindingIdentifier, identifierNode.name)) return {
-			iteratorCall: null,
-			bindingFunction: null,
-			indexParameterPosition: null,
-			isDataIndexedLoopCounter: true
-		};
 		const initializer = stripParenExpression(declarator.init);
 		if (isNodeOfType(initializer, "Literal") && typeof initializer.value === "number") {
 			if (!INDEX_PARAMETER_NAMES.has(identifierNode.name)) return null;
@@ -47093,101 +46799,6 @@ const iteratorCallExemptsIndexKey = (iteratorCall) => {
 	const receiver = iteratorCall.callee.object;
 	return isStaticPlaceholderReceiver(receiver) || isFixedMemoReceiver(receiver) || isStaticDefaultLiteralReceiver(receiver) || isStringDerivedReceiver(receiver);
 };
-const isReactNamespaceIdentifier = (node) => {
-	if (!isNodeOfType(node, "Identifier")) return false;
-	const importBinding = getImportBindingForName(node, node.name);
-	const visibleBinding = findVariableInitializer(node, node.name);
-	if (!importBinding) return node.name === "React" && !visibleBinding;
-	return visibleBinding?.initializer?.type.startsWith("Import") === true && importBinding.source === "react" && (importBinding.isNamespace || importBinding.exportedName === "default");
-};
-const isReactChildrenObject = (node) => {
-	const candidate = stripParenExpression(node);
-	if (isNodeOfType(candidate, "Identifier")) {
-		const importBinding = getImportBindingForName(candidate, candidate.name);
-		const visibleBinding = findVariableInitializer(candidate, candidate.name);
-		return Boolean(visibleBinding?.initializer?.type === "ImportSpecifier" && importBinding?.source === "react" && importBinding.exportedName === "Children");
-	}
-	return Boolean(isNodeOfType(candidate, "MemberExpression") && !candidate.computed && isReactNamespaceIdentifier(candidate.object) && isNodeOfType(candidate.property, "Identifier") && candidate.property.name === "Children");
-};
-const isReactChildrenToArrayCall = (node) => {
-	const candidate = stripParenExpression(node);
-	if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || candidate.callee.computed || !isReactChildrenObject(candidate.callee.object) || !isNodeOfType(candidate.callee.property, "Identifier") || candidate.callee.property.name !== "toArray") return false;
-	const normalizedValueNode = candidate.arguments?.[0];
-	const normalizedValue = normalizedValueNode ? stripParenExpression(normalizedValueNode) : null;
-	if (!normalizedValue || !isNodeOfType(normalizedValue, "Identifier") || normalizedValue.name !== "children") return false;
-	const normalizedBinding = findVariableInitializer(normalizedValue, normalizedValue.name);
-	return Boolean(normalizedBinding && findEnclosingParameter(normalizedBinding.bindingIdentifier));
-};
-const isSameIdentifier = (first, second) => {
-	const firstIdentifier = stripParenExpression(first);
-	const secondIdentifier = stripParenExpression(second);
-	if (!isNodeOfType(firstIdentifier, "Identifier") || !isNodeOfType(secondIdentifier, "Identifier") || firstIdentifier.name !== secondIdentifier.name) return false;
-	const firstBinding = findVariableInitializer(firstIdentifier, firstIdentifier.name);
-	const secondBinding = findVariableInitializer(secondIdentifier, secondIdentifier.name);
-	return firstBinding?.bindingIdentifier === secondBinding?.bindingIdentifier;
-};
-const isReactChildrenArrayNormalization = (node) => {
-	const candidate = stripParenExpression(node);
-	if (!isNodeOfType(candidate, "ConditionalExpression")) return false;
-	const test = stripParenExpression(candidate.test);
-	if (!isNodeOfType(test, "CallExpression") || !isNodeOfType(test.callee, "MemberExpression") || test.callee.computed || !isNodeOfType(test.callee.object, "Identifier") || test.callee.object.name !== "Array" || findVariableInitializer(test.callee.object, "Array") || !isNodeOfType(test.callee.property, "Identifier") || test.callee.property.name !== "isArray") return false;
-	const testedValueNode = test.arguments?.[0];
-	if (!testedValueNode) return false;
-	const testedValue = stripParenExpression(testedValueNode);
-	if (!isNodeOfType(testedValue, "Identifier")) return false;
-	const testedBinding = findVariableInitializer(testedValue, testedValue.name);
-	if (testedValue.name !== "children" || !testedBinding || !findEnclosingParameter(testedBinding.bindingIdentifier)) return false;
-	const branchWrapsTestedValue = (branch) => {
-		const unwrappedBranch = stripParenExpression(branch);
-		return isNodeOfType(unwrappedBranch, "ArrayExpression") && unwrappedBranch.elements?.length === 1 && Boolean(unwrappedBranch.elements[0] && isSameIdentifier(unwrappedBranch.elements[0], testedValue));
-	};
-	return isSameIdentifier(candidate.consequent, testedValue) && branchWrapsTestedValue(candidate.alternate) || isSameIdentifier(candidate.alternate, testedValue) && branchWrapsTestedValue(candidate.consequent);
-};
-const isMutatedEmptyArrayBinding = (identifierNode, depth) => {
-	const binding = findVariableInitializer(identifierNode, identifierNode.name);
-	const initializer = binding?.initializer ? stripParenExpression(binding.initializer) : null;
-	if (!binding || !initializer || !isNodeOfType(initializer, "ArrayExpression") || initializer.elements?.length !== 0) return false;
-	const program = findProgramRoot(identifierNode);
-	if (!program) return false;
-	let didFindReactChildPush = false;
-	walkAst(program, (child) => {
-		if (didFindReactChildPush) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || child.callee.computed || !isNodeOfType(child.callee.object, "Identifier") || child.callee.object.name !== identifierNode.name || !isNodeOfType(child.callee.property, "Identifier") || child.callee.property.name !== "push") return;
-		if (findVariableInitializer(child.callee.object, identifierNode.name)?.bindingIdentifier === binding.bindingIdentifier && (child.arguments ?? []).some((argument) => {
-			const candidate = stripParenExpression(argument);
-			if (!(isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "JSXElement") || isNodeOfType(candidate, "JSXFragment"))) return false;
-			let doesCarryReactChild = false;
-			walkAst(candidate, (argumentChild) => {
-				if (doesCarryReactChild) return false;
-				if (!isNodeOfType(argumentChild, "Identifier")) return;
-				const declarator = findVariableInitializer(argumentChild, argumentChild.name)?.bindingIdentifier.parent;
-				const declaration = declarator?.parent;
-				const forOfStatement = declaration?.parent;
-				if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declaration && isNodeOfType(declaration, "VariableDeclaration") && forOfStatement && isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.left === declaration && isDynamicReactChildrenExpression(forOfStatement.right, depth + 1)) {
-					doesCarryReactChild = true;
-					return false;
-				}
-			});
-			return doesCarryReactChild;
-		})) {
-			didFindReactChildPush = true;
-			return false;
-		}
-	});
-	return didFindReactChildPush;
-};
-const isDynamicReactChildrenExpression = (expression, depth) => {
-	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT$2) return false;
-	const candidate = stripParenExpression(expression);
-	if (isReactChildrenToArrayCall(candidate) || isReactChildrenArrayNormalization(candidate)) return true;
-	if (isNodeOfType(candidate, "Identifier")) {
-		if (isMutatedEmptyArrayBinding(candidate, depth)) return true;
-		const binding = findVariableInitializer(candidate, candidate.name);
-		return Boolean(binding?.initializer && isDynamicReactChildrenExpression(binding.initializer, depth + 1));
-	}
-	if (isNodeOfType(candidate, "CallExpression") && isNodeOfType(candidate.callee, "MemberExpression") && !candidate.callee.computed && isNodeOfType(candidate.callee.property, "Identifier") && candidate.callee.property.name === "filter") return isDynamicReactChildrenExpression(candidate.callee.object, depth + 1);
-	return false;
-};
 const resolveKeyTemplateLiteral = (expression) => {
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "TemplateLiteral")) return node;
@@ -47240,19 +46851,28 @@ const findBareItemNamesReferencedByTemplate = (template, itemNames) => {
 	}
 	return referencedItemNames;
 };
-const isNumericPlaceholderLoopCounter = (attributeNode, indexName) => {
+const forLoopTestReadsDataLength = (test) => {
+	let didFindLengthRead = false;
+	walkAst(test, (child) => {
+		if (didFindLengthRead) return false;
+		if (isNodeOfType(child, "MemberExpression") && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
+			didFindLengthRead = true;
+			return false;
+		}
+	});
+	return didFindLengthRead;
+};
+const isNumericForLoopCounter = (attributeNode, indexName) => {
 	const binding = findVariableInitializer(attributeNode, indexName);
 	if (!binding) return false;
 	const declarator = binding.bindingIdentifier.parent;
 	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
 	const declaration = declarator.parent;
 	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return false;
-	if (!declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
 	const forStatement = declaration.parent;
-	if (forStatement && isNodeOfType(forStatement, "ForStatement") && forStatement.init === declaration) return !(forStatement.test && loopTestBoundsCounterByLength(forStatement.test, indexName, binding.bindingIdentifier));
-	const whileLoop = findEnclosingWhileLoop(attributeNode);
-	if (!whileLoop) return false;
-	return !loopTestBoundsCounterByLength(whileLoop.test, indexName, binding.bindingIdentifier);
+	if (!forStatement || !isNodeOfType(forStatement, "ForStatement") || forStatement.init !== declaration || !declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
+	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
+	return true;
 };
 const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
 const findIteratorItemNamesOfBinding = (binding) => {
@@ -47286,11 +46906,11 @@ const collectDerivedRowContentNames = (bindingFunction, itemNames) => {
 * observable harm; anything stateful — form controls, media, custom
 * components, unknown calls — keeps the diagnostic.
 */
-const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames, areBareItemsDynamicReactChildren) => {
+const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames) => {
 	const jsxElement = openingElement.parent;
 	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement")) return false;
 	const children = jsxElement.children ?? [];
-	const bareIdentifierNames = children.some((child) => isNodeOfType(child, "JSXElement")) ? derivedNames : areBareItemsDynamicReactChildren ? derivedNames : new Set([...derivedNames, ...itemNames]);
+	const bareIdentifierNames = children.some((child) => isNodeOfType(child, "JSXElement")) ? derivedNames : new Set([...derivedNames, ...itemNames]);
 	return children.some((child) => containsStatefulDescendant(child, {
 		memberRootNames: itemNames,
 		allowAnyMemberRead: true,
@@ -47298,15 +46918,6 @@ const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames, ar
 		callCalleeRootNames: itemNames
 	}));
 };
-const elementHasDirectItemChild = (openingElement, itemNames) => {
-	const jsxElement = openingElement.parent;
-	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement")) return false;
-	return (jsxElement.children ?? []).some((child) => {
-		if (!isNodeOfType(child, "JSXExpressionContainer")) return false;
-		const expression = stripParenExpression(child.expression);
-		return isNodeOfType(expression, "Identifier") && itemNames.has(expression.name);
-	});
-};
 const callbackFiltersRows = (bindingFunction) => {
 	if (!bindingFunction) return false;
 	let didFindNullReturn = false;
@@ -47358,21 +46969,19 @@ const noArrayIndexAsKey = defineRule({
 		const indexUse = findPositionalIndexUse(node.value.expression, 0);
 		if (!indexUse) return;
 		const indexName = indexUse.identifier.name;
-		if (isNumericPlaceholderLoopCounter(node, indexName)) return;
+		if (isNumericForLoopCounter(node, indexName)) return;
 		if (indexUse.binding.iteratorCall && iteratorCallExemptsIndexKey(indexUse.binding.iteratorCall)) return;
 		const keyTemplate = resolveKeyTemplateLiteral(node.value.expression);
 		if (keyTemplate && templateHasOuterMemberIdentity(keyTemplate, indexUse.binding.bindingFunction)) return;
-		if (hasAriaHiddenAncestor(node) && !indexUse.binding.isDataIndexedLoopCounter) return;
+		if (hasAriaHiddenAncestor(node)) return;
 		const itemNames = findIteratorItemNamesOfBinding(indexUse.binding);
 		const derivedNames = collectDerivedRowContentNames(indexUse.binding.bindingFunction, itemNames);
-		const iteratorCallee = indexUse.binding.iteratorCall?.callee;
-		const hasDynamicReactChildren = Boolean(iteratorCallee && isNodeOfType(iteratorCallee, "MemberExpression") && isDynamicReactChildrenExpression(iteratorCallee.object, 0));
 		const openingElement = node.parent;
 		if (openingElement && isNodeOfType(openingElement, "JSXOpeningElement")) {
 			const elementName = openingElement.name;
 			if (isNodeOfType(elementName, "JSXIdentifier")) {
 				if (elementName.name === "Fragment") {
-					if (!fragmentHasStatefulChildren(openingElement, itemNames, derivedNames, hasDynamicReactChildren)) return;
+					if (!fragmentHasStatefulChildren(openingElement, itemNames, derivedNames)) return;
 				} else if (PURE_SVG_PRIMITIVE_TAGS.has(elementName.name)) {
 					if (!callbackFiltersRows(indexUse.binding.bindingFunction)) return;
 				} else if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
@@ -47380,14 +46989,14 @@ const noArrayIndexAsKey = defineRule({
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
 						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
 						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET$1;
-						if (!(hasDynamicReactChildren && elementHasDirectItemChild(openingElement, itemNames) || containsStatefulDescendant(jsxElement, {
+						if (!containsStatefulDescendant(jsxElement, {
 							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET$1,
 							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
-						}))) return;
+						})) return;
 					}
 				}
 			}
-			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment" && !fragmentHasStatefulChildren(openingElement, itemNames, derivedNames, hasDynamicReactChildren)) return;
+			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment" && !fragmentHasStatefulChildren(openingElement, itemNames, derivedNames)) return;
 		}
 		context.report({
 			node,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.9.2-dev.3bc63ea",
+  "version": "0.9.2-dev.444e177",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",