[babel] Inject React import if Forget compiled the function

Updates our Babel plugin to add an import to React if we succesfully compiled a 
function and cached one or more values. For now this logic is entirely in the 
Babel plugin itself, but long term we should move this into codegen and teach 
Forget to start the pipeline by lowering the whole Program node to an HIR (which 
would also allow us to understand imports and other module scope values being 
used). Right now it's not possible to add in codegen (without some ugly code) as 
a file containing multiple components would result in duplicate imports being 
generated

compiler/forget/src/Babel/BabelPlugin.ts

@@ -191,11 +191,55 @@ export default function ReactForgetBabelPlugin(
             opts: { ...pass.opts, ...options },
           });
 
-          if (options.gating != null && hasForgetCompiledCode) {
-            path.unshiftContainer(
-              "body",
-              buildImportForGatingModule(options.gating)
-            );
+          // If there isn't already an import of * as React, insert it so React.useMemoCache doesn't
+          // throw
+          if (hasForgetCompiledCode) {
+            let didInsertUseMemoCache = false;
+            let hasExistingReactImport = false;
+            path.traverse({
+              MemberExpression(memberExprPath) {
+                const obj = memberExprPath.get("object");
+                const prop = memberExprPath.get("property");
+                if (
+                  obj.isIdentifier() &&
+                  obj.node.name === "React" &&
+                  prop.isIdentifier() &&
+                  prop.node.name === "unstable_useMemoCache"
+                ) {
+                  didInsertUseMemoCache = true;
+                  memberExprPath.stop();
+                }
+              },
+              ImportDeclaration(importDeclPath) {
+                if (
+                  importDeclPath.get("source").node.value === "react" &&
+                  importDeclPath.get("specifiers").length === 1 &&
+                  importDeclPath
+                    .get("specifiers")[0]
+                    .isImportNamespaceSpecifier() &&
+                  importDeclPath.get("specifiers")[0].get("local").node.name ===
+                    "React"
+                ) {
+                  hasExistingReactImport = true;
+                  importDeclPath.stop();
+                }
+              },
+            });
+            if (didInsertUseMemoCache && !hasExistingReactImport) {
+              path.unshiftContainer(
+                "body",
+                t.importDeclaration(
+                  [t.importNamespaceSpecifier(t.identifier("React"))],
+                  t.stringLiteral("react")
+                )
+              );
+            }
+            if (options.gating != null) {
+              path.unshiftContainer(
+                "body",
+                buildImportForGatingModule(options.gating)
+              );
+            }
           }
         } catch (err) {
           if (options.logger && err) {

compiler/forget/src/__tests__/fixtures/compiler/_bug.computed-call-evaluation-order.expect.md

@@ -23,7 +23,7 @@ function Component() {
 ## Code
 
 ```javascript
-// Should print A, B, arg, original
+import * as React from "react"; // Should print A, B, arg, original
 function changeF(o) {
   o.f = () => console.log("new");
   return undefined;

compiler/forget/src/__tests__/fixtures/compiler/_bug.lambda-reassign-shadowed-primitive.expect.md

@@ -19,6 +19,7 @@ function Component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component() {
   const $ = React.unstable_useMemoCache(1);
   let t0;

compiler/forget/src/__tests__/fixtures/compiler/_bug.property-call-evaluation-order.expect.md

@@ -22,7 +22,7 @@ function Component() {
 ## Code
 
 ```javascript
-// Should print A, arg, original
+import * as React from "react"; // Should print A, arg, original
 
 function changeF(o) {
   o.f = () => console.log("new");

compiler/forget/src/__tests__/fixtures/compiler/alias-computed-load.expect.md

@@ -16,6 +16,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/alias-nested-member-path-mutate.expect.md

@@ -17,6 +17,7 @@ function component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component() {
   const $ = React.unstable_useMemoCache(1);
   let x;

compiler/forget/src/__tests__/fixtures/compiler/alias-nested-member-path.expect.md

@@ -16,6 +16,7 @@ function component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component() {
   const $ = React.unstable_useMemoCache(3);
   let t0;

compiler/forget/src/__tests__/fixtures/compiler/alias-while.expect.md

@@ -26,6 +26,7 @@ function mutate(x, y) {}
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(cond) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== cond;

compiler/forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md

@@ -19,7 +19,7 @@ function AllocatingPrimitiveAsDepNested(props) {
 ## Code
 
 ```javascript
-// bar(props.b) is an allocating expression that produces a primitive, which means
+import * as React from "react"; // bar(props.b) is an allocating expression that produces a primitive, which means
 // that Forget should memoize it.
 // Correctness:
 //   - y depends on either bar(props.b) or bar(props.b) + 1

compiler/forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep.expect.md

@@ -16,7 +16,7 @@ function AllocatingPrimitiveAsDep(props) {
 ## Code
 
 ```javascript
-// bar(props.b) is an allocating expression that produces a primitive, which means
+import * as React from "react"; // bar(props.b) is an allocating expression that produces a primitive, which means
 // that Forget should memoize it.
 // Correctness:
 //   - y depends on either bar(props.b) or bar(props.b) + 1

compiler/forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md

@@ -16,6 +16,7 @@ function foo(a, b, c) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(a, b, c) {
   const $ = React.unstable_useMemoCache(10);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/array-at-closure.expect.md

@@ -17,6 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(7);
   const c_0 = $[0] !== props.x;

compiler/forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md

@@ -17,7 +17,7 @@ function ArrayAtTest(props) {
 ## Code
 
 ```javascript
-// arrayInstance.at should have the following effects:
+import * as React from "react"; // arrayInstance.at should have the following effects:
 //  - read on arg0
 //  - read on receiver
 //  - mutate on lvalue

compiler/forget/src/__tests__/fixtures/compiler/array-at-mutate-after-capture.expect.md

@@ -18,7 +18,7 @@ function Component(props) {
 ## Code
 
 ```javascript
-// x's mutable range should extend to `mutate(y)`
+import * as React from "react"; // x's mutable range should extend to `mutate(y)`
 
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);

compiler/forget/src/__tests__/fixtures/compiler/array-expression-spread.expect.md

@@ -12,6 +12,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== props.foo;

compiler/forget/src/__tests__/fixtures/compiler/array-pattern-params.expect.md

@@ -13,6 +13,7 @@ function component([a, b]) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(t17) {
   const $ = React.unstable_useMemoCache(7);
   const [a, b] = t17;

compiler/forget/src/__tests__/fixtures/compiler/array-properties.expect.md

@@ -14,6 +14,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(7);
   const c_0 = $[0] !== props.a;

compiler/forget/src/__tests__/fixtures/compiler/array-property-call.expect.md

@@ -15,6 +15,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(11);
   const c_0 = $[0] !== props.a;

compiler/forget/src/__tests__/fixtures/compiler/array-push-effect.expect.md

@@ -19,7 +19,7 @@ function Component(props) {
 ## Code
 
 ```javascript
-// arrayInstance.push should have the following effects:
+import * as React from "react"; // arrayInstance.push should have the following effects:
 //  - read on all args (rest parameter)
 //  - mutate on receiver
 function Component(props) {

compiler/forget/src/__tests__/fixtures/compiler/arrow-function-expr-gating-test.expect.md

@@ -12,7 +12,8 @@ export default ErrorView;
 ## Code
 
 ```javascript
-import { isForgetEnabled_Fixtures } from "ReactForgetFeatureFlag"; // @gating
+import { isForgetEnabled_Fixtures } from "ReactForgetFeatureFlag";
+import * as React from "react"; // @gating
 function ErrorView_uncompiled(error, _retry) {
   return <MessageBox error={error}></MessageBox>;
 }

compiler/forget/src/__tests__/fixtures/compiler/assignment-expression-computed.expect.md

@@ -15,6 +15,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props.x;

compiler/forget/src/__tests__/fixtures/compiler/assignment-expression-nested-path.expect.md

@@ -14,6 +14,7 @@ function g(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function g(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props.c;

compiler/forget/src/__tests__/fixtures/compiler/assignment-in-nested-if.expect.md

@@ -19,6 +19,7 @@ function useBar(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function useBar(props) {
   const $ = React.unstable_useMemoCache(1);
   let z;

compiler/forget/src/__tests__/fixtures/compiler/assignment-variations-complex-lvalue-array.expect.md

@@ -14,6 +14,7 @@ function foo() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo() {
   const $ = React.unstable_useMemoCache(2);
   let t0;

compiler/forget/src/__tests__/fixtures/compiler/assignment-variations-complex-lvalue.expect.md

@@ -14,6 +14,7 @@ function g() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function g() {
   const $ = React.unstable_useMemoCache(1);
   let x;

compiler/forget/src/__tests__/fixtures/compiler/await-side-effecting-promise.expect.md

@@ -13,6 +13,7 @@ async function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 async function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props.id;

compiler/forget/src/__tests__/fixtures/compiler/await.expect.md

@@ -12,6 +12,7 @@ async function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 async function Component(props) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== props.id;

compiler/forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md

@@ -0,0 +1,75 @@
+
+## Input
+
+```javascript
+import * as React from "react";
+import { useMemo } from "react";
+
+function Component(props) {
+  const [x] = React.useState(0);
+  const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
+
+  return <div>{expensiveNumber}</div>;
+}
+
+function Component2(props) {
+  const [x] = React.useState(0);
+  const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
+
+  return <div>{expensiveNumber}</div>;
+}
+
+```
+
+## Code
+
+```javascript
+import * as React from "react";
+import { useMemo } from "react";
+
+function Component(props) {
+  const $ = React.unstable_useMemoCache(2);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const [x] = React.useState(0);
+    t0 = calculateExpensiveNumber(x);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const t17 = t0;
+  const expensiveNumber = t17;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <div>{expensiveNumber}</div>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+
+function Component2(props) {
+  const $ = React.unstable_useMemoCache(2);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const [x] = React.useState(0);
+    t0 = calculateExpensiveNumber(x);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const t17 = t0;
+  const expensiveNumber = t17;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <div>{expensiveNumber}</div>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+
+```
+      

compiler/forget/src/__tests__/fixtures/compiler/babel-existing-react-import.js

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { useMemo } from "react";
+
+function Component(props) {
+  const [x] = React.useState(0);
+  const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
+
+  return <div>{expensiveNumber}</div>;
+}
+
+function Component2(props) {
+  const [x] = React.useState(0);
+  const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
+
+  return <div>{expensiveNumber}</div>;
+}

compiler/forget/src/__tests__/fixtures/compiler/bug_object-pattern.expect.md

@@ -13,6 +13,7 @@ function component(t) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(t) {
   const $ = React.unstable_useMemoCache(2);
   const { a } = t;

compiler/forget/src/__tests__/fixtures/compiler/call-args-assignment.expect.md

@@ -13,6 +13,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(1);
   let x;

compiler/forget/src/__tests__/fixtures/compiler/call-args-destructuring-assignment.expect.md

@@ -13,6 +13,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(1);
   let x;

compiler/forget/src/__tests__/fixtures/compiler/call-spread.expect.md

@@ -12,6 +12,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== props.a;

compiler/forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md

@@ -17,6 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== props;

compiler/forget/src/__tests__/fixtures/compiler/call.expect.md

@@ -18,6 +18,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo() {
   return undefined;
 }

compiler/forget/src/__tests__/fixtures/compiler/capture-func-passed-to-jsx.expect.md

@@ -19,6 +19,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(9);
   const c_0 = $[0] !== b;

compiler/forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias.expect.md

@@ -19,6 +19,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capture-param-mutate.expect.md

@@ -45,6 +45,7 @@ function getNativeLogFunction(level) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function getNativeLogFunction(level) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== level;

compiler/forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-arrow-function-1.expect.md

@@ -15,6 +15,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2.expect.md

@@ -19,6 +19,7 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(foo, bar) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== foo;

compiler/forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2.expect.md

@@ -19,6 +19,7 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(foo, bar) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== foo;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr.expect.md

@@ -19,6 +19,7 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(foo, bar) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== foo;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate.expect.md

@@ -19,6 +19,7 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(foo, bar) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== foo;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate.expect.md

@@ -18,6 +18,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate.expect.md

@@ -18,6 +18,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-mutate-2.expect.md

@@ -18,6 +18,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(5);
   const c_0 = $[0] !== b;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-mutate-3.expect.md

@@ -17,6 +17,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(7);
   const c_0 = $[0] !== b;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-mutate-nested.expect.md

@@ -16,6 +16,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-mutate.expect.md

@@ -18,6 +18,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(5);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-1.expect.md

@@ -15,6 +15,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2.expect.md

@@ -17,6 +17,7 @@ function bar(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function bar(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3.expect.md

@@ -19,6 +19,7 @@ function bar(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function bar(a, b) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4.expect.md

@@ -17,6 +17,7 @@ function bar(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function bar(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load.expect.md

@@ -17,6 +17,7 @@ function bar(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function bar(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-capture-ref-before-rename.expect.md

@@ -22,6 +22,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(7);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-conditional-capture-mutate.expect.md

@@ -18,6 +18,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(5);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-decl.expect.md

@@ -16,6 +16,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-arguments.expect.md

@@ -18,6 +18,7 @@ function Foo(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Foo(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props.router.location;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-call.expect.md

@@ -19,6 +19,7 @@ function component({ mutator }) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(t27) {
   const $ = React.unstable_useMemoCache(7);
   const { mutator } = t27;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-renamed-ref.expect.md

@@ -18,6 +18,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-runs-inference.expect.md

@@ -13,6 +13,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-shadow-captured.expect.md

@@ -16,6 +16,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(1);
   let t0;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-skip-computed-path.expect.md

@@ -12,6 +12,7 @@ function StoreLandingUnseenGiftModalContainer(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function StoreLandingUnseenGiftModalContainer(a) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-function-within-block.expect.md

@@ -18,6 +18,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-member-expr.expect.md

@@ -15,6 +15,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-nested-member-call.expect.md

@@ -15,6 +15,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr-in-nested-func.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr.expect.md

@@ -15,6 +15,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-block.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-function.expect.md

@@ -17,6 +17,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/chained-assignment-expressions.expect.md

@@ -16,6 +16,7 @@ function foo() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo() {
   const $ = React.unstable_useMemoCache(1);
   let z;

compiler/forget/src/__tests__/fixtures/compiler/component.expect.md

@@ -34,6 +34,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(8);
   const items = props.items;

compiler/forget/src/__tests__/fixtures/compiler/computed-call-spread.expect.md

@@ -12,6 +12,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(4);
   const c_0 = $[0] !== props.method;

compiler/forget/src/__tests__/fixtures/compiler/computed-load-primitive-as-dependency.expect.md

@@ -17,6 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const a = foo();

compiler/forget/src/__tests__/fixtures/compiler/computed-store-alias.expect.md

@@ -15,6 +15,7 @@ function component(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component(a, b) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/concise-arrow-expr.expect.md

@@ -13,6 +13,7 @@ function component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component() {
   const $ = React.unstable_useMemoCache(4);
   const [x, setX] = useState(0);

compiler/forget/src/__tests__/fixtures/compiler/cond-deps-conditional-member-expr.expect.md

@@ -17,7 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
-// To preserve the nullthrows behavior and reactive deps of this code,
+import * as React from "react"; // To preserve the nullthrows behavior and reactive deps of this code,
 // Forget needs to add `props.a` as a dependency (since `props.a.b` is
 // a conditional dependency, i.e. gated behind control flow)
 

compiler/forget/src/__tests__/fixtures/compiler/conditional-break-labeled.expect.md

@@ -23,6 +23,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 /**
  * props.b *does* influence `a`
  */

compiler/forget/src/__tests__/fixtures/compiler/conditional-break.expect.md

@@ -61,6 +61,7 @@ function ComponentD(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 /**
  * props.b does *not* influence `a`
  */

compiler/forget/src/__tests__/fixtures/compiler/conditional-on-mutable.expect.md

@@ -34,6 +34,7 @@ function mayMutate() {}
 ## Code
 
 ```javascript
+import * as React from "react";
 function ComponentA(props) {
   const $ = React.unstable_useMemoCache(6);
   const c_0 = $[0] !== props;

compiler/forget/src/__tests__/fixtures/compiler/constant-computed.expect.md

@@ -15,6 +15,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props.foo;

compiler/forget/src/__tests__/fixtures/compiler/constructor.expect.md

@@ -18,6 +18,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Foo() {
   return undefined;
 }

compiler/forget/src/__tests__/fixtures/compiler/controlled-input.expect.md

@@ -13,6 +13,7 @@ function component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function component() {
   const $ = React.unstable_useMemoCache(5);
   const [x, setX] = useState(0);

compiler/forget/src/__tests__/fixtures/compiler/delete-computed-property.expect.md

@@ -14,6 +14,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== props.a;

compiler/forget/src/__tests__/fixtures/compiler/delete-property.expect.md

@@ -13,6 +13,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(3);
   const c_0 = $[0] !== props.a;

compiler/forget/src/__tests__/fixtures/compiler/dependencies-outputs.expect.md

@@ -22,6 +22,7 @@ function foo(a, b) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(a, b) {
   const $ = React.unstable_useMemoCache(5);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/dependencies.expect.md

@@ -23,6 +23,7 @@ function foo(x, y, z) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(x, y, z) {
   const $ = React.unstable_useMemoCache(3);
   const items = [z];

compiler/forget/src/__tests__/fixtures/compiler/destructure-capture-global.expect.md

@@ -13,6 +13,7 @@ function component(a) {
 ## Code
 
 ```javascript
+import * as React from "react";
 let someGlobal = {};
 function component(a) {
   const $ = React.unstable_useMemoCache(2);

compiler/forget/src/__tests__/fixtures/compiler/destructuring-array-default.expect.md

@@ -12,6 +12,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const [t0] = props.y;

compiler/forget/src/__tests__/fixtures/compiler/destructuring-assignment-array-default.expect.md

@@ -17,6 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   let x = undefined;

compiler/forget/src/__tests__/fixtures/compiler/destructuring-assignment.expect.md

@@ -26,6 +26,7 @@ function foo(a, b, c) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(a, b, c) {
   const $ = React.unstable_useMemoCache(5);
 

compiler/forget/src/__tests__/fixtures/compiler/destructuring-object-default.expect.md

@@ -12,6 +12,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const { x: t0 } = props.y;

compiler/forget/src/__tests__/fixtures/compiler/destructuring.expect.md

@@ -27,6 +27,7 @@ function foo(a, b, c) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function foo(a, b, c) {
   const $ = React.unstable_useMemoCache(18);
   const c_0 = $[0] !== a;

compiler/forget/src/__tests__/fixtures/compiler/do-while-compound-test.expect.md

@@ -17,6 +17,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props;

compiler/forget/src/__tests__/fixtures/compiler/do-while-conditional-break.expect.md

@@ -18,6 +18,7 @@ function Component(props) {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component(props) {
   const $ = React.unstable_useMemoCache(2);
   const c_0 = $[0] !== props;

compiler/forget/src/__tests__/fixtures/compiler/do-while-continue.expect.md

@@ -21,6 +21,7 @@ function Component() {
 ## Code
 
 ```javascript
+import * as React from "react";
 function Component() {
   const $ = React.unstable_useMemoCache(1);
   let ret;