[Fizz][Static] use halt rather than error when aborting a Fizz preren…

…der when enableHalt is on

enableHalt is a new feature flag to augment the abort behavior of prerenders. Initially landed for Flight this commit implements halting for Fizz. Halting is analagous to postponing in Fizz however it can only be done at the render level rather than marking individual trees as postponed from within.

packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js

@@ -7729,7 +7729,11 @@ describe('ReactDOMFizzServer', () => {
 
     expect(prerendered.postponed).toBe(null);
     expect(errors).toEqual([]);
-    expect(postpones).toEqual(['manufactured', 'manufactured']);
+    if (gate(flags => flags.enableHalt)) {
+      expect(postpones).toEqual([]);
+    } else {
+      expect(postpones).toEqual(['manufactured', 'manufactured']);
+    }
 
     await act(() => {
       prerendered.prelude.pipe(writable);

packages/react-server/src/ReactFizzServer.js

@@ -157,6 +157,7 @@ import {
   enableSuspenseAvoidThisFallbackFizz,
   enableCache,
   enablePostpone,
+  enableHalt,
   enableRenderableContext,
   enableRefAsProp,
   disableDefaultPropsExceptForClasses,
@@ -3789,14 +3790,23 @@ function abortTask(task: Task, request: Request, error: mixed): void {
       if (replay === null) {
         // We didn't complete the root so we have nothing to show. We can close
         // the request;
+        const trackedPostpones = request.trackedPostpones;
+        if (enableHalt) {
+          if (trackedPostpones !== null && segment !== null) {
+            // We are prerendering. We don't want to fatal when the shell postpones
+            // or halts we just need to mark it as postponed.
+            trackPostpone(request, trackedPostpones, task, segment);
+            finishedTask(request, null, segment);
+            return;
+          }
+        }
         if (
           enablePostpone &&
           typeof error === 'object' &&
           error !== null &&
           error.$$typeof === REACT_POSTPONE_TYPE
         ) {
           const postponeInstance: Postpone = (error: any);
-          const trackedPostpones = request.trackedPostpones;
 
           if (trackedPostpones !== null && segment !== null) {
             // We are prerendering. We don't want to fatal when the shell postpones
@@ -3821,6 +3831,8 @@ function abortTask(task: Task, request: Request, error: mixed): void {
         // If the shell aborts during a replay, that's not a fatal error. Instead
         // we should be able to recover by client rendering all the root boundaries in
         // the ReplaySet.
+        // We don't have a branch for halting here because aborting during a render/resume
+        // will never be treated like a halt
         replay.pendingTasks--;
         if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
           let errorDigest;
@@ -3862,7 +3874,13 @@ function abortTask(task: Task, request: Request, error: mixed): void {
       // boundary the message is referring to
       const errorInfo = getThrownInfo(task.componentStack);
       let errorDigest;
-      if (
+      if (enableHalt && request.trackedPostpones !== null) {
+        // We are halting a prerender. We need to mark the boundary as postponed
+        // but we do not log anything. It should be noted that with halt and postpone
+        // enabled halt semantics supercede and so if you abort with a postpone
+        // during prerender it will not show up in onPostpone
+        errorDigest = 'POSTPONE';
+      } else if (
         enablePostpone &&
         typeof error === 'object' &&
         error !== null &&
@@ -4133,6 +4151,7 @@ function retryRenderTask(
           ? request.fatalError
           : thrownValue;
 
+    const trackedPostpones = request.trackedPostpones;
     if (typeof x === 'object' && x !== null) {
       // $FlowFixMe[method-unbinding]
       if (typeof x.then === 'function') {
@@ -4145,14 +4164,15 @@ function retryRenderTask(
         return;
       } else if (
         enablePostpone &&
-        request.trackedPostpones !== null &&
+        trackedPostpones !== null &&
         x.$$typeof === REACT_POSTPONE_TYPE
       ) {
+        // We don't need to check for halting here because the thrown value for halts
+        // is a symbol type so we won't ever enter this branch
+
         // If we're tracking postpones, we mark this segment as postponed and finish
         // the task without filling it in. If we're not tracking, we treat it more like
         // an error.
-        const trackedPostpones = request.trackedPostpones;
-        task.abortSet.delete(task);
         const postponeInstance: Postpone = (x: any);
 
         const postponeInfo = getThrownInfo(task.componentStack);
@@ -4162,10 +4182,17 @@ function retryRenderTask(
           postponeInfo,
           __DEV__ && enableOwnerStacks ? task.debugTask : null,
         );
+        task.abortSet.delete(task);
         trackPostpone(request, trackedPostpones, task, segment);
         finishedTask(request, task.blockedBoundary, segment);
         return;
       }
+    } else if (enableHalt && x === haltSymbol && trackedPostpones !== null) {
+      // We're aborting a prerender with halt enabled
+      task.abortSet.delete(task);
+      trackPostpone(request, trackedPostpones, task, segment);
+      finishedTask(request, task.blockedBoundary, segment);
+      return;
     }
 
     const errorInfo = getThrownInfo(task.componentStack);
@@ -4905,6 +4932,8 @@ export function stopFlowing(request: Request): void {
   request.destination = null;
 }
 
+const haltSymbol = Symbol('halt');
+
 // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
 export function abort(request: Request, reason: mixed): void {
   if (request.status === OPEN) {
@@ -4923,7 +4952,12 @@ export function abort(request: Request, reason: mixed): void {
             : reason;
       // This error isn't necessarily fatal in this case but we need to stash it
       // so we can use it to abort any pending work
-      request.fatalError = error;
+      if (enableHalt && request.trackedPostpones !== null) {
+        // When enabled, during prerenders, aborts are treated like halts which postpone without logging
+        request.fatalError = haltSymbol;
+      } else {
+        request.fatalError = error;
+      }
       abortableTasks.forEach(task => abortTask(task, request, error));
       abortableTasks.clear();
     }