Add github_code/react__react from GitHub - direct commit (part 8)

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-keys.js

@@ -0,0 +1,36 @@
+// @validatePreserveExistingMemoizationGuarantees
+import {useMemo} from 'react';
+import {Stringify} from 'shared-runtime';
+
+// derived from https://github.com/facebook/react/issues/32261
+function Component({items}) {
+  const record = useMemo(
+    () =>
+      Object.fromEntries(
+        items.map(item => [item.id, ref => <Stringify ref={ref} {...item} />])
+      ),
+    [items]
+  );
+
+  // Without a declaration for Object.entries(), this would be assumed to mutate
+  // `record`, meaning existing memoization couldn't be preserved
+  return (
+    <div>
+      {Object.keys(record).map(id => (
+        <Stringify key={id} render={record[id]} />
+      ))}
+    </div>
+  );
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [
+    {
+      items: [
+        {id: '0', name: 'Hello'},
+        {id: '1', name: 'World!'},
+      ],
+    },
+  ],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-call-in-ternary-test.expect.md

@@ -0,0 +1,58 @@
+
+## Input
+
+```javascript
+import {
+  createHookWrapper,
+  identity,
+  CONST_STRING0,
+  CONST_STRING1,
+} from 'shared-runtime';
+
+function useHook({value}) {
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }.getValue()
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import {
+  createHookWrapper,
+  identity,
+  CONST_STRING0,
+  CONST_STRING1,
+} from "shared-runtime";
+
+function useHook(t0) {
+  const { value } = t0;
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }.getValue()
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":"global string 1","shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-call-in-ternary-test.js

@@ -0,0 +1,21 @@
+import {
+  createHookWrapper,
+  identity,
+  CONST_STRING0,
+  CONST_STRING1,
+} from 'shared-runtime';
+
+function useHook({value}) {
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }.getValue()
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-derived-in-ternary-consequent.expect.md

@@ -0,0 +1,59 @@
+
+## Input
+
+```javascript
+import {identity, createHookWrapper} from 'shared-runtime';
+
+function useHook({isCond, value}) {
+  return isCond
+    ? identity({
+        getValue() {
+          return value;
+        },
+      })
+    : 42;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{isCond: true, value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { identity, createHookWrapper } from "shared-runtime";
+
+function useHook(t0) {
+  const $ = _c(3);
+  const { isCond, value } = t0;
+  let t1;
+  if ($[0] !== isCond || $[1] !== value) {
+    t1 = isCond
+      ? identity({
+          getValue() {
+            return value;
+          },
+        })
+      : 42;
+    $[0] = isCond;
+    $[1] = value;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ isCond: true, value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getValue":{"kind":"Function","result":0}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-derived-in-ternary-consequent.js

@@ -0,0 +1,16 @@
+import {identity, createHookWrapper} from 'shared-runtime';
+
+function useHook({isCond, value}) {
+  return isCond
+    ? identity({
+        getValue() {
+          return value;
+        },
+      })
+    : 42;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{isCond: true, value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-in-ternary-consequent.expect.md

@@ -0,0 +1,59 @@
+
+## Input
+
+```javascript
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({isCond, value}) {
+  return isCond
+    ? {
+        getValue() {
+          return value;
+        },
+      }
+    : 42;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{isCond: true, value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper } from "shared-runtime";
+
+function useHook(t0) {
+  const $ = _c(3);
+  const { isCond, value } = t0;
+  let t1;
+  if ($[0] !== isCond || $[1] !== value) {
+    t1 = isCond
+      ? {
+          getValue() {
+            return value;
+          },
+        }
+      : 42;
+    $[0] = isCond;
+    $[1] = value;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ isCond: true, value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getValue":{"kind":"Function","result":0}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-in-ternary-consequent.js

@@ -0,0 +1,16 @@
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({isCond, value}) {
+  return isCond
+    ? {
+        getValue() {
+          return value;
+        },
+      }
+    : 42;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{isCond: true, value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-in-ternary-test.expect.md

@@ -0,0 +1,52 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, CONST_STRING0, CONST_STRING1} from 'shared-runtime';
+
+function useHook({value}) {
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import {
+  createHookWrapper,
+  CONST_STRING0,
+  CONST_STRING1,
+} from "shared-runtime";
+
+function useHook(t0) {
+  const { value } = t0;
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":"global string 0","shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-method-in-ternary-test.js

@@ -0,0 +1,16 @@
+import {createHookWrapper, CONST_STRING0, CONST_STRING1} from 'shared-runtime';
+
+function useHook({value}) {
+  return {
+    getValue() {
+      return identity(value);
+    },
+  }
+    ? CONST_STRING0
+    : CONST_STRING1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-spread-element.expect.md

@@ -0,0 +1,43 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  const x = {...props.foo};
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props.foo) {
+    t0 = { ...props.foo };
+    $[0] = props.foo;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const x = t0;
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: ["TodoAdd"],
+  isComponent: "TodoAdd",
+};
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-literal-spread-element.js

@@ -0,0 +1,10 @@
+function Component(props) {
+  const x = {...props.foo};
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-maybe-alias.expect.md

@@ -0,0 +1,63 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, setProperty} from 'shared-runtime';
+function useHook(props) {
+  const x = {
+    getX() {
+      return props;
+    },
+  };
+  const y = {
+    getY() {
+      return 'y';
+    },
+  };
+  return setProperty(x, y);
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper, setProperty } from "shared-runtime";
+function useHook(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props) {
+    const x = {
+      getX() {
+        return props;
+      },
+    };
+    const y = {
+      getY() {
+        return "y";
+      },
+    };
+    t0 = setProperty(x, y);
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getX":{"kind":"Function","result":{"value":0}},"wat0":{"getY":{"kind":"Function","result":"y"}}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-maybe-alias.js

@@ -0,0 +1,19 @@
+import {createHookWrapper, setProperty} from 'shared-runtime';
+function useHook(props) {
+  const x = {
+    getX() {
+      return props;
+    },
+  };
+  const y = {
+    getY() {
+      return 'y';
+    },
+  };
+  return setProperty(x, y);
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-3.expect.md

@@ -0,0 +1,59 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, mutate} from 'shared-runtime';
+
+function useHook(a) {
+  const x = {a};
+  let obj = {
+    method() {
+      mutate(x);
+      return x;
+    },
+  };
+  return obj.method();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{x: 1}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper, mutate } from "shared-runtime";
+
+function useHook(a) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== a) {
+    const x = { a };
+    const obj = {
+      method() {
+        mutate(x);
+        return x;
+      },
+    };
+    t0 = obj.method();
+    $[0] = a;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ x: 1 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"a":{"x":1},"wat0":"joe"},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-3.js

@@ -0,0 +1,17 @@
+import {createHookWrapper, mutate} from 'shared-runtime';
+
+function useHook(a) {
+  const x = {a};
+  let obj = {
+    method() {
+      mutate(x);
+      return x;
+    },
+  };
+  return obj.method();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{x: 1}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-aliased-mutate-after.expect.md

@@ -0,0 +1,57 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, mutate, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return value;
+    },
+  };
+  mutate(x);
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper, mutate, mutateAndReturn } from "shared-runtime";
+function useHook(t0) {
+  const $ = _c(2);
+  const { value } = t0;
+  let obj;
+  if ($[0] !== value) {
+    const x = mutateAndReturn({ value });
+    obj = {
+      getValue() {
+        return value;
+      },
+    };
+    mutate(x);
+    $[0] = value;
+    $[1] = obj;
+  } else {
+    obj = $[1];
+  }
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getValue":{"kind":"Function","result":0}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-aliased-mutate-after.js

@@ -0,0 +1,16 @@
+import {createHookWrapper, mutate, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return value;
+    },
+  };
+  mutate(x);
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-derived-value.expect.md

@@ -0,0 +1,64 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return x;
+    },
+  };
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper, mutateAndReturn } from "shared-runtime";
+function useHook(t0) {
+  const $ = _c(4);
+  const { value } = t0;
+  let t1;
+  if ($[0] !== value) {
+    t1 = mutateAndReturn({ value });
+    $[0] = value;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const x = t1;
+  let t2;
+  if ($[2] !== x) {
+    t2 = {
+      getValue() {
+        return x;
+      },
+    };
+    $[2] = x;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const obj = t2;
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getValue":{"kind":"Function","result":{"value":0,"wat0":"joe"}}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-derived-value.js

@@ -0,0 +1,15 @@
+import {createHookWrapper, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return x;
+    },
+  };
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-hook-dep.expect.md

@@ -0,0 +1,55 @@
+
+## Input
+
+```javascript
+import {createHookWrapper} from 'shared-runtime';
+import {useState} from 'react';
+function useFoo() {
+  const [state, _setState] = useState(false);
+  return {
+    func() {
+      return state;
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useFoo),
+  params: [{}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper } from "shared-runtime";
+import { useState } from "react";
+function useFoo() {
+  const $ = _c(2);
+  const [state] = useState(false);
+  let t0;
+  if ($[0] !== state) {
+    t0 = {
+      func() {
+        return state;
+      },
+    };
+    $[0] = state;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useFoo),
+  params: [{}],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"func":{"kind":"Function","result":false}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-hook-dep.js

@@ -0,0 +1,15 @@
+import {createHookWrapper} from 'shared-runtime';
+import {useState} from 'react';
+function useFoo() {
+  const [state, _setState] = useState(false);
+  return {
+    func() {
+      return state;
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useFoo),
+  params: [{}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-mutated-after.expect.md

@@ -0,0 +1,57 @@
+
+## Input
+
+```javascript
+import {createHookWrapper, mutate, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return x;
+    },
+  };
+  mutate(obj);
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper, mutate, mutateAndReturn } from "shared-runtime";
+function useHook(t0) {
+  const $ = _c(2);
+  const { value } = t0;
+  let obj;
+  if ($[0] !== value) {
+    const x = mutateAndReturn({ value });
+    obj = {
+      getValue() {
+        return x;
+      },
+    };
+    mutate(obj);
+    $[0] = value;
+    $[1] = obj;
+  } else {
+    obj = $[1];
+  }
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getValue":{"kind":"Function","result":{"value":0,"wat0":"joe"}},"wat0":"joe"},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand-mutated-after.js

@@ -0,0 +1,16 @@
+import {createHookWrapper, mutate, mutateAndReturn} from 'shared-runtime';
+function useHook({value}) {
+  const x = mutateAndReturn({value});
+  const obj = {
+    getValue() {
+      return x;
+    },
+  };
+  mutate(obj);
+  return obj;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand.expect.md

@@ -0,0 +1,50 @@
+
+## Input
+
+```javascript
+function Component() {
+  let obj = {
+    method() {
+      return 1;
+    },
+  };
+  return obj.method();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{x: 1}, {a: 2}, {b: 2}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component() {
+  const $ = _c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const obj = {
+      method() {
+        return 1;
+      },
+    };
+    t0 = obj.method();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ x: 1 }, { a: 2 }, { b: 2 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) 1

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-method-shorthand.js

@@ -0,0 +1,13 @@
+function Component() {
+  let obj = {
+    method() {
+      return 1;
+    },
+  };
+  return obj.method();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{x: 1}, {a: 2}, {b: 2}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-mutated-in-consequent-alternate-both-return.expect.md

@@ -0,0 +1,67 @@
+
+## Input
+
+```javascript
+import {makeObject_Primitives} from 'shared-runtime';
+
+function Component(props) {
+  const object = makeObject_Primitives();
+  if (props.cond) {
+    object.value = 1;
+    return object;
+  } else {
+    object.value = props.value;
+    return object;
+  }
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{cond: false, value: [0, 1, 2]}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { makeObject_Primitives } from "shared-runtime";
+
+function Component(props) {
+  const $ = _c(3);
+  let t0;
+  if ($[0] !== props.cond || $[1] !== props.value) {
+    t0 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const object = makeObject_Primitives();
+      if (props.cond) {
+        object.value = 1;
+        t0 = object;
+        break bb0;
+      } else {
+        object.value = props.value;
+        t0 = object;
+        break bb0;
+      }
+    }
+    $[0] = props.cond;
+    $[1] = props.value;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
+  }
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ cond: false, value: [0, 1, 2] }],
+};
+
+```
+      
+### Eval output
+(kind: ok) {"a":0,"b":"value1","c":true,"value":[0,1,2]}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-mutated-in-consequent-alternate-both-return.js

@@ -0,0 +1,17 @@
+import {makeObject_Primitives} from 'shared-runtime';
+
+function Component(props) {
+  const object = makeObject_Primitives();
+  if (props.cond) {
+    object.value = 1;
+    return object;
+  } else {
+    object.value = props.value;
+    return object;
+  }
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{cond: false, value: [0, 1, 2]}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-pattern-params.expect.md

@@ -0,0 +1,63 @@
+
+## Input
+
+```javascript
+function component({a, b}) {
+  let y = {a};
+  let z = {b};
+  return {y, z};
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: component,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};
+
+```
+
+## 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 = { a };
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const y = t1;
+  let t2;
+  if ($[2] !== b) {
+    t2 = { b };
+    $[2] = b;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const z = t2;
+  let t3;
+  if ($[4] !== y || $[5] !== z) {
+    t3 = { y, z };
+    $[4] = y;
+    $[5] = z;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: component,
+  params: ["TodoAdd"],
+  isComponent: "TodoAdd",
+};
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-pattern-params.js

@@ -0,0 +1,11 @@
+function component({a, b}) {
+  let y = {a};
+  let z = {b};
+  return {y, z};
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: component,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-properties.expect.md

@@ -0,0 +1,25 @@
+
+## Input
+
+```javascript
+function foo(a, b, c) {
+  const x = a.x;
+  const y = {...b.c.d};
+  y.z = c.d.e;
+  foo(a.b.c);
+  [a.b.c];
+}
+
+```
+
+## Code
+
+```javascript
+function foo(a, b, c) {
+  const y = { ...b.c.d };
+  y.z = c.d.e;
+  foo(a.b.c);
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-properties.js

@@ -0,0 +1,7 @@
+function foo(a, b, c) {
+  const x = a.x;
+  const y = {...b.c.d};
+  y.z = c.d.e;
+  foo(a.b.c);
+  [a.b.c];
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-1.expect.md

@@ -0,0 +1,67 @@
+
+## Input
+
+```javascript
+import {createHookWrapper} from 'shared-runtime';
+function useHook({a, b}) {
+  return {
+    x: function () {
+      return [a];
+    },
+    y() {
+      return [b];
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{a: 1, b: 2}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper } from "shared-runtime";
+function useHook(t0) {
+  const $ = _c(5);
+  const { a, b } = t0;
+  let t1;
+  if ($[0] !== a) {
+    t1 = function () {
+      return [a];
+    };
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== b || $[3] !== t1) {
+    t2 = {
+      x: t1,
+      y() {
+        return [b];
+      },
+    };
+    $[2] = b;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ a: 1, b: 2 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"x":{"kind":"Function","result":[1]},"y":{"kind":"Function","result":[2]}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-1.js

@@ -0,0 +1,16 @@
+import {createHookWrapper} from 'shared-runtime';
+function useHook({a, b}) {
+  return {
+    x: function () {
+      return [a];
+    },
+    y() {
+      return [b];
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{a: 1, b: 2}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md

@@ -0,0 +1,76 @@
+
+## Input
+
+```javascript
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({a, b, c}) {
+  return {
+    x: [a],
+    y() {
+      return [b];
+    },
+    z: {c},
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{a: 1, b: 2, c: 2}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { createHookWrapper } from "shared-runtime";
+
+function useHook(t0) {
+  const $ = _c(8);
+  const { a, b, c } = t0;
+  let t1;
+  if ($[0] !== a) {
+    t1 = [a];
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== b || $[3] !== c || $[4] !== t1) {
+    let t3;
+    if ($[6] !== c) {
+      t3 = { c };
+      $[6] = c;
+      $[7] = t3;
+    } else {
+      t3 = $[7];
+    }
+    t2 = {
+      x: t1,
+      y() {
+        return [b];
+      },
+      z: t3,
+    };
+    $[2] = b;
+    $[3] = c;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ a: 1, b: 2, c: 2 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"x":[1],"y":{"kind":"Function","result":[2]},"z":{"c":2}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-2.js

@@ -0,0 +1,16 @@
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({a, b, c}) {
+  return {
+    x: [a],
+    y() {
+      return [b];
+    },
+    z: {c},
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{a: 1, b: 2, c: 2}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-nested.expect.md

@@ -0,0 +1,72 @@
+
+## Input
+
+```javascript
+import {useState} from 'react';
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({value}) {
+  const [state] = useState(false);
+
+  return {
+    getX() {
+      return {
+        a: [],
+        getY() {
+          return value;
+        },
+        state,
+      };
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { useState } from "react";
+import { createHookWrapper } from "shared-runtime";
+
+function useHook(t0) {
+  const $ = _c(3);
+  const { value } = t0;
+  const [state] = useState(false);
+  let t1;
+  if ($[0] !== state || $[1] !== value) {
+    t1 = {
+      getX() {
+        return {
+          a: [],
+          getY() {
+            return value;
+          },
+          state,
+        };
+      },
+    };
+    $[0] = state;
+    $[1] = value;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{ value: 0 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"getX":{"kind":"Function","result":{"a":[],"getY":{"kind":"Function","result":0},"state":false}}},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-shorthand-method-nested.js

@@ -0,0 +1,23 @@
+import {useState} from 'react';
+import {createHookWrapper} from 'shared-runtime';
+
+function useHook({value}) {
+  const [state] = useState(false);
+
+  return {
+    getX() {
+      return {
+        a: [],
+        getY() {
+          return value;
+        },
+        state,
+      };
+    },
+  };
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: createHookWrapper(useHook),
+  params: [{value: 0}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-values-mutation.expect.md

@@ -0,0 +1,57 @@
+
+## Input
+
+```javascript
+import {makeObject_Primitives, Stringify} from 'shared-runtime';
+
+function Component(props) {
+  const object = {object: props.object};
+  const entries = Object.entries(object);
+  entries.map(([, value]) => {
+    value.updated = true;
+  });
+  return <Stringify entries={entries} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{object: {key: makeObject_Primitives()}}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { makeObject_Primitives, Stringify } from "shared-runtime";
+
+function Component(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props.object) {
+    const object = { object: props.object };
+    const entries = Object.entries(object);
+    entries.map(_temp);
+    t0 = <Stringify entries={entries} />;
+    $[0] = props.object;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+function _temp(t0) {
+  const [, value] = t0;
+  value.updated = true;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ object: { key: makeObject_Primitives() } }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"entries":[["object",{"key":{"a":0,"b":"value1","c":true},"updated":true}]]}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-values-mutation.js

@@ -0,0 +1,15 @@
+import {makeObject_Primitives, Stringify} from 'shared-runtime';
+
+function Component(props) {
+  const object = {object: props.object};
+  const entries = Object.entries(object);
+  entries.map(([, value]) => {
+    value.updated = true;
+  });
+  return <Stringify entries={entries} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{object: {key: makeObject_Primitives()}}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-values.expect.md

@@ -0,0 +1,103 @@
+
+## Input
+
+```javascript
+// @validatePreserveExistingMemoizationGuarantees
+import {useMemo} from 'react';
+import {Stringify} from 'shared-runtime';
+
+// derived from https://github.com/facebook/react/issues/32261
+function Component({items}) {
+  const record = useMemo(
+    () =>
+      Object.fromEntries(
+        items.map(item => [
+          item.id,
+          {id: item.id, render: ref => <Stringify ref={ref} {...item} />},
+        ])
+      ),
+    [items]
+  );
+
+  // Without a declaration for Object.entries(), this would be assumed to mutate
+  // `record`, meaning existing memoization couldn't be preserved
+  return (
+    <div>
+      {Object.values(record).map(({id, render}) => (
+        <Stringify key={id} render={render} />
+      ))}
+    </div>
+  );
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [
+    {
+      items: [
+        {id: '0', name: 'Hello'},
+        {id: '1', name: 'World!'},
+      ],
+    },
+  ],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @validatePreserveExistingMemoizationGuarantees
+import { useMemo } from "react";
+import { Stringify } from "shared-runtime";
+
+// derived from https://github.com/facebook/react/issues/32261
+function Component(t0) {
+  const $ = _c(4);
+  const { items } = t0;
+  let t1;
+  if ($[0] !== items) {
+    t1 = Object.fromEntries(items.map(_temp));
+    $[0] = items;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const record = t1;
+  let t2;
+  if ($[2] !== record) {
+    t2 = <div>{Object.values(record).map(_temp2)}</div>;
+    $[2] = record;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
+}
+function _temp2(t0) {
+  const { id, render } = t0;
+  return <Stringify key={id} render={render} />;
+}
+function _temp(item) {
+  return [
+    item.id,
+    { id: item.id, render: (ref) => <Stringify ref={ref} {...item} /> },
+  ];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [
+    {
+      items: [
+        { id: "0", name: "Hello" },
+        { id: "1", name: "World!" },
+      ],
+    },
+  ],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div><div>{"render":"[[ function params=1 ]]"}</div><div>{"render":"[[ function params=1 ]]"}</div></div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/object-values.js

@@ -0,0 +1,39 @@
+// @validatePreserveExistingMemoizationGuarantees
+import {useMemo} from 'react';
+import {Stringify} from 'shared-runtime';
+
+// derived from https://github.com/facebook/react/issues/32261
+function Component({items}) {
+  const record = useMemo(
+    () =>
+      Object.fromEntries(
+        items.map(item => [
+          item.id,
+          {id: item.id, render: ref => <Stringify ref={ref} {...item} />},
+        ])
+      ),
+    [items]
+  );
+
+  // Without a declaration for Object.entries(), this would be assumed to mutate
+  // `record`, meaning existing memoization couldn't be preserved
+  return (
+    <div>
+      {Object.values(record).map(({id, render}) => (
+        <Stringify key={id} render={render} />
+      ))}
+    </div>
+  );
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [
+    {
+      items: [
+        {id: '0', name: 'Hello'},
+        {id: '1', name: 'World!'},
+      ],
+    },
+  ],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chain-in-logical-expr.expect.md

@@ -0,0 +1,37 @@
+
+## Input
+
+```javascript
+import {useNoAlias} from 'shared-runtime';
+
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ?? {};
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+## Code
+
+```javascript
+import { useNoAlias } from "shared-runtime";
+
+function useFoo(props) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ?? {};
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{ value: null }],
+};
+
+```
+      
+### Eval output
+(kind: exception) Fixture not implemented

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chain-in-logical-expr.ts

@@ -0,0 +1,11 @@
+import {useNoAlias} from 'shared-runtime';
+
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ?? {};
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chain-in-ternary.expect.md

@@ -0,0 +1,37 @@
+
+## Input
+
+```javascript
+import {useNoAlias} from 'shared-runtime';
+
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ? {} : null;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+## Code
+
+```javascript
+import { useNoAlias } from "shared-runtime";
+
+function useFoo(props) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ? {} : null;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{ value: null }],
+};
+
+```
+      
+### Eval output
+(kind: exception) Fixture not implemented

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chain-in-ternary.ts

@@ -0,0 +1,11 @@
+import {useNoAlias} from 'shared-runtime';
+
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return useNoAlias(value?.x, value?.y) ? {} : null;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chained.expect.md

@@ -0,0 +1,29 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  return call?.(props.a)?.(props.b)?.(props.c);
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props) {
+    t0 = call?.(props.a)?.(props.b)?.(props.c);
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-chained.js

@@ -0,0 +1,3 @@
+function Component(props) {
+  return call?.(props.a)?.(props.b)?.(props.c);
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-logical.expect.md

@@ -0,0 +1,52 @@
+
+## Input
+
+```javascript
+import {useFragment} from 'shared-runtime';
+
+function Component(props) {
+  const item = useFragment(
+    graphql`
+      fragment F on T {
+        id
+      }
+    `,
+    props.item
+  );
+  return item.items?.map(item => renderItem(item)) ?? [];
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { useFragment } from "shared-runtime";
+
+function Component(props) {
+  const $ = _c(2);
+  const item = useFragment(
+    graphql`
+      fragment F on T {
+        id
+      }
+    `,
+    props.item,
+  );
+  let t0;
+  if ($[0] !== item.items) {
+    t0 = item.items?.map(_temp) ?? [];
+    $[0] = item.items;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+function _temp(item_0) {
+  return renderItem(item_0);
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-logical.js

@@ -0,0 +1,13 @@
+import {useFragment} from 'shared-runtime';
+
+function Component(props) {
+  const item = useFragment(
+    graphql`
+      fragment F on T {
+        id
+      }
+    `,
+    props.item
+  );
+  return item.items?.map(item => renderItem(item)) ?? [];
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/optional-call-simple.expect.md

@@ -0,0 +1,29 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  return foo?.(props);
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props) {
+    t0 = foo?.(props);
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+```
+