[babel] Alias unstable_useMemoCache to useMemoCache

DevTools relies on built-in hook names at their call site to be unprefixed in 

order to correctly track them. This PR updates our Babel plugin to: 

- Check if there are any existing import declarations of `import { /* ... /* } 
from 'react';` 

- If true, we add the specifier `unstable_useMemoCache as useMemoCache` 

- Otherwise, we synthesize a new import declaration 

- In Codegen we now emit `useMemoCache(n)` rather than 
`React.unstable_useMemoCache(n)`

compiler/forget/src/Babel/BabelPlugin.ts

@@ -214,48 +214,76 @@ export default function ReactForgetBabelPlugin(
           opts: { ...pass.opts, ...options },
         });
 
-        // If there isn't already an import of * as React, insert it so React.useMemoCache doesn't
+        // If there isn't already an import of * as React, insert it so 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");
+            CallExpression(callExprPath) {
+              const callee = callExprPath.get("callee");
+              const args = callExprPath.get("arguments");
               if (
-                obj.isIdentifier() &&
-                obj.node.name === "React" &&
-                prop.isIdentifier() &&
-                prop.node.name === "unstable_useMemoCache"
+                callee.isIdentifier() &&
+                callee.node.name === "useMemoCache" &&
+                args.length === 1 &&
+                args[0].isNumericLiteral()
               ) {
                 didInsertUseMemoCache = true;
-                memberExprPath.stop();
               }
             },
             ImportDeclaration(importDeclPath) {
+              // Matches `import { /* ... */ } from 'react';`
+              // but not `import * as React from 'react';`
               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"
+                  .get("specifiers")
+                  .every((specifier) => specifier.isImportSpecifier())
               ) {
                 hasExistingReactImport = true;
-                importDeclPath.stop();
               }
             },
           });
-          if (didInsertUseMemoCache && !hasExistingReactImport) {
-            path.unshiftContainer(
-              "body",
-              t.importDeclaration(
-                [t.importNamespaceSpecifier(t.identifier("React"))],
-                t.stringLiteral("react")
-              )
-            );
+          // If Forget did successfully compile inject/update an import of
+          // `import {unstable_useMemoCache as useMemoCache} from 'react'` and rename
+          // `React.unstable_useMemoCache(n)` to `useMemoCache(n)`;
+          if (didInsertUseMemoCache) {
+            if (hasExistingReactImport) {
+              let didUpdateImport = false;
+              path.traverse({
+                ImportDeclaration(importDeclPath) {
+                  if (importDeclPath.get("source").node.value === "react") {
+                    importDeclPath.pushContainer(
+                      "specifiers",
+                      t.importSpecifier(
+                        t.identifier("useMemoCache"),
+                        t.identifier("unstable_useMemoCache")
+                      )
+                    );
+                    didUpdateImport = true;
+                  }
+                },
+              });
+              if (didUpdateImport === false) {
+                throw new Error(
+                  "Expected an ImportDeclaration of react in order to update ImportSpecifiers with useMemoCache"
+                );
+              }
+            } else {
+              path.unshiftContainer(
+                "body",
+                t.importDeclaration(
+                  [
+                    t.importSpecifier(
+                      t.identifier("useMemoCache"),
+                      t.identifier("unstable_useMemoCache")
+                    ),
+                  ],
+                  t.stringLiteral("react")
+                )
+              );
+            }
           }
           if (options.gating != null) {
             path.unshiftContainer(

compiler/forget/src/ReactiveScopes/CodegenReactiveFunction.ts

@@ -54,17 +54,14 @@ export function codegenReactiveFunction(
   }
   const cacheCount = cx.nextCacheIndex;
   if (cacheCount !== 0) {
+    // The import declaration for `useMemoCache` is inserted in the Babel plugin
     statements.unshift(
       t.variableDeclaration("const", [
         t.variableDeclarator(
           t.identifier("$"),
-          t.callExpression(
-            t.memberExpression(
-              t.identifier("React"),
-              t.identifier("unstable_useMemoCache")
-            ),
-            [t.numericLiteral(cacheCount)]
-          )
+          t.callExpression(t.identifier("useMemoCache"), [
+            t.numericLiteral(cacheCount),
+          ])
         ),
       ])
     );

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

@@ -23,13 +23,13 @@ function Component() {
 ## Code
 
 ```javascript
-import * as React from "react"; // Should print A, B, arg, original
+import { unstable_useMemoCache as useMemoCache } from "react"; // Should print A, B, arg, original
 function changeF(o) {
   o.f = () => console.log("new");
 }
 
 function Component() {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = () => console.log("original");

compiler/forget/src/__tests__/fixtures/compiler/_bug.global-jsx-tag-lowered-between-mutations.expect.md

@@ -23,9 +23,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   let t0;
   let t1;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {

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

@@ -19,9 +19,9 @@ function Component() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component() {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = {};

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

@@ -22,14 +22,14 @@ function Component() {
 ## Code
 
 ```javascript
-import * as React from "react"; // Should print A, arg, original
+import { unstable_useMemoCache as useMemoCache } from "react"; // Should print A, arg, original
 
 function changeF(o) {
   o.f = () => console.log("new");
 }
 
 function Component() {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = () => console.log("original");

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

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

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

@@ -17,9 +17,9 @@ function component() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component() {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let x;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     const z = [];

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

@@ -16,9 +16,9 @@ function component() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component() {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = [];

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

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

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

@@ -19,12 +19,12 @@ function AllocatingPrimitiveAsDepNested(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // bar(props.b) is an allocating expression that produces a primitive, which means
+import { unstable_useMemoCache as useMemoCache } 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
 function AllocatingPrimitiveAsDepNested(props) {
-  const $ = React.unstable_useMemoCache(9);
+  const $ = useMemoCache(9);
   const c_0 = $[0] !== props.b;
   const c_1 = $[1] !== props.a;
   let x;

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

@@ -16,12 +16,12 @@ function AllocatingPrimitiveAsDep(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // bar(props.b) is an allocating expression that produces a primitive, which means
+import { unstable_useMemoCache as useMemoCache } 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
 function AllocatingPrimitiveAsDep(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const t0 = bar(props).b + 1;
   const c_0 = $[0] !== t0;
   let t1;

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

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

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

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

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

@@ -17,12 +17,12 @@ function ArrayAtTest(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // arrayInstance.at should have the following effects:
+import { unstable_useMemoCache as useMemoCache } from "react"; // arrayInstance.at should have the following effects:
 //  - read on arg0
 //  - read on receiver
 //  - mutate on lvalue
 function ArrayAtTest(props) {
-  const $ = React.unstable_useMemoCache(9);
+  const $ = useMemoCache(9);
   const c_0 = $[0] !== props.x;
   let t0;
   if (c_0) {

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

@@ -18,10 +18,10 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // x's mutable range should extend to `mutate(y)`
+import { unstable_useMemoCache as useMemoCache } from "react"; // x's mutable range should extend to `mutate(y)`
 
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = {};

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

@@ -12,9 +12,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== props.foo;
   const c_1 = $[1] !== props.bar;
   let t0;

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

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

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

@@ -14,9 +14,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(7);
+  const $ = useMemoCache(7);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   let t0;

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

@@ -15,9 +15,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(11);
+  const $ = useMemoCache(11);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   let t0;

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

@@ -19,11 +19,11 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // arrayInstance.push should have the following effects:
+import { unstable_useMemoCache as useMemoCache } from "react"; // arrayInstance.push should have the following effects:
 //  - read on all args (rest parameter)
 //  - mutate on receiver
 function Component(props) {
-  const $ = React.unstable_useMemoCache(8);
+  const $ = useMemoCache(8);
   const c_0 = $[0] !== props.x;
   let t0;
   if (c_0) {

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

@@ -13,12 +13,12 @@ export default ErrorView;
 
 ```javascript
 import { isForgetEnabled_Fixtures } from "ReactForgetFeatureFlag";
-import * as React from "react"; // @gating
+import { unstable_useMemoCache as useMemoCache } from "react"; // @gating
 function ErrorView_uncompiled(error, _retry) {
   return <MessageBox error={error}></MessageBox>;
 }
 function ErrorView_forget(error, _retry) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== error;
   let t0;
   if (c_0) {

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

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

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

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

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

@@ -19,9 +19,9 @@ function useBar(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function useBar(props) {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let z;
   if (props.a) {
     if (props.b) {

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

@@ -14,9 +14,9 @@ function foo() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function foo() {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = [1];

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

@@ -14,9 +14,9 @@ function g() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function g() {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let x;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     x = { y: { z: 1 } };

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

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

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

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

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

@@ -2,18 +2,17 @@
 ## Input
 
 ```javascript
-import * as React from "react";
-import { useMemo } from "react";
+import { useState, useMemo } from "react";
 
 function Component(props) {
-  const [x] = React.useState(0);
+  const [x] = useState(0);
   const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
 
   return <div>{expensiveNumber}</div>;
 }
 
 function Component2(props) {
-  const [x] = React.useState(0);
+  const [x] = useState(0);
   const expensiveNumber = useMemo(() => calculateExpensiveNumber(x), [x]);
 
   return <div>{expensiveNumber}</div>;
@@ -24,49 +23,60 @@ function Component2(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
-import { useMemo } from "react";
+import {
+  useState,
+  useMemo,
+  unstable_useMemoCache as useMemoCache,
+} from "react";
 
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(4);
+  const [x] = useState(0);
+  const c_0 = $[0] !== x;
   let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    const [x] = React.useState(0);
+  if (c_0) {
     t0 = calculateExpensiveNumber(x);
-    $[0] = t0;
+    $[0] = x;
+    $[1] = t0;
   } else {
-    t0 = $[0];
+    t0 = $[1];
   }
-  const t17 = t0;
-  const expensiveNumber = t17;
+  const t16 = t0;
+  const expensiveNumber = t16;
+  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+  if (c_2) {
     t1 = <div>{expensiveNumber}</div>;
-    $[1] = t1;
+    $[2] = expensiveNumber;
+    $[3] = t1;
   } else {
-    t1 = $[1];
+    t1 = $[3];
   }
   return t1;
 }
 
 function Component2(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(4);
+  const [x] = useState(0);
+  const c_0 = $[0] !== x;
   let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    const [x] = React.useState(0);
+  if (c_0) {
     t0 = calculateExpensiveNumber(x);
-    $[0] = t0;
+    $[0] = x;
+    $[1] = t0;
   } else {
-    t0 = $[0];
+    t0 = $[1];
   }
-  const t17 = t0;
-  const expensiveNumber = t17;
+  const t16 = t0;
+  const expensiveNumber = t16;
+  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+  if (c_2) {
     t1 = <div>{expensiveNumber}</div>;
-    $[1] = t1;
+    $[2] = expensiveNumber;
+    $[3] = t1;
   } else {
-    t1 = $[1];
+    t1 = $[3];
   }
   return t1;
 }

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

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

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

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

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

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

@@ -13,9 +13,9 @@ function component(t) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const { a } = t;
   const c_0 = $[0] !== a;
   let t0;

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

@@ -13,9 +13,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let x;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     x = makeObject();

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

@@ -13,9 +13,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let x;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     x = makeObject();

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

@@ -12,9 +12,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   let t0;

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

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

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

@@ -18,11 +18,11 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function foo() {}
 
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   let a;
   let b;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {

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

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

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

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

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

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

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

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

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

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

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

@@ -19,9 +19,9 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== foo;
   const c_1 = $[1] !== bar;
   let x;

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

@@ -19,9 +19,9 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== foo;
   const c_1 = $[1] !== bar;
   let x;

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

@@ -19,9 +19,9 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== foo;
   const c_1 = $[1] !== bar;
   let y;

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

@@ -19,9 +19,9 @@ function component(foo, bar) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== foo;
   const c_1 = $[1] !== bar;
   let y;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -18,9 +18,9 @@ function component(a, b) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
-  const $ = React.unstable_useMemoCache(5);
+  const $ = useMemoCache(5);
   const c_0 = $[0] !== a;
   const c_1 = $[1] !== b;
   let x;

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

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

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

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

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

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

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

@@ -19,9 +19,9 @@ function bar(a, b) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a, b) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== a;
   const c_1 = $[1] !== b;
   let y;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -19,9 +19,9 @@ function component({ mutator }) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t27) {
-  const $ = React.unstable_useMemoCache(7);
+  const $ = useMemoCache(7);
   const { mutator } = t27;
   const c_0 = $[0] !== mutator;
   let t0;

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

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

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

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

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

@@ -16,9 +16,9 @@ function component(a) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = function () {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -16,9 +16,9 @@ function foo() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function foo() {
-  const $ = React.unstable_useMemoCache(1);
+  const $ = useMemoCache(1);
   let z;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     const x = { x: 0 };

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

@@ -34,9 +34,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(8);
+  const $ = useMemoCache(8);
   const items = props.items;
   const maxItems = props.maxItems;
   const c_0 = $[0] !== maxItems;

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

@@ -12,9 +12,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(4);
+  const $ = useMemoCache(4);
   const c_0 = $[0] !== props.method;
   const c_1 = $[1] !== props.a;
   const c_2 = $[2] !== props.b;

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

@@ -17,9 +17,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const a = foo();
 
   const t0 = a[props.a] + 1;

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

@@ -15,9 +15,9 @@ function component(a, b) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== a;
   const c_1 = $[1] !== b;
   let x;

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

@@ -13,9 +13,9 @@ function component() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component() {
-  const $ = React.unstable_useMemoCache(4);
+  const $ = useMemoCache(4);
   const [x, setX] = useState(0);
   const c_0 = $[0] !== setX;
   let t0;

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

@@ -17,12 +17,12 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react"; // To preserve the nullthrows behavior and reactive deps of this code,
+import { unstable_useMemoCache as useMemoCache } 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)
 
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== props.a;
   let x;
   if (c_0) {

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

@@ -23,12 +23,12 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 /**
  * props.b *does* influence `a`
  */
 function Component(props) {
-  const $ = React.unstable_useMemoCache(5);
+  const $ = useMemoCache(5);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   const c_2 = $[2] !== props.c;

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

@@ -61,12 +61,12 @@ function ComponentD(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 /**
  * props.b does *not* influence `a`
  */
 function ComponentA(props) {
-  const $ = React.unstable_useMemoCache(4);
+  const $ = useMemoCache(4);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   const c_2 = $[2] !== props.d;
@@ -93,7 +93,7 @@ function ComponentA(props) {
  * props.b *does* influence `a`
  */
 function ComponentB(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== props;
   let a;
   if (c_0) {
@@ -116,7 +116,7 @@ function ComponentB(props) {
  * props.b *does* influence `a`, but only in a way that is never observable
  */
 function ComponentC(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== props;
   let a;
   if (c_0) {
@@ -140,7 +140,7 @@ function ComponentC(props) {
  * props.b *does* influence `a`
  */
 function ComponentD(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== props;
   let a;
   if (c_0) {

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

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

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

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

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

@@ -18,11 +18,11 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Foo() {}
 
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   let a;
   let b;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {

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

@@ -13,9 +13,9 @@ function component() {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function component() {
-  const $ = React.unstable_useMemoCache(5);
+  const $ = useMemoCache(5);
   const [x, setX] = useState(0);
   const c_0 = $[0] !== setX;
   let t0;

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

@@ -14,9 +14,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   let x;

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

@@ -13,9 +13,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const c_0 = $[0] !== props.a;
   const c_1 = $[1] !== props.b;
   let x;

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

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

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

@@ -23,9 +23,9 @@ function foo(x, y, z) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(x, y, z) {
-  const $ = React.unstable_useMemoCache(3);
+  const $ = useMemoCache(3);
   const items = [z];
   items.push(x);
   const c_0 = $[0] !== x;

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

@@ -13,10 +13,10 @@ function component(a) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 let someGlobal = {};
 function component(a) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const c_0 = $[0] !== a;
   let t0;
   if (c_0) {

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

@@ -12,9 +12,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const [t0] = props.y;
   const c_0 = $[0] !== t0;
   let t1;

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

@@ -17,9 +17,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   let x = undefined;
   if (props.cond) {
     const [t0] = props.y;

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

@@ -26,9 +26,9 @@ function foo(a, b, c) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
-  const $ = React.unstable_useMemoCache(5);
+  const $ = useMemoCache(5);
 
   const [d, t47] = a;
   const [t49] = t47;

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

@@ -12,9 +12,9 @@ function Component(props) {
 ## Code
 
 ```javascript
-import * as React from "react";
+import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
-  const $ = React.unstable_useMemoCache(2);
+  const $ = useMemoCache(2);
   const { x: t0 } = props.y;
   const c_0 = $[0] !== t0;
   let t1;