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

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-recursive-call-within-lambda.js

@@ -0,0 +1,17 @@
+function Foo({}) {
+  const outer = val => {
+    const fact = x => {
+      if (x <= 0) {
+        return 1;
+      }
+      return x * fact(x - 1);
+    };
+    return fact(val);
+  };
+  return outer(3);
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{}],
+};

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

@@ -0,0 +1,57 @@
+
+## Input
+
+```javascript
+function Foo({value}: {value: number}) {
+  const factorial = (x: number) => {
+    if (x <= 1) {
+      return 1;
+    } else {
+      return x * factorial(x - 1);
+    }
+  };
+
+  return factorial(value);
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{value: 3}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Foo(t0) {
+  const $ = _c(2);
+  const { value } = t0;
+  let t1;
+  if ($[0] !== value) {
+    const factorial = (x) => {
+      if (x <= 1) {
+        return 1;
+      } else {
+        return x * factorial(x - 1);
+      }
+    };
+    t1 = factorial(value);
+    $[0] = value;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{ value: 3 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) 6

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-recursive-call.ts

@@ -0,0 +1,16 @@
+function Foo({value}: {value: number}) {
+  const factorial = (x: number) => {
+    if (x <= 1) {
+      return 1;
+    } else {
+      return x * factorial(x - 1);
+    }
+  };
+
+  return factorial(value);
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{value: 3}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-repro-variable-used-in-assignment.expect.md

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

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-repro-variable-used-in-assignment.js

@@ -0,0 +1,13 @@
+function get2() {
+  const callbk = () => {
+    const copy = x;
+    return copy;
+  };
+  const x = 2;
+  return callbk();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: get2,
+  params: [],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-setstate-captured-indirectly-jsx.expect.md

@@ -0,0 +1,73 @@
+
+## Input
+
+```javascript
+// @validatePreserveExistingMemoizationGuarantees
+function useFoo() {
+  const onClick = response => {
+    setState(DISABLED_FORM);
+  };
+
+  const [state, setState] = useState();
+  const handleLogout = useCallback(() => {
+    setState(DISABLED_FORM);
+  }, [setState]);
+  const getComponent = () => {
+    return <ColumnItem onPress={() => handleLogout()} />;
+  };
+
+  // this `getComponent` call should not be inferred as mutating setState
+  return [getComponent(), onClick]; // pass onClick to avoid dce
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @validatePreserveExistingMemoizationGuarantees
+function useFoo() {
+  const $ = _c(7);
+  const onClick = (response) => {
+    setState(DISABLED_FORM);
+  };
+
+  const [, t0] = useState();
+  const setState = t0;
+  let t1;
+  if ($[0] !== setState) {
+    t1 = () => {
+      setState(DISABLED_FORM);
+    };
+    $[0] = setState;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  setState;
+  const handleLogout = t1;
+  let t2;
+  if ($[2] !== handleLogout) {
+    const getComponent = () => <ColumnItem onPress={() => handleLogout()} />;
+    t2 = getComponent();
+    $[2] = handleLogout;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== onClick || $[5] !== t2) {
+    t3 = [t2, onClick];
+    $[4] = onClick;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
+}
+
+```
+      
+### Eval output
+(kind: exception) Fixture not implemented

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-setstate-captured-indirectly-jsx.js

@@ -0,0 +1,17 @@
+// @validatePreserveExistingMemoizationGuarantees
+function useFoo() {
+  const onClick = response => {
+    setState(DISABLED_FORM);
+  };
+
+  const [state, setState] = useState();
+  const handleLogout = useCallback(() => {
+    setState(DISABLED_FORM);
+  }, [setState]);
+  const getComponent = () => {
+    return <ColumnItem onPress={() => handleLogout()} />;
+  };
+
+  // this `getComponent` call should not be inferred as mutating setState
+  return [getComponent(), onClick]; // pass onClick to avoid dce
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-const-declaration.expect.md

@@ -0,0 +1,50 @@
+
+## Input
+
+```javascript
+function hoisting() {
+  const foo = () => {
+    return bar + baz;
+  };
+  const bar = 3;
+  const baz = 2;
+  return foo(); // OK: called outside of TDZ for bar/baz
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function hoisting() {
+  const $ = _c(1);
+  let foo;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    foo = () => bar + baz;
+
+    const bar = 3;
+    const baz = 2;
+    $[0] = foo;
+  } else {
+    foo = $[0];
+  }
+  return foo();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+      
+### Eval output
+(kind: ok) 5

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-const-declaration.js

@@ -0,0 +1,14 @@
+function hoisting() {
+  const foo = () => {
+    return bar + baz;
+  };
+  const bar = 3;
+  const baz = 2;
+  return foo(); // OK: called outside of TDZ for bar/baz
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-function-expression.expect.md

@@ -0,0 +1,54 @@
+
+## Input
+
+```javascript
+function hoisting() {
+  const foo = () => {
+    return bar();
+  };
+  const bar = () => {
+    return 1;
+  };
+
+  return foo(); // OK: bar's value is only accessed outside of its TDZ
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function hoisting() {
+  const $ = _c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const foo = () => bar();
+    const bar = _temp;
+    t0 = foo();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+function _temp() {
+  return 1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+      
+### Eval output
+(kind: ok) 1

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-function-expression.js

@@ -0,0 +1,16 @@
+function hoisting() {
+  const foo = () => {
+    return bar();
+  };
+  const bar = () => {
+    return 1;
+  };
+
+  return foo(); // OK: bar's value is only accessed outside of its TDZ
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-let-declaration.expect.md

@@ -0,0 +1,50 @@
+
+## Input
+
+```javascript
+function hoisting() {
+  let foo = () => {
+    return bar + baz;
+  };
+  let bar = 3;
+  let baz = 2;
+  return foo(); // OK: called outside of TDZ for bar/baz
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function hoisting() {
+  const $ = _c(1);
+  let foo;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    foo = () => bar + baz;
+
+    let bar = 3;
+    let baz = 2;
+    $[0] = foo;
+  } else {
+    foo = $[0];
+  }
+  return foo();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};
+
+```
+      
+### Eval output
+(kind: ok) 5

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-simple-let-declaration.js

@@ -0,0 +1,14 @@
+function hoisting() {
+  let foo = () => {
+    return bar + baz;
+  };
+  let bar = 3;
+  let baz = 2;
+  return foo(); // OK: called outside of TDZ for bar/baz
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: hoisting,
+  params: [],
+  isComponent: false,
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-skip-type-alias-declarations.expect.md

@@ -0,0 +1,51 @@
+
+## Input
+
+```javascript
+// @flow
+type Item = {id: string, name: string};
+
+function Component({items}: {items: Array<Item>}) {
+  const onClick = () => {
+    const mapped: Array<Item> = items.map(item => ({
+      id: item.id,
+      name: item.name.toUpperCase(),
+    }));
+    submit(mapped);
+  };
+  return <Button onClick={onClick} />;
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+type Item = { id: string, name: string };
+
+function Component(t0) {
+  const $ = _c(2);
+  const { items } = t0;
+  let t1;
+  if ($[0] !== items) {
+    const onClick = () => {
+      const mapped = items.map(_temp);
+      submit(mapped);
+    };
+    t1 = <Button onClick={onClick} />;
+    $[0] = items;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+function _temp(item) {
+  return { id: item.id, name: item.name.toUpperCase() };
+}
+
+```
+      
+### Eval output
+(kind: exception) Fixture not implemented

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-skip-type-alias-declarations.js

@@ -0,0 +1,13 @@
+// @flow
+type Item = {id: string, name: string};
+
+function Component({items}: {items: Array<Item>}) {
+  const onClick = () => {
+    const mapped: Array<Item> = items.map(item => ({
+      id: item.id,
+      name: item.name.toUpperCase(),
+    }));
+    submit(mapped);
+  };
+  return <Button onClick={onClick} />;
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-within-lambda.expect.md

@@ -0,0 +1,53 @@
+
+## Input
+
+```javascript
+function Component({}) {
+  const outer = () => {
+    const inner = () => {
+      return x;
+    };
+    const x = 3;
+    return inner();
+  };
+  return <div>{outer()}</div>;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(t0) {
+  const $ = _c(1);
+  const outer = _temp;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <div>{outer()}</div>;
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  return t1;
+}
+function _temp() {
+  const inner = () => x;
+  const x = 3;
+  return inner();
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>3</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hoisting-within-lambda.js

@@ -0,0 +1,15 @@
+function Component({}) {
+  const outer = () => {
+    const inner = () => {
+      return x;
+    };
+    const x = 3;
+    return inner();
+  };
+  return <div>{outer()}</div>;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-expr.expect.md

@@ -0,0 +1,49 @@
+
+## Input
+
+```javascript
+import {CONST_STRING0} from 'shared-runtime';
+
+function t(props) {
+  let x = [, CONST_STRING0, props];
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: [{a: 1, b: 2}],
+  isComponent: false,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { CONST_STRING0 } from "shared-runtime";
+
+function t(props) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props) {
+    t0 = [, CONST_STRING0, props];
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const x = t0;
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: [{ a: 1, b: 2 }],
+  isComponent: false,
+};
+
+```
+      
+### Eval output
+(kind: ok) [null,"global string 0",{"a":1,"b":2}]

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-expr.js

@@ -0,0 +1,12 @@
+import {CONST_STRING0} from 'shared-runtime';
+
+function t(props) {
+  let x = [, CONST_STRING0, props];
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: [{a: 1, b: 2}],
+  isComponent: false,
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-pattern-dce-2.expect.md

@@ -0,0 +1,33 @@
+
+## Input
+
+```javascript
+function t(props) {
+  let [foo, bar, ,] = props;
+  return foo;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};
+
+```
+
+## Code
+
+```javascript
+function t(props) {
+  const [foo] = props;
+  return foo;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: ["TodoAdd"],
+  isComponent: "TodoAdd",
+};
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-pattern-dce-2.js

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

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-pattern-dce.expect.md

@@ -0,0 +1,33 @@
+
+## Input
+
+```javascript
+function t(props) {
+  let [, foo, bar] = props;
+  return foo;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: ['TodoAdd'],
+  isComponent: 'TodoAdd',
+};
+
+```
+
+## Code
+
+```javascript
+function t(props) {
+  const [, foo] = props;
+  return foo;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: t,
+  params: ["TodoAdd"],
+  isComponent: "TodoAdd",
+};
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/holey-array-pattern-dce.js

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

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-call-freezes-captured-memberexpr.expect.md

@@ -0,0 +1,87 @@
+
+## Input
+
+```javascript
+import {useIdentity, Stringify, identity} from 'shared-runtime';
+
+function Foo({val1}) {
+  // `x={inner: val1}` should be able to be memoized
+  const x = {inner: val1};
+
+  // Any references to `x` after this hook call should be read-only
+  const cb = useIdentity(() => x.inner);
+
+  // With enableTransitivelyFreezeFunctionExpressions, it's invalid
+  // to write to `x` after it's been frozen.
+  // TODO: runtime validation for DX
+  const copy = identity(x);
+  return <Stringify copy={copy} cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{val1: 1}],
+  sequentialRenders: [{val1: 1}, {val1: 1}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { useIdentity, Stringify, identity } from "shared-runtime";
+
+function Foo(t0) {
+  const $ = _c(9);
+  const { val1 } = t0;
+  let t1;
+  if ($[0] !== val1) {
+    t1 = { inner: val1 };
+    $[0] = val1;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const x = t1;
+  let t2;
+  if ($[2] !== x.inner) {
+    t2 = () => x.inner;
+    $[2] = x.inner;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const cb = useIdentity(t2);
+  let t3;
+  if ($[4] !== x) {
+    t3 = identity(x);
+    $[4] = x;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const copy = t3;
+  let t4;
+  if ($[6] !== cb || $[7] !== copy) {
+    t4 = <Stringify copy={copy} cb={cb} shouldInvokeFns={true} />;
+    $[6] = cb;
+    $[7] = copy;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{ val1: 1 }],
+  sequentialRenders: [{ val1: 1 }, { val1: 1 }],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"copy":{"inner":1},"cb":{"kind":"Function","result":1},"shouldInvokeFns":true}</div>
+<div>{"copy":{"inner":1},"cb":{"kind":"Function","result":1},"shouldInvokeFns":true}</div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-call-freezes-captured-memberexpr.tsx

@@ -0,0 +1,21 @@
+import {useIdentity, Stringify, identity} from 'shared-runtime';
+
+function Foo({val1}) {
+  // `x={inner: val1}` should be able to be memoized
+  const x = {inner: val1};
+
+  // Any references to `x` after this hook call should be read-only
+  const cb = useIdentity(() => x.inner);
+
+  // With enableTransitivelyFreezeFunctionExpressions, it's invalid
+  // to write to `x` after it's been frozen.
+  // TODO: runtime validation for DX
+  const copy = identity(x);
+  return <Stringify copy={copy} cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [{val1: 1}],
+  sequentialRenders: [{val1: 1}, {val1: 1}],
+};

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

@@ -0,0 +1,58 @@
+
+## Input
+
+```javascript
+function useFreeze() {}
+function foo() {}
+
+function Component(props) {
+  const x = [];
+  const y = useFreeze(x);
+  foo(y, x);
+  return (
+    <Component>
+      {x}
+      {y}
+    </Component>
+  );
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function useFreeze() {}
+function foo() {}
+
+function Component(props) {
+  const $ = _c(3);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const x = t0;
+  const y = useFreeze(x);
+  foo(y, x);
+  let t1;
+  if ($[1] !== y) {
+    t1 = (
+      <Component>
+        {x}
+        {y}
+      </Component>
+    );
+    $[1] = y;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+```
+      

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

@@ -0,0 +1,14 @@
+function useFreeze() {}
+function foo() {}
+
+function Component(props) {
+  const x = [];
+  const y = useFreeze(x);
+  foo(y, x);
+  return (
+    <Component>
+      {x}
+      {y}
+    </Component>
+  );
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-declaration-basic.flow.expect.md

@@ -0,0 +1,42 @@
+
+## Input
+
+```javascript
+// @flow @compilationMode:"infer"
+export default hook useFoo(bar: number) {
+  return [bar];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [42],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+export default function useFoo(bar) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== bar) {
+    t0 = [bar];
+    $[0] = bar;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [42],
+};
+
+```
+      
+### Eval output
+(kind: ok) [42]

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-declaration-basic.flow.js

@@ -0,0 +1,9 @@
+// @flow @compilationMode:"infer"
+export default hook useFoo(bar: number) {
+  return [bar];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [42],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-inside-logical-expression.expect.md

@@ -0,0 +1,37 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  const user =
+    useFragment(
+      graphql`
+        fragment F on T {
+          id
+        }
+      `,
+      props.user
+    ) ?? {};
+  return user.name;
+}
+
+```
+
+## Code
+
+```javascript
+function Component(props) {
+  const user =
+    useFragment(
+      graphql`
+        fragment F on T {
+          id
+        }
+      `,
+      props.user,
+    ) ?? {};
+  return user.name;
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-inside-logical-expression.js

@@ -0,0 +1,12 @@
+function Component(props) {
+  const user =
+    useFragment(
+      graphql`
+        fragment F on T {
+          id
+        }
+      `,
+      props.user
+    ) ?? {};
+  return user.name;
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-noAlias.expect.md

@@ -0,0 +1,64 @@
+
+## Input
+
+```javascript
+import {useNoAlias} from 'shared-runtime';
+
+function Component(props) {
+  const item = {a: props.a};
+  const x = useNoAlias(item, () => {
+    console.log(props);
+  }, [props.a]);
+  return [x, item];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: {id: 42}}],
+  isComponent: true,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { useNoAlias } from "shared-runtime";
+
+function Component(props) {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== props.a) {
+    t0 = { a: props.a };
+    $[0] = props.a;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const item = t0;
+  const x = useNoAlias(item, () => {
+    console.log(props);
+  }, [props.a]);
+  let t1;
+  if ($[2] !== item || $[3] !== x) {
+    t1 = [x, item];
+    $[2] = item;
+    $[3] = x;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ a: { id: 42 } }],
+  isComponent: true,
+};
+
+```
+      
+### Eval output
+(kind: ok) [{},{"a":{"id":42}}]

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-noAlias.js

@@ -0,0 +1,15 @@
+import {useNoAlias} from 'shared-runtime';
+
+function Component(props) {
+  const item = {a: props.a};
+  const x = useNoAlias(item, () => {
+    console.log(props);
+  }, [props.a]);
+  return [x, item];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{a: {id: 42}}],
+  isComponent: true,
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-property-load-local.expect.md

@@ -0,0 +1,40 @@
+
+## Input
+
+```javascript
+function useFoo() {}
+
+function Foo() {
+  let name = useFoo.name;
+  console.log(name);
+  return name;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};
+
+```
+
+## Code
+
+```javascript
+function useFoo() {}
+
+function Foo() {
+  const name = useFoo.name;
+  console.log(name);
+  return name;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};
+
+```
+      
+### Eval output
+(kind: ok) "useFoo"
+logs: ['useFoo']

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-property-load-local.js

@@ -0,0 +1,12 @@
+function useFoo() {}
+
+function Foo() {
+  let name = useFoo.name;
+  console.log(name);
+  return name;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-ref-callback.expect.md

@@ -0,0 +1,54 @@
+
+## Input
+
+```javascript
+import {useEffect, useRef} from 'react';
+
+function Component(props) {
+  const ref = useRef();
+  useFoo(() => {
+    ref.current = 42;
+  });
+}
+
+function useFoo(x) {}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { useEffect, useRef } from "react";
+
+function Component(props) {
+  const $ = _c(1);
+  const ref = useRef();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = () => {
+      ref.current = 42;
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  useFoo(t0);
+}
+
+function useFoo(x) {}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};
+
+```
+      
+### Eval output
+(kind: ok) 

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hook-ref-callback.js

@@ -0,0 +1,15 @@
+import {useEffect, useRef} from 'react';
+
+function Component(props) {
+  const ref = useRef();
+  useFoo(() => {
+    ref.current = 42;
+  });
+}
+
+function useFoo(x) {}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-freeze-arguments.expect.md

@@ -0,0 +1,42 @@
+
+## Input
+
+```javascript
+function Component() {
+  const a = [];
+  useFreeze(a); // should freeze
+  useFreeze(a); // should be readonly
+  call(a); // should be readonly
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}
+
+```
+
+## 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")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const a = t0;
+  useFreeze(a);
+  useFreeze(a);
+  call(a);
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-freeze-arguments.js

@@ -0,0 +1,10 @@
+function Component() {
+  const a = [];
+  useFreeze(a); // should freeze
+  useFreeze(a); // should be readonly
+  call(a); // should be readonly
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-freeze-possibly-mutable-arguments.expect.md

@@ -0,0 +1,57 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  const cond = props.cond;
+  const x = props.x;
+  let a;
+  if (cond) {
+    a = x;
+  } else {
+    a = [];
+  }
+  useFreeze(a); // should freeze, value *may* be mutable
+  useFreeze(a); // should be readonly
+  call(a); // should be readonly
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+function Component(props) {
+  const $ = _c(1);
+  const cond = props.cond;
+  const x = props.x;
+  let a;
+  if (cond) {
+    a = x;
+  } else {
+    let t0;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t0 = [];
+      $[0] = t0;
+    } else {
+      t0 = $[0];
+    }
+    a = t0;
+  }
+
+  useFreeze(a);
+  useFreeze(a);
+  call(a);
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-freeze-possibly-mutable-arguments.js

@@ -0,0 +1,17 @@
+function Component(props) {
+  const cond = props.cond;
+  const x = props.x;
+  let a;
+  if (cond) {
+    a = x;
+  } else {
+    a = [];
+  }
+  useFreeze(a); // should freeze, value *may* be mutable
+  useFreeze(a); // should be readonly
+  call(a); // should be readonly
+  return a;
+}
+
+function useFreeze(x) {}
+function call(x) {}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-with-React-namespace.expect.md

@@ -0,0 +1,33 @@
+
+## Input
+
+```javascript
+function Component() {
+  const [x, setX] = React.useState(1);
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};
+
+```
+
+## Code
+
+```javascript
+function Component() {
+  const [x] = React.useState(1);
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};
+
+```
+      
+### Eval output
+(kind: ok) 1

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-with-React-namespace.js

@@ -0,0 +1,9 @@
+function Component() {
+  const [x, setX] = React.useState(1);
+  return x;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-method-no-outlining-wildcard.expect.md

@@ -0,0 +1,113 @@
+
+## Input
+
+```javascript
+// @customMacros:"idx.*.b"
+
+function Component(props) {
+  // outlined
+  const groupName1 = idx(props, _ => _.group.label);
+  // outlined
+  const groupName2 = idx.a(props, _ => _.group.label);
+  // not outlined
+  const groupName3 = idx.a.b(props, _ => _.group.label);
+  // not outlined
+  const groupName4 = idx.hello_world.b(props, _ => _.group.label);
+  // outlined
+  const groupName5 = idx.hello_world.b.c(props, _ => _.group.label);
+  return (
+    <div>
+      {groupName1}
+      {groupName2}
+      {groupName3}
+      {groupName4}
+      {groupName5}
+    </div>
+  );
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @customMacros:"idx.*.b"
+
+function Component(props) {
+  const $ = _c(16);
+  let t0;
+  if ($[0] !== props) {
+    t0 = idx(props, (_) => _.group.label);
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const groupName1 = t0;
+  let t1;
+  if ($[2] !== props) {
+    t1 = idx.a(props, (__0) => __0.group.label);
+    $[2] = props;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const groupName2 = t1;
+  let t2;
+  if ($[4] !== props) {
+    t2 = idx.a.b(props, (__1) => __1.group.label);
+    $[4] = props;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const groupName3 = t2;
+  let t3;
+  if ($[6] !== props) {
+    t3 = idx.hello_world.b(props, (__2) => __2.group.label);
+    $[6] = props;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const groupName4 = t3;
+  let t4;
+  if ($[8] !== props) {
+    t4 = idx.hello_world.b.c(props, (__3) => __3.group.label);
+    $[8] = props;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  const groupName5 = t4;
+  let t5;
+  if (
+    $[10] !== groupName1 ||
+    $[11] !== groupName2 ||
+    $[12] !== groupName3 ||
+    $[13] !== groupName4 ||
+    $[14] !== groupName5
+  ) {
+    t5 = (
+      <div>
+        {groupName1}
+        {groupName2}
+        {groupName3}
+        {groupName4}
+        {groupName5}
+      </div>
+    );
+    $[10] = groupName1;
+    $[11] = groupName2;
+    $[12] = groupName3;
+    $[13] = groupName4;
+    $[14] = groupName5;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  return t5;
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-method-no-outlining-wildcard.js

@@ -0,0 +1,23 @@
+// @customMacros:"idx.*.b"
+
+function Component(props) {
+  // outlined
+  const groupName1 = idx(props, _ => _.group.label);
+  // outlined
+  const groupName2 = idx.a(props, _ => _.group.label);
+  // not outlined
+  const groupName3 = idx.a.b(props, _ => _.group.label);
+  // not outlined
+  const groupName4 = idx.hello_world.b(props, _ => _.group.label);
+  // outlined
+  const groupName5 = idx.hello_world.b.c(props, _ => _.group.label);
+  return (
+    <div>
+      {groupName1}
+      {groupName2}
+      {groupName3}
+      {groupName4}
+      {groupName5}
+    </div>
+  );
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-method-no-outlining.expect.md

@@ -0,0 +1,79 @@
+
+## Input
+
+```javascript
+// @customMacros:"idx.a"
+
+function Component(props) {
+  // outlined
+  const groupName1 = idx(props, _ => _.group.label);
+  // not outlined
+  const groupName2 = idx.a(props, _ => _.group.label);
+  // outlined
+  const groupName3 = idx.a.b(props, _ => _.group.label);
+  return (
+    <div>
+      {groupName1}
+      {groupName2}
+      {groupName3}
+    </div>
+  );
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @customMacros:"idx.a"
+
+function Component(props) {
+  const $ = _c(10);
+  let t0;
+  if ($[0] !== props) {
+    t0 = idx(props, (_) => _.group.label);
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const groupName1 = t0;
+  let t1;
+  if ($[2] !== props) {
+    t1 = idx.a(props, (__0) => __0.group.label);
+    $[2] = props;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const groupName2 = t1;
+  let t2;
+  if ($[4] !== props) {
+    t2 = idx.a.b(props, (__1) => __1.group.label);
+    $[4] = props;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const groupName3 = t2;
+  let t3;
+  if ($[6] !== groupName1 || $[7] !== groupName2 || $[8] !== groupName3) {
+    t3 = (
+      <div>
+        {groupName1}
+        {groupName2}
+        {groupName3}
+      </div>
+    );
+    $[6] = groupName1;
+    $[7] = groupName2;
+    $[8] = groupName3;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  return t3;
+}
+
+```
+      

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-method-no-outlining.js

@@ -0,0 +1,17 @@
+// @customMacros:"idx.a"
+
+function Component(props) {
+  // outlined
+  const groupName1 = idx(props, _ => _.group.label);
+  // not outlined
+  const groupName2 = idx.a(props, _ => _.group.label);
+  // outlined
+  const groupName3 = idx.a.b(props, _ => _.group.label);
+  return (
+    <div>
+      {groupName1}
+      {groupName2}
+      {groupName3}
+    </div>
+  );
+}

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-no-outlining.expect.md

@@ -0,0 +1,62 @@
+
+## Input
+
+```javascript
+// @customMacros:"idx"
+import idx from 'idx';
+
+function Component(props) {
+  // the lambda should not be outlined
+  const groupName = idx(props, _ => _.group.label);
+  return <div>{groupName}</div>;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @customMacros:"idx"
+
+function Component(props) {
+  const $ = _c(4);
+  let t0;
+  if ($[0] !== props) {
+    var _ref;
+    t0 =
+      (_ref = props) != null
+        ? (_ref = _ref.group) != null
+          ? _ref.label
+          : _ref
+        : _ref;
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const groupName = t0;
+  let t1;
+  if ($[2] !== groupName) {
+    t1 = <div>{groupName}</div>;
+    $[2] = groupName;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div></div>

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/idx-no-outlining.js

@@ -0,0 +1,13 @@
+// @customMacros:"idx"
+import idx from 'idx';
+
+function Component(props) {
+  // the lambda should not be outlined
+  const groupName = idx(props, _ => _.group.label);
+  return <div>{groupName}</div>;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};

github_code/react__react/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ignore-inner-interface-types.expect.md

@@ -0,0 +1,35 @@
+
+## Input
+
+```javascript
+function Foo() {
+  type X = number;
+  interface Bar {
+    baz: number;
+  }
+  return 0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};
+
+```
+
+## Code
+
+```javascript
+function Foo() {
+  return 0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};
+
+```
+      
+### Eval output
+(kind: ok) 0