Update fixture snapshots after ObjectMethod removal (#36151)

Method shorthand now lowered to FunctionExpression in BuildHIR, so all
object-method fixtures emit function() syntax instead of method() syntax.
Also adds two new bug fixtures demonstrating consistent memoization for
objects with mixed fn-expression / arrow / shorthand methods.

Author: Bobadu

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-inconsistent-memoization-object-fn-expression.expect.md

@@ -0,0 +1,70 @@
+
+## Input
+
+```javascript
+function Component({a, b}) {
+  return {
+    test1: () => {
+      console.log(a);
+    },
+    test2: function () {
+      console.log(b);
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: 1, b: 2}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(t0) {
+  const $ = _c(7);
+  const { a, b } = t0;
+  let t1;
+  if ($[0] !== a) {
+    t1 = () => {
+      console.log(a);
+    };
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== b) {
+    t2 = function () {
+      console.log(b);
+    };
+    $[2] = b;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== t1 || $[5] !== t2) {
+    t3 = { test1: t1, test2: t2 };
+    $[4] = t1;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ a: 1, b: 2 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) {"test1":"[[ function params=0 ]]","test2":"[[ function params=0 ]]"}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-inconsistent-memoization-object-fn-expression.js

@@ -0,0 +1,15 @@
+function Component({a, b}) {
+  return {
+    test1: () => {
+      console.log(a);
+    },
+    test2: function () {
+      console.log(b);
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: 1, b: 2}],
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-inconsistent-memoization-object-mixed.expect.md

@@ -0,0 +1,84 @@
+
+## Input
+
+```javascript
+function Component({a, b, c}) {
+  return {
+    test1() {
+      console.log(a);
+    },
+    test2: () => {
+      console.log(b);
+    },
+    test3: function () {
+      console.log(c);
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: 1, b: 2, c: 3}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(t0) {
+  const $ = _c(10);
+  const { a, b, c } = t0;
+  let t1;
+  if ($[0] !== a) {
+    t1 = function () {
+      console.log(a);
+    };
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== b) {
+    t2 = () => {
+      console.log(b);
+    };
+    $[2] = b;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== c) {
+    t3 = function () {
+      console.log(c);
+    };
+    $[4] = c;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== t1 || $[7] !== t2 || $[8] !== t3) {
+    t4 = { test1: t1, test2: t2, test3: t3 };
+    $[6] = t1;
+    $[7] = t2;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ a: 1, b: 2, c: 3 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) {"test1":"[[ function params=0 ]]","test2":"[[ function params=0 ]]","test3":"[[ function params=0 ]]"}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-inconsistent-memoization-object-mixed.js

@@ -0,0 +1,18 @@
+function Component({a, b, c}) {
+  return {
+    test1() {
+      console.log(a);
+    },
+    test2: () => {
+      console.log(b);
+    },
+    test3: function () {
+      console.log(c);
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: 1, b: 2, c: 3}],
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md

@@ -29,7 +29,7 @@ import { c as _c } from "react/compiler-runtime"; // @enableEmitInstrumentForget
 function Bar(props) {
   "use forget";
   if (DEV && shouldInstrument)
-    useRenderCounter("Bar", "/codegen-instrument-forget-test.ts");
+    useRenderCounter("Bar", "C:\\codegen-instrument-forget-test.ts");
   const $ = _c(2);
   let t0;
   if ($[0] !== props.bar) {
@@ -49,7 +49,7 @@ function NoForget(props) {
 function Foo(props) {
   "use forget";
   if (DEV && shouldInstrument)
-    useRenderCounter("Foo", "/codegen-instrument-forget-test.ts");
+    useRenderCounter("Foo", "C:\\codegen-instrument-forget-test.ts");
   const $ = _c(2);
   let t0;
   if ($[0] !== props.bar) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/conflict-codegen-instrument-forget.expect.md

@@ -42,7 +42,7 @@ import { identity } from "shared-runtime";
 function Bar(props) {
   "use forget";
   if (DEV && _shouldInstrument3)
-    useRenderCounter("Bar", "/conflict-codegen-instrument-forget.ts");
+    useRenderCounter("Bar", "C:\\conflict-codegen-instrument-forget.ts");
   const $ = _c(4);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -78,7 +78,7 @@ function Bar(props) {
 function Foo(props) {
   "use forget";
   if (DEV && _shouldInstrument3)
-    useRenderCounter("Foo", "/conflict-codegen-instrument-forget.ts");
+    useRenderCounter("Foo", "C:\\conflict-codegen-instrument-forget.ts");
   const $ = _c(2);
   let t0;
   if ($[0] !== props.bar) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/constant-prop-across-objectmethod-def.expect.md

@@ -34,12 +34,13 @@ import { identity } from "shared-runtime";
 // inferred as a context variable.
 
 function Component() {
-  const obj = { method() {} };
+  const obj = { method: _temp };
 
   identity(obj);
 
   return 4;
 }
+function _temp() {}
 
 export const FIXTURE_ENTRYPOINT = {
   fn: Component,

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/constant-prop-to-object-method.expect.md

@@ -31,18 +31,17 @@ function Foo() {
   const $ = _c(1);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    const x = {
-      foo() {
-        return identity(1);
-      },
-    };
+    const x = { foo: _temp };
     t0 = x.foo();
     $[0] = t0;
   } else {
     t0 = $[0];
   }
   return t0;
 }
+function _temp() {
+  return identity(1);
+}
 
 export const FIXTURE_ENTRYPOINT = {
   fn: Foo,

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/context-variable-reassigned-objectmethod.expect.md

@@ -37,7 +37,7 @@ function Component(t0) {
   if ($[0] !== cond) {
     x = 2;
     const obj = {
-      method(cond_0) {
+      method: function (cond_0) {
         if (cond_0) {
           x = 4;
         }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/effect-derived-computations/derived-state-conditionally-in-effect.expect.md

@@ -56,8 +56,8 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [value]\n\nData Flow Tree:\n└── value (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":9,"column":6,"index":263},"end":{"line":9,"column":19,"index":276},"filename":"derived-state-conditionally-in-effect.ts","identifierName":"setLocalValue"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":16,"column":1,"index":397},"filename":"derived-state-conditionally-in-effect.ts"},"fnName":"Component","memoSlots":6,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
+{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [value]\n\nData Flow Tree:\n└── value (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":9,"column":6,"index":271},"end":{"line":9,"column":19,"index":284},"filename":"derived-state-conditionally-in-effect.ts","identifierName":"setLocalValue"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
+{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":129},"end":{"line":16,"column":1,"index":412},"filename":"derived-state-conditionally-in-effect.ts"},"fnName":"Component","memoSlots":6,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```
       
 ### Eval output