Re-throw root errors thrown in complete phase

React treats errors thrown at the root as a fatal because there's no
parent component that can capture it. (This is distinct from an
"uncaught error" that isn't wrapped in an error boundary, because in
that case we can fall back to deleting the whole tree -- not great, but
at least the error is contained to a single root, and React is left in a
consistent state.)

The only way it can happen is if the renderer's host config throws. It
turns out we had a test case for this when the error is thrown in the
begin phase, but not the complete phase.

This adds a test case for the complete phase and fixes a bug where React
would keep retrying the root because the `workInProgress` pointer was
not advanced to the next fiber. (Which in this case is `null`, since
it's the root.)

We could consider in the future trying to gracefully exit from certain
types of root errors without leaving React in an inconsistent state. For
now, I'm treating it like an internal invariant and immediately exiting.

Author: acdlite

packages/react-noop-renderer/src/createReactNoop.js

@@ -533,6 +533,13 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
           newChildren: Array<Instance | TextInstance>,
         ): void {
           container.pendingChildren = newChildren;
+          if (
+            newChildren.length === 1 &&
+            newChildren[0].text === 'Error when completing root'
+          ) {
+            // Trigger an error for testing purposes
+            throw Error('Error when completing root');
+          }
         },
 
         replaceContainerChildren(

packages/react-reconciler/src/ReactFiberWorkLoop.js

@@ -1285,6 +1285,7 @@ function handleError(root, thrownValue) {
         // boundary.
         workInProgressRootExitStatus = RootFatalErrored;
         workInProgressRootFatalError = thrownValue;
+        workInProgress = null;
         return null;
       }
 

packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js

@@ -1249,7 +1249,7 @@ describe('ReactIncrementalErrorHandling', () => {
     ]);
   });
 
-  it('recovers from uncaught reconciler errors', () => {
+  it('recovers from error at the root (begin phase)', () => {
     const InvalidType = undefined;
     expect(() =>
       ReactNoop.render(<InvalidType />),
@@ -1271,6 +1271,18 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(ReactNoop.getChildren()).toEqual([span('hi')]);
   });
 
+  if (global.__PERSISTENT__) {
+    it('recovers from error at the root (complete phase)', () => {
+      const root = ReactNoop.createRoot();
+      root.render('Error when completing root');
+      expect(Scheduler).toFlushAndThrow('Error when completing root');
+
+      const blockingRoot = ReactNoop.createBlockingRoot();
+      blockingRoot.render('Error when completing root');
+      expect(Scheduler).toFlushAndThrow('Error when completing root');
+    });
+  }
+
   it('unmounts components with uncaught errors', () => {
     const ops = [];
     let inst;