diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.expect.md b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.expect.md
new file mode 100644
index 0000000000..b8c7f8d422
--- /dev/null
+++ b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.expect.md
@@ -0,0 +1,129 @@
+
+## Input
+
+```javascript
+import {makeArray, mutate} from 'shared-runtime';
+
+/**
+ * Bug repro:
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe"}}
+ * Forget:
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe","wat1":"joe"}}
+ *
+ * Fork of `capturing-func-alias-captured-mutate`, but instead of directly
+ * aliasing `y` via `[y]`, we make an opaque call.
+ *
+ * Note that the bug here is that we don't infer that `a = makeArray(y)`
+ * potentially captures a context variable into a local variable. As a result,
+ * we don't understand that `a[0].x = b` captures `x` into `y` -- instead, we're
+ * currently inferring that this lambda captures `y` (for a potential later
+ * mutation) and simply reads `x`.
+ *
+ * Concretely `InferReferenceEffects.hasContextRefOperand` is incorrectly not
+ * used when we analyze CallExpressions.
+ */
+function Component({foo, bar}: {foo: number; bar: number}) {
+ let x = {foo};
+ let y: {bar: number; x?: {foo: number}} = {bar};
+ const f0 = function () {
+ let a = makeArray(y); // a = [y]
+ let b = x;
+ // this writes y.x = x
+ a[0].x = b;
+ };
+ f0();
+ mutate(y.x);
+ return y;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+ fn: Component,
+ params: [{foo: 3, bar: 4}],
+ sequentialRenders: [
+ {foo: 3, bar: 4},
+ {foo: 3, bar: 5},
+ ],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { makeArray, mutate } from "shared-runtime";
+
+/**
+ * Bug repro:
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe"}}
+ * Forget:
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe","wat1":"joe"}}
+ *
+ * Fork of `capturing-func-alias-captured-mutate`, but instead of directly
+ * aliasing `y` via `[y]`, we make an opaque call.
+ *
+ * Note that the bug here is that we don't infer that `a = makeArray(y)`
+ * potentially captures a context variable into a local variable. As a result,
+ * we don't understand that `a[0].x = b` captures `x` into `y` -- instead, we're
+ * currently inferring that this lambda captures `y` (for a potential later
+ * mutation) and simply reads `x`.
+ *
+ * Concretely `InferReferenceEffects.hasContextRefOperand` is incorrectly not
+ * used when we analyze CallExpressions.
+ */
+function Component(t0) {
+ const $ = _c(5);
+ const { foo, bar } = t0;
+ let t1;
+ if ($[0] !== foo) {
+ t1 = { foo };
+ $[0] = foo;
+ $[1] = t1;
+ } else {
+ t1 = $[1];
+ }
+ const x = t1;
+ let y;
+ if ($[2] !== bar || $[3] !== x) {
+ y = { bar };
+ const f0 = function () {
+ const a = makeArray(y);
+ const b = x;
+
+ a[0].x = b;
+ };
+
+ f0();
+ mutate(y.x);
+ $[2] = bar;
+ $[3] = x;
+ $[4] = y;
+ } else {
+ y = $[4];
+ }
+ return y;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+ fn: Component,
+ params: [{ foo: 3, bar: 4 }],
+ sequentialRenders: [
+ { foo: 3, bar: 4 },
+ { foo: 3, bar: 5 },
+ ],
+};
+
+```
+
\ No newline at end of file
diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.ts b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.ts
new file mode 100644
index 0000000000..ca7076fda4
--- /dev/null
+++ b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.ts
@@ -0,0 +1,48 @@
+import {makeArray, mutate} from 'shared-runtime';
+
+/**
+ * Bug repro:
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe"}}
+ * Forget:
+ * (kind: ok)
+ * {"bar":4,"x":{"foo":3,"wat0":"joe"}}
+ * {"bar":5,"x":{"foo":3,"wat0":"joe","wat1":"joe"}}
+ *
+ * Fork of `capturing-func-alias-captured-mutate`, but instead of directly
+ * aliasing `y` via `[y]`, we make an opaque call.
+ *
+ * Note that the bug here is that we don't infer that `a = makeArray(y)`
+ * potentially captures a context variable into a local variable. As a result,
+ * we don't understand that `a[0].x = b` captures `x` into `y` -- instead, we're
+ * currently inferring that this lambda captures `y` (for a potential later
+ * mutation) and simply reads `x`.
+ *
+ * Concretely `InferReferenceEffects.hasContextRefOperand` is incorrectly not
+ * used when we analyze CallExpressions.
+ */
+function Component({foo, bar}: {foo: number; bar: number}) {
+ let x = {foo};
+ let y: {bar: number; x?: {foo: number}} = {bar};
+ const f0 = function () {
+ let a = makeArray(y); // a = [y]
+ let b = x;
+ // this writes y.x = x
+ a[0].x = b;
+ };
+ f0();
+ mutate(y.x);
+ return y;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+ fn: Component,
+ params: [{foo: 3, bar: 4}],
+ sequentialRenders: [
+ {foo: 3, bar: 4},
+ {foo: 3, bar: 5},
+ ],
+};
diff --git a/compiler/packages/snap/src/SproutTodoFilter.ts b/compiler/packages/snap/src/SproutTodoFilter.ts
index 36b3e92f96..3610707396 100644
--- a/compiler/packages/snap/src/SproutTodoFilter.ts
+++ b/compiler/packages/snap/src/SproutTodoFilter.ts
@@ -479,6 +479,7 @@ const skipFilter = new Set([
// bugs
'fbt/bug-fbt-plural-multiple-function-calls',
'fbt/bug-fbt-plural-multiple-mixed-call-tag',
+ `bug-capturing-func-maybealias-captured-mutate`,
'bug-object-expression-computed-key-modified-during-after-construction-hoisted-sequence-expr',
'bug-invalid-hoisting-functionexpr',
'bug-aliased-capture-aliased-mutate',
diff --git a/fixtures/flight/src/App.js b/fixtures/flight/src/App.js
index 49bfc9e051..69fbb5e0af 100644
--- a/fixtures/flight/src/App.js
+++ b/fixtures/flight/src/App.js
@@ -27,7 +27,8 @@ function Foo({children}) {
return {children}
;
}
-function Bar({children}) {
+async function Bar({children}) {
+ await new Promise(resolve => setTimeout(() => resolve('deferred text'), 10));
return {children}
;
}
@@ -81,7 +82,7 @@ export default async function App({prerender}) {
{dedupedChild}
- {dedupedChild}
+ {Promise.resolve([dedupedChild])}