fix: apply sleep/dependency heuristics to callback-based iteration

The loopBodyHasOnlySleepLikeAwaits and hasLoopCarriedDependency checks
were only applied in inspectLoopBody (for/while/do-while) but skipped
for callback-based iteration (.forEach, .map, etc.), causing false
positives on patterns like arr.forEach(async item => { await sleep(500) }).

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: aidenybai

packages/react-doctor/src/plugin/rules/js-performance.ts

@@ -904,9 +904,8 @@ export const asyncAwaitInLoop: Rule = {
         ) {
           return;
         }
-        // `body` is either a BlockStatement (block body) or any
-        // expression (concise body, e.g. `async x => fetch(x)`); walkAst
-        // handles both, so we just walk `body` directly.
+        if (loopBodyHasOnlySleepLikeAwaits(body)) return;
+        if (hasLoopCarriedDependency(body)) return;
         const firstAwait = findFirstAwaitOutsideNestedFunctions(body);
         if (firstAwait) {
           const message =

packages/react-doctor/tests/fixtures/basic-react/src/async-and-handler-issues.tsx

@@ -47,6 +47,30 @@ export const fetchAllUsersParallel = async (ids: string[]) => {
   );
 };
 
+// NEGATIVE case for async-await-in-loop: forEach with only sleep-like awaits.
+// The heuristic must suppress the report just as it does for traditional loops.
+declare const sleep: (ms: number) => Promise<void>;
+declare const process: (item: string) => void;
+
+export const throttledForEach = (items: string[]) => {
+  items.forEach(async (item) => {
+    await sleep(500);
+    process(item);
+  });
+};
+
+// NEGATIVE case for async-await-in-loop: forEach with a loop-carried
+// dependency pattern (assign + read in awaited arg).
+declare const fetchPage: (cursor: string) => Promise<{ next: string; data: string[] }>;
+
+export const paginatedForEach = async (cursors: string[]) => {
+  let token = "start";
+  cursors.forEach(async () => {
+    const page = await fetchPage(token);
+    token = page.next;
+  });
+};
+
 // advanced-event-handler-refs: useEffect re-subscribes when handler prop
 // identity changes.
 export const Ticker = ({ onTick }: { onTick: () => void }) => {