Fix more tests

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

@@ -275,32 +275,17 @@ describe('ReactDOMFiberAsync', () => {
         expect(ops).toEqual([]);
       });
       // Only the active updates have flushed
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(container.textContent).toEqual('ABC');
-        expect(ops).toEqual(['ABC']);
-      } else {
-        expect(container.textContent).toEqual('BC');
-        expect(ops).toEqual(['BC']);
-      }
+      expect(container.textContent).toEqual('ABC');
+      expect(ops).toEqual(['ABC']);
 
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        instance.push('D');
-        expect(container.textContent).toEqual('ABC');
-        expect(ops).toEqual(['ABC']);
-      } else {
-        instance.push('D');
-        expect(container.textContent).toEqual('BC');
-        expect(ops).toEqual(['BC']);
-      }
+      instance.push('D');
+      expect(container.textContent).toEqual('ABC');
+      expect(ops).toEqual(['ABC']);
 
       // Flush the async updates
       Scheduler.unstable_flushAll();
       expect(container.textContent).toEqual('ABCD');
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(ops).toEqual(['ABC', 'ABCD']);
-      } else {
-        expect(ops).toEqual(['BC', 'ABCD']);
-      }
+      expect(ops).toEqual(['ABC', 'ABCD']);
     });
 
     // @gate www

packages/react-reconciler/src/ReactFiberLane.js

@@ -23,7 +23,6 @@ import {
   enableUpdaterTracking,
   allowConcurrentByDefault,
   enableTransitionTracing,
-  enableUnifiedSyncLane,
 } from 'shared/ReactFeatureFlags';
 import {isDevToolsPresent} from './ReactFiberDevToolsHook';
 import {ConcurrentUpdatesByDefaultMode, NoMode} from './ReactTypeOfMode';
@@ -136,11 +135,9 @@ let nextTransitionLane: Lane = TransitionLane1;
 let nextRetryLane: Lane = RetryLane1;
 
 function getHighestPriorityLanes(lanes: Lanes | Lane): Lanes {
-  if (enableUnifiedSyncLane) {
-    const pendingSyncLanes = lanes & SyncUpdateLanes;
-    if (pendingSyncLanes !== 0) {
-      return pendingSyncLanes;
-    }
+  const pendingSyncLanes = lanes & SyncUpdateLanes;
+  if (pendingSyncLanes !== NoLanes) {
+    return pendingSyncLanes;
   }
   switch (getHighestPriorityLane(lanes)) {
     case SyncHydrationLane:
@@ -759,7 +756,7 @@ export function getBumpedLaneForHydration(
   const renderLane = getHighestPriorityLane(renderLanes);
 
   let lane;
-  if (enableUnifiedSyncLane && (renderLane & SyncUpdateLanes) !== NoLane) {
+  if ((renderLane & SyncUpdateLanes) !== NoLane) {
     lane = SyncHydrationLane;
   } else {
     switch (renderLane) {

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

@@ -158,17 +158,7 @@ describe('ReactBlockingMode', () => {
     );
 
     // Now flush the first update
-    if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded(['A1', 'B1']);
-      expect(root).toMatchRenderedOutput('A1B1');
-    } else {
-      // Only the second update should have flushed synchronously
-      expect(Scheduler).toHaveYielded(['B1']);
-      expect(root).toMatchRenderedOutput('A0B1');
-
-      // Now flush the first update
-      expect(Scheduler).toFlushAndYield(['A1']);
-      expect(root).toMatchRenderedOutput('A1B1');
-    }
+    expect(Scheduler).toHaveYielded(['A1', 'B1']);
+    expect(root).toMatchRenderedOutput('A1B1');
   });
 });

packages/react-reconciler/src/__tests__/ReactClassSetStateCallback-test.js

@@ -35,17 +35,11 @@ describe('ReactClassSetStateCallback', () => {
     expect(Scheduler).toHaveYielded([0]);
 
     await act(async () => {
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        React.startTransition(() => {
-          app.setState({step: 1}, () =>
-            Scheduler.unstable_yieldValue('Callback 1'),
-          );
-        });
-      } else {
+      React.startTransition(() => {
         app.setState({step: 1}, () =>
           Scheduler.unstable_yieldValue('Callback 1'),
         );
-      }
+      });
       ReactNoop.flushSync(() => {
         app.setState({step: 2}, () =>
           Scheduler.unstable_yieldValue('Callback 2'),

packages/react-reconciler/src/__tests__/ReactExpiration-test.js

@@ -508,13 +508,9 @@ describe('ReactExpiration', () => {
 
     // First demonstrate what happens when there's no starvation
     await act(async () => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          updateNormalPri();
-        });
-      } else {
+      React.startTransition(() => {
         updateNormalPri();
-      }
+      });
       expect(Scheduler).toFlushAndYieldThrough(['Sync pri: 0']);
       updateSyncPri();
       expect(Scheduler).toHaveYielded(['Sync pri: 1', 'Normal pri: 0']);
@@ -532,13 +528,9 @@ describe('ReactExpiration', () => {
 
     // Do the same thing, but starve the first update
     await act(async () => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          updateNormalPri();
-        });
-      } else {
+      React.startTransition(() => {
         updateNormalPri();
-      }
+      });
       expect(Scheduler).toFlushAndYieldThrough(['Sync pri: 1']);
 
       // This time, a lot of time has elapsed since the normal pri update

packages/react-reconciler/src/__tests__/ReactFlushSync-test.js

@@ -54,21 +54,13 @@ describe('ReactFlushSync', () => {
       // The passive effect will schedule a sync update and a normal update.
       // They should commit in two separate batches. First the sync one.
       expect(() => {
-        expect(Scheduler).toFlushUntilNextPaint(
-          gate(flags => flags.enableUnifiedSyncLane) ? ['1, 1'] : ['1, 0'],
-        );
+        expect(Scheduler).toFlushUntilNextPaint(['1, 1']);
       }).toErrorDev('flushSync was called from inside a lifecycle method');
 
-      // The remaining update is not sync
+      // No remaining update
       ReactNoop.flushSync();
       expect(Scheduler).toHaveYielded([]);
-
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(Scheduler).toFlushUntilNextPaint([]);
-      } else {
-        // Now flush it.
-        expect(Scheduler).toFlushUntilNextPaint(['1, 1']);
-      }
+      expect(Scheduler).toFlushUntilNextPaint([]);
     });
     expect(root).toMatchRenderedOutput('1, 1');
   });

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

@@ -568,13 +568,9 @@ describe('ReactHooks', () => {
       });
     };
 
-    if (gate(flags => flags.enableUnifiedSyncLane)) {
-      // Update at transition priority
-      React.startTransition(() => update(n => n * 100));
-    } else {
-      // Update at normal priority
-      ReactTestRenderer.unstable_batchedUpdates(() => update(n => n * 100));
-    }
+    // Update at transition priority
+    React.startTransition(() => update(n => n * 100));
+
     // The new state is eagerly computed.
     expect(Scheduler).toHaveYielded(['Compute state (1 -> 100)']);
 

packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js

@@ -171,15 +171,10 @@ describe('ReactHooksWithNoopRenderer', () => {
 
     // Schedule some updates
     act(() => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          counter.current.updateCount(1);
-          counter.current.updateCount(count => count + 10);
-        });
-      } else {
+      React.startTransition(() => {
         counter.current.updateCount(1);
         counter.current.updateCount(count => count + 10);
-      }
+      });
 
       // Partially flush without committing
       expect(Scheduler).toFlushAndYieldThrough(['Count: 11']);
@@ -815,13 +810,9 @@ describe('ReactHooksWithNoopRenderer', () => {
         ReactNoop.discreteUpdates(() => {
           setRow(5);
         });
-        if (gate(flags => flags.enableSyncDefaultUpdates)) {
-          React.startTransition(() => {
-            setRow(20);
-          });
-        } else {
+        React.startTransition(() => {
           setRow(20);
-        }
+        });
       });
       expect(Scheduler).toHaveYielded(['Up', 'Down']);
       expect(root).toMatchRenderedOutput(<span prop="Down" />);
@@ -961,15 +952,8 @@ describe('ReactHooksWithNoopRenderer', () => {
       ReactNoop.flushSync(() => {
         counter.current.dispatch(INCREMENT);
       });
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(Scheduler).toHaveYielded(['Count: 4']);
-        expect(ReactNoop.getChildren()).toEqual([span('Count: 4')]);
-      } else {
-        expect(Scheduler).toHaveYielded(['Count: 1']);
-        expect(ReactNoop.getChildren()).toEqual([span('Count: 1')]);
-        expect(Scheduler).toFlushAndYield(['Count: 4']);
-        expect(ReactNoop.getChildren()).toEqual([span('Count: 4')]);
-      }
+      expect(Scheduler).toHaveYielded(['Count: 4']);
+      expect(ReactNoop.getChildren()).toEqual([span('Count: 4')]);
     });
   });
 
@@ -1727,15 +1711,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       // As a result we, somewhat surprisingly, commit them in the opposite order.
       // This should be fine because any non-discrete set of work doesn't guarantee order
       // and easily could've happened slightly later too.
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(Scheduler).toHaveYielded(['Will set count to 1', 'Count: 1']);
-      } else {
-        expect(Scheduler).toHaveYielded([
-          'Will set count to 1',
-          'Count: 2',
-          'Count: 1',
-        ]);
-      }
+      expect(Scheduler).toHaveYielded(['Will set count to 1', 'Count: 1']);
 
       expect(ReactNoop.getChildren()).toEqual([span('Count: 1')]);
     });

packages/react-reconciler/src/__tests__/ReactIncremental-test.js

@@ -215,17 +215,7 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo />);
     expect(Scheduler).toFlushWithoutYielding();
 
-    if (gate(flags => flags.enableSyncDefaultUpdates)) {
-      React.startTransition(() => {
-        inst.setState(
-          () => {
-            Scheduler.unstable_yieldValue('setState1');
-            return {text: 'bar'};
-          },
-          () => Scheduler.unstable_yieldValue('callback1'),
-        );
-      });
-    } else {
+    React.startTransition(() => {
       inst.setState(
         () => {
           Scheduler.unstable_yieldValue('setState1');
@@ -233,24 +223,14 @@ describe('ReactIncremental', () => {
         },
         () => Scheduler.unstable_yieldValue('callback1'),
       );
-    }
+    });
 
     // Flush part of the work
     expect(Scheduler).toFlushAndYieldThrough(['setState1']);
 
     // This will abort the previous work and restart
     ReactNoop.flushSync(() => ReactNoop.render(<Foo />));
-    if (gate(flags => flags.enableSyncDefaultUpdates)) {
-      React.startTransition(() => {
-        inst.setState(
-          () => {
-            Scheduler.unstable_yieldValue('setState2');
-            return {text2: 'baz'};
-          },
-          () => Scheduler.unstable_yieldValue('callback2'),
-        );
-      });
-    } else {
+    React.startTransition(() => {
       inst.setState(
         () => {
           Scheduler.unstable_yieldValue('setState2');
@@ -258,7 +238,7 @@ describe('ReactIncremental', () => {
         },
         () => Scheduler.unstable_yieldValue('callback2'),
       );
-    }
+    });
 
     // Flush the rest of the work which now includes the low priority
     expect(Scheduler).toFlushAndYield([

packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js

@@ -162,21 +162,11 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     // Schedule some async updates
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates || flags.enableUnifiedSyncLane,
-      )
-    ) {
-      React.startTransition(() => {
-        instance.setState(createUpdate('a'));
-        instance.setState(createUpdate('b'));
-        instance.setState(createUpdate('c'));
-      });
-    } else {
+    React.startTransition(() => {
       instance.setState(createUpdate('a'));
       instance.setState(createUpdate('b'));
       instance.setState(createUpdate('c'));
-    }
+    });
 
     // Begin the updates but don't flush them yet
     expect(Scheduler).toFlushAndYieldThrough(['a', 'b', 'c']);
@@ -193,54 +183,24 @@ describe('ReactIncrementalUpdates', () => {
     });
 
     // The sync updates should have flushed, but not the async ones.
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates && flags.enableUnifiedSyncLane,
-      )
-    ) {
-      expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
-      expect(ReactNoop.getChildren()).toEqual([span('def')]);
-    } else {
-      // Update d was dropped and replaced by e.
-      expect(Scheduler).toHaveYielded(['e', 'f']);
-      expect(ReactNoop.getChildren()).toEqual([span('ef')]);
-    }
+    expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
+    expect(ReactNoop.getChildren()).toEqual([span('def')]);
 
     // Now flush the remaining work. Even though e and f were already processed,
     // they should be processed again, to ensure that the terminal state
     // is deterministic.
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates && !flags.enableUnifiedSyncLane,
-      )
-    ) {
-      expect(Scheduler).toFlushAndYield([
-        // Since 'g' is in a transition, we'll process 'd' separately first.
-        // That causes us to process 'd' with 'e' and 'f' rebased.
-        'd',
-        'e',
-        'f',
-        // Then we'll re-process everything for 'g'.
-        'a',
-        'b',
-        'c',
-        'd',
-        'e',
-        'f',
-        'g',
-      ]);
-    } else {
-      expect(Scheduler).toFlushAndYield([
-        // Then we'll re-process everything for 'g'.
-        'a',
-        'b',
-        'c',
-        'd',
-        'e',
-        'f',
-        'g',
-      ]);
-    }
+    expect(Scheduler).toFlushAndYield([
+      // Although 'g' is in a transition, it is intuerrupted and
+      // batched with 'd'
+      // Twe'll re-process everything for 'g'.
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'f',
+      'g',
+    ]);
     expect(ReactNoop.getChildren()).toEqual([span('abcdefg')]);
   });
 
@@ -273,21 +233,11 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     // Schedule some async updates
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates || flags.enableUnifiedSyncLane,
-      )
-    ) {
-      React.startTransition(() => {
-        instance.setState(createUpdate('a'));
-        instance.setState(createUpdate('b'));
-        instance.setState(createUpdate('c'));
-      });
-    } else {
+    React.startTransition(() => {
       instance.setState(createUpdate('a'));
       instance.setState(createUpdate('b'));
       instance.setState(createUpdate('c'));
-    }
+    });
 
     // Begin the updates but don't flush them yet
     expect(Scheduler).toFlushAndYieldThrough(['a', 'b', 'c']);
@@ -307,53 +257,22 @@ describe('ReactIncrementalUpdates', () => {
     });
 
     // The sync updates should have flushed, but not the async ones.
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates && flags.enableUnifiedSyncLane,
-      )
-    ) {
-      expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
-    } else {
-      // Update d was dropped and replaced by e.
-      expect(Scheduler).toHaveYielded(['e', 'f']);
-    }
+    expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
     expect(ReactNoop.getChildren()).toEqual([span('f')]);
 
     // Now flush the remaining work. Even though e and f were already processed,
     // they should be processed again, to ensure that the terminal state
     // is deterministic.
-    if (
-      gate(
-        flags => flags.enableSyncDefaultUpdates && !flags.enableUnifiedSyncLane,
-      )
-    ) {
-      expect(Scheduler).toFlushAndYield([
-        // Since 'g' is in a transition, we'll process 'd' separately first.
-        // That causes us to process 'd' with 'e' and 'f' rebased.
-        'd',
-        'e',
-        'f',
-        // Then we'll re-process everything for 'g'.
-        'a',
-        'b',
-        'c',
-        'd',
-        'e',
-        'f',
-        'g',
-      ]);
-    } else {
-      expect(Scheduler).toFlushAndYield([
-        // Then we'll re-process everything for 'g'.
-        'a',
-        'b',
-        'c',
-        'd',
-        'e',
-        'f',
-        'g',
-      ]);
-    }
+    expect(Scheduler).toFlushAndYield([
+      // Then we'll re-process everything for 'g'.
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'f',
+      'g',
+    ]);
     expect(ReactNoop.getChildren()).toEqual([span('fg')]);
   });
 
@@ -696,41 +615,26 @@ describe('ReactIncrementalUpdates', () => {
     expect(root).toMatchRenderedOutput(null);
 
     await act(async () => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          pushToLog('A');
-        });
-      } else {
+      React.startTransition(() => {
         pushToLog('A');
-      }
-
+      });
       ReactNoop.unstable_runWithPriority(ContinuousEventPriority, () =>
         pushToLog('B'),
       );
     });
-    if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded([
-        'Committed: B',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
-    } else {
-      expect(Scheduler).toHaveYielded([
-        // A and B are pending. B is higher priority, so we'll render that first.
-        'Committed: B',
-        // Because A comes first in the queue, we're now in rebase mode. B must
-        // be rebased on top of A. Also, in a layout effect, we received two new
-        // updates: C and D. C is user-blocking and D is synchronous.
-        //
-        // First render the synchronous update. What we're testing here is that
-        // B *is not dropped* even though it has lower than sync priority. That's
-        // because we already committed it. However, this render should not
-        // include C, because that update wasn't already committed.
-        'Committed: BD',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
-    }
+    expect(Scheduler).toHaveYielded([
+      // A and B are pending. B is higher priority, so we'll render that first.
+      'Committed: B',
+      // Because A comes first in the queue, we're now in rebase mode. B must
+      // be rebased on top of A. Also, in a layout effect, we received two new
+      // updates: C and D. C is user-blocking and D is synchronous.
+      //
+      // First render the synchronous update. What we're testing here is that
+      // B *is not dropped* even though it has lower than sync priority. That's
+      // because we already committed it. C is batched with BD.
+      'Committed: BCD',
+      'Committed: ABCD',
+    ]);
     expect(root).toMatchRenderedOutput('ABCD');
   });
 
@@ -765,40 +669,26 @@ describe('ReactIncrementalUpdates', () => {
     expect(root).toMatchRenderedOutput(null);
 
     await act(async () => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          pushToLog('A');
-        });
-      } else {
+      React.startTransition(() => {
         pushToLog('A');
-      }
+      });
       ReactNoop.unstable_runWithPriority(ContinuousEventPriority, () =>
         pushToLog('B'),
       );
     });
-    if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded([
-        'Committed: B',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
-    } else {
-      expect(Scheduler).toHaveYielded([
-        // A and B are pending. B is higher priority, so we'll render that first.
-        'Committed: B',
-        // Because A comes first in the queue, we're now in rebase mode. B must
-        // be rebased on top of A. Also, in a layout effect, we received two new
-        // updates: C and D. C is user-blocking and D is synchronous.
-        //
-        // First render the synchronous update. What we're testing here is that
-        // B *is not dropped* even though it has lower than sync priority. That's
-        // because we already committed it. However, this render should not
-        // include C, because that update wasn't already committed.
-        'Committed: BD',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
-    }
+    expect(Scheduler).toHaveYielded([
+      // A and B are pending. B is higher priority, so we'll render that first.
+      'Committed: B',
+      // Because A comes first in the queue, we're now in rebase mode. B must
+      // be rebased on top of A. Also, in a layout effect, we received two new
+      // updates: C and D. C is user-blocking and D is synchronous.
+      //
+      // First render the synchronous update. What we're testing here is that
+      // B *is not dropped* even though it has lower than sync priority. That's
+      // because we already committed it. C is batched with BD.
+      'Committed: BCD',
+      'Committed: ABCD',
+    ]);
     expect(root).toMatchRenderedOutput('ABCD');
   });
 

packages/react-reconciler/src/__tests__/ReactOffscreen-test.js

@@ -690,15 +690,10 @@ describe('ReactOffscreen', () => {
       );
 
       // Before the inner update can finish, we receive another pair of updates.
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        React.startTransition(() => {
-          setOuter(2);
-          setInner(2);
-        });
-      } else {
+      React.startTransition(() => {
         setOuter(2);
         setInner(2);
-      }
+      });
 
       // Also, before either of these new updates are processed, the hidden
       // tree is revealed at high priority.

packages/react-reconciler/src/__tests__/ReactSuspenseList-test.js

@@ -2549,13 +2549,9 @@ describe('ReactSuspenseList', () => {
 
     await act(async () => {
       // Add a few items at the end.
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          updateLowPri(true);
-        });
-      } else {
+      React.startTransition(() => {
         updateLowPri(true);
-      }
+      });
 
       // Flush partially through.
       expect(Scheduler).toFlushAndYieldThrough(['B', 'C']);

packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js

@@ -3796,7 +3796,6 @@ describe('ReactSuspenseWithNoopRenderer', () => {
   });
 
   // @gate enableLegacyCache
-  // @gate !enableSyncDefaultUpdates
   it('regression: ping at high priority causes update to be dropped', async () => {
     const {useState, useTransition} = React;
 
@@ -3863,10 +3862,9 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       });
 
       expect(Scheduler).toFlushAndYield([
-        'B',
         'Suspend! [A1]',
         'Loading...',
-
+        'B',
         'Suspend! [A2]',
         'Loading...',
         'Suspend! [B2]',
@@ -3882,6 +3880,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       await resolveText('A1');
       expect(Scheduler).toFlushAndYield([
         'A1',
+        'B',
         'Suspend! [A2]',
         'Loading...',
         'Suspend! [B2]',

packages/react-reconciler/src/__tests__/ReactTransition-test.js

@@ -934,28 +934,16 @@ describe('ReactTransition', () => {
       updateNormalPri();
     });
 
-    if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded([
-        'Normal pri: 0',
-        'Commit',
+    expect(Scheduler).toHaveYielded([
+      // Finish transition update.
+      'Normal pri: 0',
+      'Commit',
 
-        // Normal pri update.
-        'Transition pri: 1',
-        'Normal pri: 1',
-        'Commit',
-      ]);
-    } else {
-      expect(Scheduler).toHaveYielded([
-        // Finish transition update.
-        'Normal pri: 0',
-        'Commit',
-
-        // Normal pri update.
-        'Transition pri: 1',
-        'Normal pri: 1',
-        'Commit',
-      ]);
-    }
+      // Normal pri update.
+      'Transition pri: 1',
+      'Normal pri: 1',
+      'Commit',
+    ]);
 
     expect(root).toMatchRenderedOutput('Transition pri: 1, Normal pri: 1');
   });

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

@@ -454,13 +454,9 @@ describe('useMutableSource', () => {
 
       // Changing values should schedule an update with React.
       // Start working on this update but don't finish it.
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          source.value = 'two';
-        });
-      } else {
+      React.startTransition(() => {
         source.value = 'two';
-      }
+      });
       expect(Scheduler).toFlushAndYieldThrough(['a:two']);
 
       // Re-renders that occur before the update is processed
@@ -1558,15 +1554,10 @@ describe('useMutableSource', () => {
         expect(Scheduler).toFlushAndYieldThrough(['a0', 'b0']);
         // Mutate in an event. This schedules a subscription update on a, which
         // already mounted, but not b, which hasn't subscribed yet.
-        if (gate(flags => flags.enableUnifiedSyncLane)) {
-          React.startTransition(() => {
-            mutateA('a1');
-            mutateB('b1');
-          });
-        } else {
+        React.startTransition(() => {
           mutateA('a1');
           mutateB('b1');
-        }
+        });
 
         // Mutate again at lower priority. This will schedule another subscription
         // update on a, but not b. When b mounts and subscriptions, the value it

packages/react/src/__tests__/ReactProfiler-test.internal.js

@@ -1065,13 +1065,9 @@ describe(`onRender`, () => {
 
       // Render a partially update, but don't finish.
       // This partial render will take 10ms of actual render time.
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          first.setState({renderTime: 10});
-        });
-      } else {
+      React.startTransition(() => {
         first.setState({renderTime: 10});
-      }
+      });
       expect(Scheduler).toFlushAndYieldThrough(['FirstComponent:10']);
       expect(callback).toHaveBeenCalledTimes(0);
 

packages/shared/ReactFeatureFlags.js

@@ -137,8 +137,6 @@ export const enableUseRefAccessWarning = false;
 // Enables time slicing for updates that aren't wrapped in startTransition.
 export const enableSyncDefaultUpdates = true;
 
-export const enableUnifiedSyncLane = __EXPERIMENTAL__;
-
 // Adds an opt-in to time slicing for updates that aren't wrapped in
 // startTransition. Only relevant when enableSyncDefaultUpdates is disabled.
 export const allowConcurrentByDefault = false;

packages/shared/forks/ReactFeatureFlags.native-fb.js

@@ -68,7 +68,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = true;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = false;
 export const allowConcurrentByDefault = true;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.native-oss.js

@@ -59,7 +59,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = false;
 export const allowConcurrentByDefault = false;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.test-renderer.js

@@ -59,7 +59,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = __EXPERIMENTAL__;
 export const allowConcurrentByDefault = false;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.test-renderer.native.js

@@ -58,7 +58,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = false;
 export const allowConcurrentByDefault = true;
 
 export const consoleManagedByDevToolsDuringStrictMode = false;

packages/shared/forks/ReactFeatureFlags.test-renderer.www.js

@@ -59,7 +59,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = false;
 export const allowConcurrentByDefault = true;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.testing.js

@@ -59,7 +59,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = __EXPERIMENTAL__;
 export const allowConcurrentByDefault = false;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.testing.www.js

@@ -59,7 +59,6 @@ export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const enableSyncDefaultUpdates = true;
-export const enableUnifiedSyncLane = __EXPERIMENTAL__;
 export const allowConcurrentByDefault = true;
 export const enableCustomElementPropertySupport = false;
 

packages/shared/forks/ReactFeatureFlags.www-dynamic.js

@@ -23,7 +23,6 @@ export const enableProfilerNestedUpdateScheduledHook = __VARIANT__;
 export const disableSchedulerTimeoutInWorkLoop = __VARIANT__;
 export const enableLazyContextPropagation = __VARIANT__;
 export const enableSyncDefaultUpdates = __VARIANT__;
-export const enableUnifiedSyncLane = __VARIANT__;
 export const enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay = __VARIANT__;
 export const enableTransitionTracing = __VARIANT__;
 // Enable this flag to help with concurrent mode debugging.

packages/shared/forks/ReactFeatureFlags.www.js

@@ -29,7 +29,6 @@ export const {
   disableSchedulerTimeoutInWorkLoop,
   enableLazyContextPropagation,
   enableSyncDefaultUpdates,
-  enableUnifiedSyncLane,
   enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
   enableTransitionTracing,
 } = dynamicFeatureFlags;

packages/use-subscription/src/__tests__/useSubscription-test.js

@@ -439,13 +439,9 @@ describe('useSubscription', () => {
 
     // Start React update, but don't finish
     act(() => {
-      if (gate(flags => flags.enableSyncDefaultUpdates)) {
-        React.startTransition(() => {
-          renderer.update(<Parent observed={observableB} />);
-        });
-      } else {
+      React.startTransition(() => {
         renderer.update(<Parent observed={observableB} />);
-      }
+      });
       expect(Scheduler).toFlushAndYieldThrough(['Child: b-0']);
       expect(log).toEqual([]);
 
@@ -454,13 +450,9 @@ describe('useSubscription', () => {
       observableA.next('a-2');
 
       // Update again
-      if (gate(flags => flags.enableUnifiedSyncLane)) {
-        React.startTransition(() => {
-          renderer.update(<Parent observed={observableA} />);
-        });
-      } else {
+      React.startTransition(() => {
         renderer.update(<Parent observed={observableA} />);
-      }
+      });
 
       // Flush everything and ensure that the correct subscribable is used
       expect(Scheduler).toFlushAndYield([