Fix crash when GCing modules reachable via multiple paths

Summary:
Changelog:

* **[Fix]**: Fix incremental build crashing when garbage collecting modules reachable via multiple paths in the graph.

Under the GC algorithm implemented in D36403390 (9065257), the same white ( = marked for deletion) node may be reached multiple times during the "CollectRoots" phase - specifically, if it is the child of two or more white nodes. We had an overly strict null check that caused a crash in this case.

In the test case added to `traverseDependencies-test`, the node that can be reached multiple times is `/baz`:

```
                    ┌─────────────────────────┐
                    │                         ▼
┌─────────┐   / ┌──────┐     ┌──────┐     ┌──────┐
│ /bundle │ ┈/▷ │ /foo │ ──▶ │ /bar │ ──▶ │ /baz │
└─────────┘ /   └──────┘     └──────┘     └──────┘
                    ▲            │
                    └────────────┘
```

A real-world instance of this crash can be seen by launching the default React Native starter app (created with `npx react-native init MyApp`) and deleting the contents of `index.js`. This causes a crash when Metro attempts to collect the `node_modules/babel/runtime/helpers/interopRequireDefault.js` dependency multiple times.

Reviewed By: huntie

Differential Revision: D39416657

fbshipit-source-id: 084b3a0f6363ffc5f51f8cdabc1fc7e81616f4db

Author: motiz88

packages/metro/src/DeltaBundler/__tests__/traverseDependencies-test.js

@@ -2188,6 +2188,42 @@ describe('edge cases', () => {
     expect(mockTransform).toHaveBeenCalledWith('/bar', undefined);
     expect(mockTransform).toHaveBeenCalledWith('/foo', undefined);
   });
+
+  it('removing a cycle with multiple outgoing edges to the same module', async () => {
+    /*
+                      ┌─────────────────────────┐
+                      │                         ▼
+    ┌─────────┐     ┌──────┐     ┌──────┐     ┌──────┐
+    │ /bundle │ ──▶ │ /foo │ ──▶ │ /bar │ ──▶ │ /baz │
+    └─────────┘     └──────┘     └──────┘     └──────┘
+                      ▲            │
+                      └────────────┘
+    */
+    Actions.addDependency('/bar', '/foo');
+    Actions.addDependency('/bar', '/baz');
+    files.clear();
+
+    await initialTraverseDependencies(graph, options);
+
+    /*
+                      ┌─────────────────────────┐
+                      │                         ▼
+    ┌─────────┐   / ┌──────┐     ┌──────┐     ┌──────┐
+    │ /bundle │ ┈/▷ │ /foo │ ──▶ │ /bar │ ──▶ │ /baz │
+    └─────────┘ /   └──────┘     └──────┘     └──────┘
+                      ▲            │
+                      └────────────┘
+    */
+    Actions.removeDependency('/bundle', '/foo');
+
+    expect(
+      getPaths(await traverseDependencies([...files], graph, options)),
+    ).toEqual({
+      added: new Set(),
+      modified: new Set(['/bundle']),
+      deleted: new Set(['/foo', '/bar', '/baz']),
+    });
+  });
 });
 
 describe('require.context', () => {

packages/metro/src/DeltaBundler/graphOperations.js

@@ -812,10 +812,11 @@ function collectWhite<T>(module: Module<T>, graph: Graph<T>, delta: Delta) {
   ) {
     graph.privateState.gc.color.set(module.path, 'black');
     for (const dependency of module.dependencies.values()) {
-      const childModule = nullthrows(
-        graph.dependencies.get(dependency.absolutePath),
-      );
-      collectWhite(childModule, graph, delta);
+      const childModule = graph.dependencies.get(dependency.absolutePath);
+      // The child may already have been collected.
+      if (childModule) {
+        collectWhite(childModule, graph, delta);
+      }
     }
     freeModule(module, graph, delta);
   }