Pass lanes as argument to performSyncWorkOnRoot (#26763)

`performSyncWorkOnRoot` has only a single caller, and the caller already
computes the next lanes (`getNextLanes`) before deciding to call the
function. So we can pass them as an argument instead of computing the
lanes again.

There was already a TODO comment about this, but it was mostly perf
related. However, @rickhanlonii noticed a discrepancy where the inner
`getNextLanes` call was not being passed the current work-in- progress
lanes. Usually this shouldn't matter because there should never be
work-in-progress sync work; it should finish immediately. There is one
case I'm aware of where we exit the work loop without finishing a sync
render, which is selective hydration, but even then it should switch to
the sync hydration lane, not the normal sync lane. So something else is
probably going on. I suspect it might be related to the
`enableUnifiedSyncLane` experiment.

This is likely related to a regression found internally at Meta. We're
still working on getting a proper regression test; I can come up with a
contrived one but I'm not confident it'll be the same as the actual
regression until we get a better repro.

DiffTrain build for commit 13d0225.

Author: acdlite

compiled-rn/facebook-fbsource/xplat/js/RKJSModules/vendor/react-test-renderer/cjs/ReactTestRenderer-dev.js

@@ -7,7 +7,7 @@
  * @noflow
  * @nolint
  * @preventMunge
- * @generated SignedSource<<0e3d907c9303927e282697c3cd932853>>
+ * @generated SignedSource<<aab7866dd4ea4a33aa518692d1dfa02f>>
  */
 
 'use strict';
@@ -6078,10 +6078,7 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
   if (!mightHavePendingSyncWork) {
     // Fast path. There's no sync work to do.
     return;
-  }
-
-  var workInProgressRoot = getWorkInProgressRoot();
-  var workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes(); // There may or may not be synchronous work scheduled. Let's check.
+  } // There may or may not be synchronous work scheduled. Let's check.
 
   var didPerformSomeWork;
   var errors = null;
@@ -6094,6 +6091,8 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
     while (root !== null) {
       if (onlyLegacy && root.tag !== LegacyRoot);
       else {
+        var workInProgressRoot = getWorkInProgressRoot();
+        var workInProgressRootRenderLanes = getWorkInProgressRootRenderLanes();
         var nextLanes = getNextLanes(
           root,
           root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
@@ -6102,10 +6101,8 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy) {
         if (includesSyncLane(nextLanes)) {
           // This root has pending sync work. Flush it now.
           try {
-            // TODO: Pass nextLanes as an argument instead of computing it again
-            // inside performSyncWorkOnRoot.
             didPerformSomeWork = true;
-            performSyncWorkOnRoot(root);
+            performSyncWorkOnRoot(root, nextLanes);
           } catch (error) {
             // Collect errors so we can rethrow them at the end
             if (errors === null) {
@@ -20677,25 +20674,28 @@ function markRootSuspended(root, suspendedLanes) {
 } // This is the entry point for synchronous tasks that don't go
 // through Scheduler
 
-function performSyncWorkOnRoot(root) {
-  {
-    syncNestedUpdateFlag();
-  }
-
+function performSyncWorkOnRoot(root, lanes) {
   if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
     throw new Error("Should not already be working.");
   }
 
-  flushPassiveEffects(); // TODO: This was already computed in the caller. Pass it as an argument.
-
-  var lanes = getNextLanes(root, NoLanes);
+  var didFlushPassiveEffects = flushPassiveEffects();
 
-  if (!includesSyncLane(lanes)) {
-    // There's no remaining sync work left.
+  if (didFlushPassiveEffects) {
+    // If passive effects were flushed, exit to the outer work loop in the root
+    // scheduler, so we can recompute the priority.
+    // TODO: We don't actually need this `ensureRootIsScheduled` call because
+    // this path is only reachable if the root is already part of the schedule.
+    // I'm including it only for consistency with the other exit points from
+    // this function. Can address in a subsequent refactor.
     ensureRootIsScheduled(root);
     return null;
   }
 
+  {
+    syncNestedUpdateFlag();
+  }
+
   var exitStatus = renderRootSync(root, lanes);
 
   if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
@@ -23985,7 +23985,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-canary-62512bafc-20230928";
+var ReactVersion = "18.3.0-canary-13d0225c7-20230928";
 
 // Might add PROFILE later.