Use EventPriority to track update priority (#21082)

Instead of LanePriority. Internally, EventPriority is just a lane, so
this skips an extra conversion. Since EventPriority is a "public" (to
the host config) type, I was also able to remove some deep imports
of the Lane module.
This gets us most of the way to deleting the LanePriority entirely.

Author: acdlite

packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js

@@ -17,11 +17,7 @@ let ReactFeatureFlags;
 letSuspense;
 letSuspenseList;
 letact;
-
-// Copied from ReactFiberLanes. Don't do this!
-// This is hard coded directly to avoid needing to import, and
-// we'll remove this as we replace runWithPriority with React APIs.
-exportconstIdleLanePriority=2;
+letIdleEventPriority;
 
 functiondispatchMouseEvent(to,from){
 if(!to){
@@ -89,6 +85,8 @@ describe('ReactDOMServerPartialHydration', () => {
 Scheduler=require('scheduler');
 Suspense=React.Suspense;
 SuspenseList=React.SuspenseList;
+
+IdleEventPriority=require('react-reconciler/constants').IdleEventPriority;
 });
 
 // Note: This is based on a similar component we use in www. We can delete
@@ -628,7 +626,7 @@ describe('ReactDOMServerPartialHydration', () => {
 expect(span.textContent).toBe('Hello');
 
 // Schedule an update at idle priority
-ReactDOM.unstable_runWithPriority(IdleLanePriority,()=>{
+ReactDOM.unstable_runWithPriority(IdleEventPriority,()=>{
 root.render(<Apptext="Hi"className="hi"/>);
 });
 

packages/react-dom/src/__tests__/ReactDOMServerSelectiveHydration-test.internal.js

@@ -19,10 +19,7 @@ let Scheduler;
 letSuspense;
 letact;
 
-// Copied from ReactFiberLanes. Don't do this!
-// This is hard coded directly to avoid needing to import, and
-// we'll remove this as we replace runWithPriority with React APIs.
-exportconstIdleLanePriority=2;
+letIdleEventPriority;
 
 functiondispatchMouseHoverEvent(to,from){
 if(!to){
@@ -101,7 +98,7 @@ function dispatchClickEvent(target) {
 // and there's no native DOM event that maps to idle priority, so this is a
 // temporary workaround. Need something like ReactDOM.unstable_IdleUpdates.
 functionTODO_scheduleIdleDOMSchedulerTask(fn){
-ReactDOM.unstable_runWithPriority(IdleLanePriority,()=>{
+ReactDOM.unstable_runWithPriority(IdleEventPriority,()=>{
 constprevEvent=window.event;
 window.event={type: 'message'};
 try{
@@ -125,6 +122,8 @@ describe('ReactDOMServerSelectiveHydration', () => {
 act=ReactTestUtils.unstable_concurrentAct;
 Scheduler=require('scheduler');
 Suspense=React.Suspense;
+
+IdleEventPriority=require('react-reconciler/constants').IdleEventPriority;
 });
 
 // @gate experimental

packages/react-dom/src/client/ReactDOM.js

@@ -35,9 +35,11 @@ import {
 attemptDiscreteHydration,
 attemptContinuousHydration,
 attemptHydrationAtCurrentPriority,
-runWithPriority,
-getCurrentUpdateLanePriority,
 }from'react-reconciler/src/ReactFiberReconciler';
+import{
+runWithPriority,
+getCurrentUpdatePriority,
+}from'react-reconciler/src/ReactEventPriorities';
 import{createPortalascreatePortalImpl}from'react-reconciler/src/ReactPortal';
 import{canUseDOM}from'shared/ExecutionEnvironment';
 importReactVersionfrom'shared/ReactVersion';
@@ -74,7 +76,7 @@ setAttemptSynchronousHydration(attemptSynchronousHydration);
 setAttemptDiscreteHydration(attemptDiscreteHydration);
 setAttemptContinuousHydration(attemptContinuousHydration);
 setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority);
-setGetCurrentUpdatePriority(getCurrentUpdateLanePriority);
+setGetCurrentUpdatePriority(getCurrentUpdatePriority);
 setAttemptHydrationAtPriority(runWithPriority);
 
 letdidWarnAboutUnstableCreatePortal=false;

packages/react-dom/src/events/ReactDOMEventListener.js

@@ -44,16 +44,6 @@ import {
 discreteUpdates,
 }from'./ReactDOMUpdateBatching';
 
-import{
-InputContinuousLanePriorityasInputContinuousLanePriority_old,
-getCurrentUpdateLanePriorityasgetCurrentUpdateLanePriority_old,
-setCurrentUpdateLanePriorityassetCurrentUpdateLanePriority_old,
-}from'react-reconciler/src/ReactFiberLane.old';
-import{
-InputContinuousLanePriorityasInputContinuousLanePriority_new,
-getCurrentUpdateLanePriorityasgetCurrentUpdateLanePriority_new,
-setCurrentUpdateLanePriorityassetCurrentUpdateLanePriority_new,
-}from'react-reconciler/src/ReactFiberLane.new';
 import{getCurrentPriorityLevelasgetCurrentPriorityLevel_old}from'react-reconciler/src/SchedulerWithReactIntegration.old';
 import{
 getCurrentPriorityLevelasgetCurrentPriorityLevel_new,
@@ -68,19 +58,10 @@ import {
 ContinuousEventPriority,
 DefaultEventPriority,
 IdleEventPriority,
+getCurrentUpdatePriority,
+setCurrentUpdatePriority,
 }from'react-reconciler/src/ReactEventPriorities';
 
-// TODO: These should use the opaque EventPriority type instead of LanePriority.
-// Then internally we can use a Lane.
-constInputContinuousLanePriority=enableNewReconciler
- ? InputContinuousLanePriority_new
- : InputContinuousLanePriority_old;
-constgetCurrentUpdateLanePriority=enableNewReconciler
- ? getCurrentUpdateLanePriority_new
- : getCurrentUpdateLanePriority_old;
-constsetCurrentUpdateLanePriority=enableNewReconciler
- ? setCurrentUpdateLanePriority_new
- : setCurrentUpdateLanePriority_old;
 constgetCurrentPriorityLevel=enableNewReconciler
  ? getCurrentPriorityLevel_new
  : getCurrentPriorityLevel_old;
@@ -167,12 +148,12 @@ function dispatchContinuousEvent(
 container,
 nativeEvent,
 ){
-constpreviousPriority=getCurrentUpdateLanePriority();
+constpreviousPriority=getCurrentUpdatePriority();
 try{
-setCurrentUpdateLanePriority(InputContinuousLanePriority);
+setCurrentUpdatePriority(ContinuousEventPriority);
 dispatchEvent(domEventName,eventSystemFlags,container,nativeEvent);
 }finally{
-setCurrentUpdateLanePriority(previousPriority);
+setCurrentUpdatePriority(previousPriority);
 }
 }
 

packages/react-dom/src/events/ReactDOMEventReplaying.js

@@ -12,7 +12,7 @@ import type {Container, SuspenseInstance} from '../client/ReactDOMHostConfig';
 importtype{DOMEventName}from'../events/DOMEventNames';
 importtype{EventSystemFlags}from'./EventSystemFlags';
 importtype{FiberRoot}from'react-reconciler/src/ReactInternalTypes';
-importtype{LanePriority}from'react-reconciler/src/ReactFiberLane.old';
+importtype{EventPriority}from'react-reconciler/src/ReactEventPriorities';
 
 import{enableSelectiveHydration}from'shared/ReactFeatureFlags';
 import{
@@ -30,6 +30,7 @@ import {
 getClosestInstanceFromNode,
 }from'../client/ReactDOMComponentTree';
 import{HostRoot,SuspenseComponent}from'react-reconciler/src/ReactWorkTags';
+import{isHigherEventPriority}from'react-reconciler/src/ReactEventPriorities';
 
 let attemptSynchronousHydration: (fiber: Object)=>void;
 
@@ -57,16 +58,16 @@ export function setAttemptHydrationAtCurrentPriority(
 attemptHydrationAtCurrentPriority=fn;
 }
 
-let getCurrentUpdatePriority: ()=>LanePriority;
+let getCurrentUpdatePriority: ()=>EventPriority;
 
-exportfunctionsetGetCurrentUpdatePriority(fn: ()=>LanePriority){
+exportfunctionsetGetCurrentUpdatePriority(fn: ()=>EventPriority){
 getCurrentUpdatePriority=fn;
 }
 
-letattemptHydrationAtPriority: <T>(priority: LanePriority, fn: () =>T)=>T;
+letattemptHydrationAtPriority: <T>(priority: EventPriority, fn: () =>T)=>T;
 
 exportfunctionsetAttemptHydrationAtPriority(
-fn: <T>(priority: LanePriority,fn: ()=>T)=>T,
+fn: <T>(priority: EventPriority,fn: ()=>T)=>T,
 ){
 attemptHydrationAtPriority=fn;
 }
@@ -109,7 +110,7 @@ const queuedPointerCaptures: Map<number, QueuedReplayableEvent> = new Map();
 typeQueuedHydrationTarget={|
 blockedOn: null|Container|SuspenseInstance,
 target: Node,
-lanePriority: LanePriority,
+priority: EventPriority,
 |};
 constqueuedExplicitHydrationTargets: Array<QueuedHydrationTarget>=[];
 
@@ -390,7 +391,7 @@ function attemptExplicitHydrationTarget(
 // We're blocked on hydrating this boundary.
 // Increase its priority.
 queuedTarget.blockedOn=instance;
-attemptHydrationAtPriority(queuedTarget.lanePriority,()=>{
+attemptHydrationAtPriority(queuedTarget.priority,()=>{
 attemptHydrationAtCurrentPriority(nearestMounted);
 });
 
@@ -412,16 +413,23 @@ function attemptExplicitHydrationTarget(
 
 exportfunctionqueueExplicitHydrationTarget(target: Node): void{
 if(enableSelectiveHydration){
-constupdateLanePriority=getCurrentUpdatePriority();
+// TODO: This will read the priority if it's dispatched by the React
+// event system but not native events. Should read window.event.type, like
+// we do for updates (getCurrentEventPriority).
+constupdatePriority=getCurrentUpdatePriority();
 constqueuedTarget: QueuedHydrationTarget={
 blockedOn: null,
 target: target,
-lanePriority: updateLanePriority,
+priority: updatePriority,
 };
 leti=0;
 for(;i<queuedExplicitHydrationTargets.length;i++){
+// Stop once we hit the first target with lower priority than
 if(
-updateLanePriority<=queuedExplicitHydrationTargets[i].lanePriority
+!isHigherEventPriority(
+updatePriority,
+queuedExplicitHydrationTargets[i].priority,
+)
 ){
 break;
 }

packages/react-reconciler/src/ReactEventPriorities.js

@@ -14,24 +14,61 @@ import {
 ContinuousEventPriorityasContinuousEventPriority_old,
 DefaultEventPriorityasDefaultEventPriority_old,
 IdleEventPriorityasIdleEventPriority_old,
+getCurrentUpdatePriorityasgetCurrentUpdatePriority_old,
+setCurrentUpdatePriorityassetCurrentUpdatePriority_old,
+runWithPriorityasrunWithPriority_old,
+isHigherEventPriorityasisHigherEventPriority_old,
 }from'./ReactEventPriorities.old';
 
 import{
 DiscreteEventPriorityasDiscreteEventPriority_new,
 ContinuousEventPriorityasContinuousEventPriority_new,
 DefaultEventPriorityasDefaultEventPriority_new,
 IdleEventPriorityasIdleEventPriority_new,
+getCurrentUpdatePriorityasgetCurrentUpdatePriority_new,
+setCurrentUpdatePriorityassetCurrentUpdatePriority_new,
+runWithPriorityasrunWithPriority_new,
+isHigherEventPriorityasisHigherEventPriority_new,
 }from'./ReactEventPriorities.new';
 
-exportconstDiscreteEventPriority=enableNewReconciler
- ? DiscreteEventPriority_new
- : DiscreteEventPriority_old;
-exportconstContinuousEventPriority=enableNewReconciler
- ? ContinuousEventPriority_new
- : ContinuousEventPriority_old;
-exportconstDefaultEventPriority=enableNewReconciler
- ? DefaultEventPriority_new
- : DefaultEventPriority_old;
-exportconstIdleEventPriority=enableNewReconciler
- ? IdleEventPriority_new
- : IdleEventPriority_old;
+exportopaquetypeEventPriority=number;
+
+exportconstDiscreteEventPriority: EventPriority=enableNewReconciler
+ ? (DiscreteEventPriority_new: any)
+ : (DiscreteEventPriority_old: any);
+exportconstContinuousEventPriority: EventPriority=enableNewReconciler
+ ? (ContinuousEventPriority_new: any)
+ : (ContinuousEventPriority_old: any);
+exportconstDefaultEventPriority: EventPriority=enableNewReconciler
+ ? (DefaultEventPriority_new: any)
+ : (DefaultEventPriority_old: any);
+exportconstIdleEventPriority: EventPriority=enableNewReconciler
+ ? (IdleEventPriority_new: any)
+ : (IdleEventPriority_old: any);
+
+exportfunctionrunWithPriority<T>(priority: EventPriority,fn: ()=>T): T{
+returnenableNewReconciler
+ ? runWithPriority_new((priority: any),fn)
+ : runWithPriority_old((priority: any),fn);
+}
+
+exportfunctiongetCurrentUpdatePriority(): EventPriority{
+returnenableNewReconciler
+ ? (getCurrentUpdatePriority_new(): any)
+ : (getCurrentUpdatePriority_old(): any);
+}
+
+exportfunctionsetCurrentUpdatePriority(priority: EventPriority){
+returnenableNewReconciler
+ ? setCurrentUpdatePriority_new((priority: any))
+ : setCurrentUpdatePriority_old((priority: any));
+}
+
+exportfunctionisHigherEventPriority(
+a: EventPriority,
+b: EventPriority,
+): boolean{
+returnenableNewReconciler
+ ? isHigherEventPriority_new((a: any),(b: any))
+ : isHigherEventPriority_old((a: any),(b: any));
+}

packages/react-reconciler/src/ReactEventPriorities.new.js

@@ -7,9 +7,69 @@
  * @flow
  */
 
-export{
-SyncLaneasDiscreteEventPriority,
-InputContinuousLaneasContinuousEventPriority,
-DefaultLaneasDefaultEventPriority,
-IdleLaneasIdleEventPriority,
+importtype{Lane,Lanes}from'./ReactFiberLane.new';
+
+import{
+NoLane,
+SyncLane,
+InputContinuousLane,
+DefaultLane,
+IdleLane,
+getHighestPriorityLane,
+includesNonIdleWork,
 }from'./ReactFiberLane.new';
+
+exportopaquetypeEventPriority=Lane;
+
+exportconstDiscreteEventPriority: EventPriority=SyncLane;
+exportconstContinuousEventPriority: EventPriority=InputContinuousLane;
+exportconstDefaultEventPriority: EventPriority=DefaultLane;
+exportconstIdleEventPriority: EventPriority=IdleLane;
+
+let currentUpdatePriority: EventPriority=NoLane;
+
+exportfunctiongetCurrentUpdatePriority(): EventPriority{
+returncurrentUpdatePriority;
+}
+
+exportfunctionsetCurrentUpdatePriority(newPriority: EventPriority){
+currentUpdatePriority=newPriority;
+}
+
+exportfunctionrunWithPriority<T>(priority: EventPriority,fn: ()=>T): T{
+constpreviousPriority=currentUpdatePriority;
+try{
+currentUpdatePriority=priority;
+returnfn();
+}finally{
+currentUpdatePriority=previousPriority;
+}
+}
+
+exportfunctionhigherEventPriority(
+a: EventPriority,
+b: EventPriority,
+): EventPriority{
+returna!==0&&a<b ? a : b;
+}
+
+exportfunctionisHigherEventPriority(
+a: EventPriority,
+b: EventPriority,
+): boolean{
+returna!==0&&a<b;
+}
+
+exportfunctionlanesToEventPriority(lanes: Lanes): EventPriority{
+constlane=getHighestPriorityLane(lanes);
+if(!isHigherEventPriority(DiscreteEventPriority,lane)){
+returnDiscreteEventPriority;
+}
+if(!isHigherEventPriority(ContinuousEventPriority,lane)){
+returnContinuousEventPriority;
+}
+if(includesNonIdleWork(lane)){
+returnDefaultEventPriority;
+}
+returnIdleEventPriority;
+}