Remove ad hoc throw

Fatal errors (errors that are not captured by an error boundary) are
currently rethrown from directly inside the render phase's `catch`
block. This is a refactor hazard because the code in this branch has
to mirror the code that happens at the end of the function, when exiting
the render phase in the normal case.

This commit moves the throw to the end, using a new root exit status.

Author: acdlite

packages/react-reconciler/src/ReactFiberWorkLoop.js

@@ -200,13 +200,14 @@ const LegacyUnbatchedContext = /*       */ 0b001000;
 const RenderContext = /*                */ 0b010000;
 const CommitContext = /*                */ 0b100000;
 
-type RootExitStatus = 0 | 1 | 2 | 3 | 4 | 5;
+type RootExitStatus = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 const RootIncomplete = 0;
-const RootErrored = 1;
-const RootSuspended = 2;
-const RootSuspendedWithDelay = 3;
-const RootCompleted = 4;
-const RootLocked = 5;
+const RootFatalErrored = 1;
+const RootErrored = 2;
+const RootSuspended = 3;
+const RootSuspendedWithDelay = 4;
+const RootCompleted = 5;
+const RootLocked = 6;
 
 export type Thenable = {
   then(resolve: () => mixed, reject?: () => mixed): Thenable | void,
@@ -225,6 +226,8 @@ let workInProgress: Fiber | null = null;
 let renderExpirationTime: ExpirationTime = NoWork;
 // Whether to root completed, errored, suspended, etc.
 let workInProgressRootExitStatus: RootExitStatus = RootIncomplete;
+// A fatal error, if one is thrown
+let workInProgressRootFatalError: mixed = null;
 // Most recent event time among processed updates during this render.
 // This is conceptually a time stamp but expressed in terms of an ExpirationTime
 // because we deal mostly with expiration times in the hot path, so this avoids
@@ -685,28 +688,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           workLoopConcurrent();
           break;
         } catch (thrownValue) {
-          // Reset module-level state that was set during the render phase.
-          resetContextDependencies();
-          resetHooks();
-
-          if (workInProgress === null || workInProgress.return === null) {
-            // Expected to be working on a non-root fiber. This is a fatal error
-            // because there's no ancestor that can handle it; the root is
-            // supposed to capture all errors that weren't caught by an error
-            // boundary.
-            prepareFreshStack(root, expirationTime);
-            executionContext = prevExecutionContext;
-            markRootSuspendedAtTime(root, expirationTime);
-            ensureRootIsScheduled(root);
-            throw thrownValue;
-          }
-
-          workInProgress = handleError(
-            root,
-            workInProgress.return,
-            workInProgress,
-            thrownValue,
-          );
+          handleError(root, workInProgress, thrownValue);
         }
       } while (true);
       resetContextDependencies();
@@ -715,36 +697,42 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
       if (enableSchedulerTracing) {
         popInteractions(((prevInteractions: any): Set<Interaction>));
       }
-    }
-
-    if (workInProgress !== null) {
-      // There's still work left over. Exit without committing.
-      stopInterruptedWorkLoopTimer();
-    } else {
-      // We now have a consistent tree. The next step is either to commit it,
-      // or, if something suspended, wait to commit it after a timeout.
-      stopFinishedWorkLoopTimer();
 
-      const finishedWork: Fiber = ((root.finishedWork =
-        root.current.alternate): any);
-      root.finishedExpirationTime = expirationTime;
+      if (workInProgressRootExitStatus === RootFatalErrored) {
+        const fatalError = workInProgressRootFatalError;
+        stopInterruptedWorkLoopTimer();
+        prepareFreshStack(root, expirationTime);
+        markRootSuspendedAtTime(root, expirationTime);
+        ensureRootIsScheduled(root);
+        throw fatalError;
+      }
 
-      resolveLocksOnRoot(root, expirationTime);
+      if (workInProgress !== null) {
+        // There's still work left over. Exit without committing.
+        stopInterruptedWorkLoopTimer();
+      } else {
+        // We now have a consistent tree. The next step is either to commit it,
+        // or, if something suspended, wait to commit it after a timeout.
+        stopFinishedWorkLoopTimer();
+
+        const finishedWork: Fiber = ((root.finishedWork =
+          root.current.alternate): any);
+        root.finishedExpirationTime = expirationTime;
+        resolveLocksOnRoot(root, expirationTime);
+        finishConcurrentRender(
+          root,
+          finishedWork,
+          workInProgressRootExitStatus,
+          expirationTime,
+        );
+      }
 
-      finishConcurrentRender(
-        root,
-        finishedWork,
-        workInProgressRootExitStatus,
-        expirationTime,
-      );
-    }
-    // Before exiting, make sure there's a callback scheduled for the next
-    // pending level.
-    ensureRootIsScheduled(root);
-    if (root.callbackNode === originalCallbackNode) {
-      // The task node scheduled for this root is the same one that's
-      // currently executed. Need to return a continuation.
-      return performConcurrentWorkOnRoot.bind(null, root);
+      ensureRootIsScheduled(root);
+      if (root.callbackNode === originalCallbackNode) {
+        // The task node scheduled for this root is the same one that's
+        // currently executed. Need to return a continuation.
+        return performConcurrentWorkOnRoot.bind(null, root);
+      }
     }
   }
   return null;
@@ -760,8 +748,9 @@ function finishConcurrentRender(
   workInProgressRoot = null;
 
   switch (exitStatus) {
-    case RootIncomplete: {
-      invariant(false, 'Should have a work-in-progress.');
+    case RootIncomplete:
+    case RootFatalErrored: {
+      invariant(false, 'Root did not complete. This is a bug in React.');
     }
     // Flow knows about invariant, so it complains if I add a break
     // statement, but eslint doesn't know about invariant, so it complains
@@ -1042,28 +1031,7 @@ function performSyncWorkOnRoot(root) {
           workLoopSync();
           break;
         } catch (thrownValue) {
-          // Reset module-level state that was set during the render phase.
-          resetContextDependencies();
-          resetHooks();
-
-          if (workInProgress === null || workInProgress.return === null) {
-            // Expected to be working on a non-root fiber. This is a fatal error
-            // because there's no ancestor that can handle it; the root is
-            // supposed to capture all errors that weren't caught by an error
-            // boundary.
-            prepareFreshStack(root, expirationTime);
-            executionContext = prevExecutionContext;
-            markRootSuspendedAtTime(root, expirationTime);
-            ensureRootIsScheduled(root);
-            throw thrownValue;
-          }
-
-          workInProgress = handleError(
-            root,
-            workInProgress.return,
-            workInProgress,
-            thrownValue,
-          );
+          handleError(root, workInProgress, thrownValue);
         }
       } while (true);
       resetContextDependencies();
@@ -1072,46 +1040,63 @@ function performSyncWorkOnRoot(root) {
       if (enableSchedulerTracing) {
         popInteractions(((prevInteractions: any): Set<Interaction>));
       }
-    }
 
-    invariant(
-      workInProgressRootExitStatus !== RootIncomplete,
-      'Cannot commit an incomplete root. This error is likely caused by a ' +
-        'bug in React. Please file an issue.',
-    );
+      if (workInProgressRootExitStatus === RootFatalErrored) {
+        const fatalError = workInProgressRootFatalError;
+        stopInterruptedWorkLoopTimer();
+        prepareFreshStack(root, expirationTime);
+        markRootSuspendedAtTime(root, expirationTime);
+        ensureRootIsScheduled(root);
+        throw fatalError;
+      }
 
-    // We now have a consistent tree. The next step is either to commit it,
-    // or, if something suspended, wait to commit it after a timeout.
-    stopFinishedWorkLoopTimer();
+      if (workInProgress !== null) {
+        // This is a sync render, so we should have finished the whole tree.
+        invariant(
+          false,
+          'Cannot commit an incomplete root. This error is likely caused by a ' +
+            'bug in React. Please file an issue.',
+        );
+      } else {
+        // We now have a consistent tree. Because this is a sync render, we
+        // will commit it even if something suspended. The only exception is
+        // if the root is locked (using the unstable_createBatch API).
+        stopFinishedWorkLoopTimer();
+        root.finishedWork = (root.current.alternate: any);
+        root.finishedExpirationTime = expirationTime;
+        resolveLocksOnRoot(root, expirationTime);
+        finishSyncRender(root, workInProgressRootExitStatus, expirationTime);
+      }
 
-    root.finishedWork = ((root.current.alternate: any): Fiber);
-    root.finishedExpirationTime = expirationTime;
+      // Before exiting, make sure there's a callback scheduled for the next
+      // pending level.
+      ensureRootIsScheduled(root);
+    }
+  }
 
-    resolveLocksOnRoot(root, expirationTime);
-    if (workInProgressRootExitStatus === RootLocked) {
-      // This root has a lock that prevents it from committing. Exit. If we
-      // begin work on the root again, without any intervening updates, it
-      // will finish without doing additional work.
-      markRootSuspendedAtTime(root, expirationTime);
-    } else {
-      // Set this to null to indicate there's no in-progress render.
-      workInProgressRoot = null;
+  return null;
+}
 
-      if (__DEV__) {
-        if (
-          workInProgressRootExitStatus === RootSuspended ||
-          workInProgressRootExitStatus === RootSuspendedWithDelay
-        ) {
-          flushSuspensePriorityWarningInDEV();
-        }
+function finishSyncRender(root, exitStatus, expirationTime) {
+  if (exitStatus === RootLocked) {
+    // This root has a lock that prevents it from committing. Exit. If we
+    // begin work on the root again, without any intervening updates, it
+    // will finish without doing additional work.
+    markRootSuspendedAtTime(root, expirationTime);
+  } else {
+    // Set this to null to indicate there's no in-progress render.
+    workInProgressRoot = null;
+
+    if (__DEV__) {
+      if (
+        exitStatus === RootSuspended ||
+        exitStatus === RootSuspendedWithDelay
+      ) {
+        flushSuspensePriorityWarningInDEV();
       }
-      commitRoot(root);
     }
+    commitRoot(root);
   }
-  // Before exiting, make sure there's a callback scheduled for the next
-  // pending level.
-  ensureRootIsScheduled(root);
-  return null;
 }
 
 export function flushRoot(root: FiberRoot, expirationTime: ExpirationTime) {
@@ -1320,6 +1305,7 @@ function prepareFreshStack(root, expirationTime) {
   workInProgress = createWorkInProgress(root.current, null, expirationTime);
   renderExpirationTime = expirationTime;
   workInProgressRootExitStatus = RootIncomplete;
+  workInProgressRootFatalError = null;
   workInProgressRootLatestProcessedExpirationTime = Sync;
   workInProgressRootLatestSuspenseTimeout = Sync;
   workInProgressRootCanSuspendUsingConfig = null;
@@ -1336,7 +1322,21 @@ function prepareFreshStack(root, expirationTime) {
   }
 }
 
-function handleError(root, returnFiber, sourceFiber, thrownValue) {
+function handleError(root, sourceFiber, thrownValue) {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooks();
+
+  if (workInProgress === null || workInProgress.return === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return null;
+  }
+
   if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {
     // Record the time spent rendering before an error was thrown. This
     // avoids inaccurate Profiler durations in the case of a
@@ -1346,14 +1346,14 @@ function handleError(root, returnFiber, sourceFiber, thrownValue) {
 
   throwException(
     root,
-    returnFiber,
+    workInProgress.return,
     sourceFiber,
     thrownValue,
     renderExpirationTime,
   );
   // TODO: This is not wrapped in a try-catch, so if the complete phase
   // throws, we won't capture it.
-  return completeUnitOfWork(sourceFiber);
+  workInProgress = completeUnitOfWork(sourceFiber);
 }
 
 function pushDispatcher(root) {

scripts/error-codes/codes.json

@@ -342,5 +342,6 @@
   "341": "We just came from a parent so we must have had a parent. This is a bug in React.",
   "342": "A React component suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.",
   "343": "ReactDOMServer does not yet support scope components.",
-  "344": "Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."
+  "344": "Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.",
+  "345": "Root did not complete. This is a bug in React."
 }