[cache] Use WeakMap by default

Allows us to get rid of an indiretion in the Client implementation.

Author: eps1lon

packages/react-reconciler/src/ReactFiberCacheComponent.js

@@ -90,7 +90,7 @@ export function createCache(): Cache {
   }
   const cache: Cache = {
     controller: new AbortControllerLocal(),
-    data: new Map(),
+    data: new WeakMap(),
     refCount: 0,
   };
 

packages/react-reconciler/src/ReactInternalTypes.js

@@ -451,6 +451,9 @@ export type Dispatcher = {
   ) => [Awaited<S>, (P) => void, boolean],
 };
 
+/**
+ * resourceType is weakly held i.e. the underlying implementation must be a WeakMap.
+ */
 export interface AsyncCache {
   get(resourceType: Function): mixed;
   set(resourceType: Function, value: mixed): AsyncCache;

packages/react-server/src/ReactFlightServer.js

@@ -359,7 +359,7 @@ export type Request = {
   fatalError: mixed,
   destination: null | Destination,
   bundlerConfig: ClientManifest,
-  cache: Map<Function, mixed>,
+  cache: WeakMap<Function, mixed>,
   nextChunkId: number,
   pendingChunks: number,
   hints: Hints,
@@ -470,7 +470,7 @@ function RequestInstance(
   this.fatalError = null;
   this.destination = null;
   this.bundlerConfig = bundlerConfig;
-  this.cache = new Map();
+  this.cache = new WeakMap();
   this.nextChunkId = 0;
   this.pendingChunks = 0;
   this.hints = hints;
@@ -989,7 +989,7 @@ export function getHints(request: Request): Hints {
   return request.hints;
 }
 
-export function getCache(request: Request): Map<Function, mixed> {
+export function getCache(request: Request): WeakMap<Function, mixed> {
   return request.cache;
 }
 

packages/react-server/src/flight/ReactFlightAsyncDispatcher.js

@@ -23,12 +23,12 @@ import {resolveOwner} from './ReactFlightCurrentOwner';
 
 const previousAsyncDispatcher = ReactSharedInternals.A;
 
-function resolveCache(): Map<Function, mixed> {
+function resolveCache(): WeakMap<Function, mixed> {
   const request = resolveRequest();
   if (request) {
     return getCache(request);
   }
-  return new Map();
+  return new WeakMap();
 }
 
 function getActiveCache(): AsyncCache {

packages/react/src/ReactCacheImpl.js

@@ -39,10 +39,6 @@ type CacheNode<T> =
   | UnterminatedCacheNode<T>
   | ErroredCacheNode<T>;
 
-function createCacheRoot<T>(): WeakMap<Function | Object, CacheNode<T>> {
-  return new WeakMap();
-}
-
 function createCacheNode<T>(): CacheNode<T> {
   return {
     s: UNTERMINATED, // status, represents whether the cached computation returned a value or threw an error
@@ -61,19 +57,11 @@ export function cache<A: Iterable<mixed>, T>(fn: (...A) => T): (...A) => T {
       return fn.apply(null, arguments);
     }
     const activeCache = dispatcher.getActiveCache();
-    let fnMap: WeakMap<any, CacheNode<T>> | void = (activeCache.get(
-      createCacheRoot,
-    ): any);
-    if (fnMap === undefined) {
-      fnMap = createCacheRoot();
-      // TODO: Warn if undefined?
-      activeCache.set(createCacheRoot, fnMap);
-    }
-    const fnNode = fnMap.get(fn);
+    const fnNode: CacheNode<T> | void = (activeCache.get(fn): any);
     let cacheNode: CacheNode<T>;
     if (fnNode === undefined) {
       cacheNode = createCacheNode();
-      fnMap.set(fn, cacheNode);
+      activeCache.set(fn, cacheNode);
     } else {
       cacheNode = fnNode;
     }