Cleanup enableUnifiedSyncLane flag

Author: tyao1

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__/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

@@ -961,15 +961,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 +1720,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')]);
     });