From 34ee3919c39bc9b149462322713a9811db4b8498 Mon Sep 17 00:00:00 2001 From: Jack Pope Date: Tue, 17 Dec 2024 11:56:00 -0500 Subject: [PATCH] Clean up enableLazyContextPropagation (#31810) This flag has shipped everywhere, let's clean it up. --- ...eactLegacyContextDisabled-test.internal.js | 10 +- .../src/ReactFiberBeginWork.js | 71 +----- .../src/ReactFiberClassComponent.js | 5 +- .../react-reconciler/src/ReactFiberHooks.js | 33 ++- .../src/ReactFiberNewContext.js | 214 ++---------------- .../react-reconciler/src/ReactFiberThrow.js | 29 ++- .../__tests__/ReactContextPropagation-test.js | 5 - .../__tests__/ReactContextValidator-test.js | 8 +- packages/shared/ReactFeatureFlags.js | 2 - .../forks/ReactFeatureFlags.native-fb.js | 1 - .../forks/ReactFeatureFlags.native-oss.js | 1 - .../forks/ReactFeatureFlags.test-renderer.js | 1 - ...actFeatureFlags.test-renderer.native-fb.js | 2 - .../ReactFeatureFlags.test-renderer.www.js | 1 - .../shared/forks/ReactFeatureFlags.www.js | 1 - 15 files changed, 53 insertions(+), 331 deletions(-) diff --git a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js index 7c68b275c232b..257c061fb46a0 100644 --- a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js +++ b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js @@ -233,15 +233,7 @@ describe('ReactLegacyContextDisabled', () => { ); }); expect(container.textContent).toBe('bbb'); - if (gate(flags => flags.enableLazyContextPropagation)) { - // In the lazy propagation implementation, we don't check if context - // changed until after shouldComponentUpdate is run. - expect(lifecycleContextLog).toEqual(['b', 'b', 'b']); - } else { - // In the eager implementation, a dirty flag was set when the parent - // changed, so we skipped sCU. - expect(lifecycleContextLog).toEqual(['b', 'b']); - } + expect(lifecycleContextLog).toEqual(['b', 'b', 'b']); root.unmount(); }); }); diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js index 2d3e3c04c48ea..632b2df70c097 100644 --- a/packages/react-reconciler/src/ReactFiberBeginWork.js +++ b/packages/react-reconciler/src/ReactFiberBeginWork.js @@ -37,8 +37,6 @@ import type { import type {UpdateQueue} from './ReactFiberClassUpdateQueue'; import type {RootState} from './ReactFiberRoot'; import type {TracingMarkerInstance} from './ReactFiberTracingMarkerComponent'; -import type {TransitionStatus} from './ReactFiberConfig'; -import type {Hook} from './ReactFiberHooks'; import { markComponentRenderStarted, @@ -100,7 +98,6 @@ import { enableProfilerCommitHooks, enableProfilerTimer, enableScopeAPI, - enableLazyContextPropagation, enableSchedulingProfiler, enableTransitionTracing, enableLegacyHidden, @@ -272,7 +269,6 @@ import { createClassErrorUpdate, initializeClassErrorUpdate, } from './ReactFiberThrow'; -import is from 'shared/objectIs'; import { getForksAtLevel, isForkedChild, @@ -843,7 +839,7 @@ function deferHiddenOffscreenComponent( pushOffscreenSuspenseHandler(workInProgress); - if (enableLazyContextPropagation && current !== null) { + if (current !== null) { // Since this tree will resume rendering in a separate render, we need // to propagate parent contexts now so we don't lose track of which // ones changed. @@ -1636,26 +1632,6 @@ function updateHostComponent( } else { HostTransitionContext._currentValue2 = newState; } - if (enableLazyContextPropagation) { - // In the lazy propagation implementation, we don't scan for matching - // consumers until something bails out. - } else { - if (didReceiveUpdate) { - if (current !== null) { - const oldStateHook: Hook = current.memoizedState; - const oldState: TransitionStatus = oldStateHook.memoizedState; - // This uses regular equality instead of Object.is because we assume - // that host transition state doesn't include NaN as a valid type. - if (oldState !== newState) { - propagateContextChange( - workInProgress, - HostTransitionContext, - renderLanes, - ); - } - } - } - } } markRef(current, workInProgress); @@ -2706,10 +2682,7 @@ function updateDehydratedSuspenseComponent( } if ( - enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too. - // But don't want to re-arrange the if-else chain until/unless this - // feature lands. !didReceiveUpdate ) { // We need to check if any children have context before we decide to bail @@ -3300,8 +3273,6 @@ function updateContextProvider( context = workInProgress.type._context; } const newProps = workInProgress.pendingProps; - const oldProps = workInProgress.memoizedProps; - const newValue = newProps.value; if (__DEV__) { @@ -3317,34 +3288,6 @@ function updateContextProvider( pushProvider(workInProgress, context, newValue); - if (enableLazyContextPropagation) { - // In the lazy propagation implementation, we don't scan for matching - // consumers until something bails out, because until something bails out - // we're going to visit those nodes, anyway. The trade-off is that it shifts - // responsibility to the consumer to track whether something has changed. - } else { - if (oldProps !== null) { - const oldValue = oldProps.value; - if (is(oldValue, newValue)) { - // No change. Bailout early if children are the same. - if ( - oldProps.children === newProps.children && - !hasLegacyContextChanged() - ) { - return bailoutOnAlreadyFinishedWork( - current, - workInProgress, - renderLanes, - ); - } - } else { - // The context value changed. Search for matching consumers and schedule - // them to update. - propagateContextChange(workInProgress, context, renderLanes); - } - } - } - const newChildren = newProps.children; reconcileChildren(current, workInProgress, newChildren, renderLanes); return workInProgress.child; @@ -3463,7 +3406,7 @@ function bailoutOnAlreadyFinishedWork( // TODO: Once we add back resuming, we should check if the children are // a work-in-progress set. If so, we need to transfer their effects. - if (enableLazyContextPropagation && current !== null) { + if (current !== null) { // Before bailing out, check if there are any context changes in // the children. lazilyPropagateParentContextChanges(current, workInProgress, renderLanes); @@ -3564,11 +3507,9 @@ function checkScheduledUpdateOrContext( } // No pending update, but because context is propagated lazily, we need // to check for a context change before we bail out. - if (enableLazyContextPropagation) { - const dependencies = current.dependencies; - if (dependencies !== null && checkIfContextChanged(dependencies)) { - return true; - } + const dependencies = current.dependencies; + if (dependencies !== null && checkIfContextChanged(dependencies)) { + return true; } return false; } @@ -3706,7 +3647,7 @@ function attemptEarlyBailoutIfNoScheduledUpdate( workInProgress.childLanes, ); - if (enableLazyContextPropagation && !hasChildWork) { + if (!hasChildWork) { // Context changes may not have been propagated yet. We need to do // that now, before we can decide whether to bail out. // TODO: We use `childLanes` as a heuristic for whether there is diff --git a/packages/react-reconciler/src/ReactFiberClassComponent.js b/packages/react-reconciler/src/ReactFiberClassComponent.js index f5d5c96a2a93c..7ebf0fb9f4b92 100644 --- a/packages/react-reconciler/src/ReactFiberClassComponent.js +++ b/packages/react-reconciler/src/ReactFiberClassComponent.js @@ -21,7 +21,6 @@ import { debugRenderPhaseSideEffectsForStrictMode, disableLegacyContext, enableSchedulingProfiler, - enableLazyContextPropagation, disableDefaultPropsExceptForClasses, } from 'shared/ReactFeatureFlags'; import ReactStrictModeWarnings from './ReactStrictModeWarnings'; @@ -1092,7 +1091,6 @@ function updateClassInstance( !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !( - enableLazyContextPropagation && current !== null && current.dependencies !== null && checkIfContextChanged(current.dependencies) @@ -1144,8 +1142,7 @@ function updateClassInstance( // both before and after `shouldComponentUpdate` has been called. Not ideal, // but I'm loath to refactor this function. This only happens for memoized // components so it's not that common. - (enableLazyContextPropagation && - current !== null && + (current !== null && current.dependencies !== null && checkIfContextChanged(current.dependencies)); diff --git a/packages/react-reconciler/src/ReactFiberHooks.js b/packages/react-reconciler/src/ReactFiberHooks.js index 771b60cbb0894..12b110b16d3c9 100644 --- a/packages/react-reconciler/src/ReactFiberHooks.js +++ b/packages/react-reconciler/src/ReactFiberHooks.js @@ -36,7 +36,6 @@ import { import ReactSharedInternals from 'shared/ReactSharedInternals'; import { enableSchedulingProfiler, - enableLazyContextPropagation, enableTransitionTracing, enableUseEffectEventHook, enableUseResourceEffectHook, @@ -743,23 +742,21 @@ function finishRenderingHooks( ); } - if (enableLazyContextPropagation) { - if (current !== null) { - if (!checkIfWorkInProgressReceivedUpdate()) { - // If there were no changes to props or state, we need to check if there - // was a context change. We didn't already do this because there's no - // 1:1 correspondence between dependencies and hooks. Although, because - // there almost always is in the common case (`readContext` is an - // internal API), we could compare in there. OTOH, we only hit this case - // if everything else bails out, so on the whole it might be better to - // keep the comparison out of the common path. - const currentDependencies = current.dependencies; - if ( - currentDependencies !== null && - checkIfContextChanged(currentDependencies) - ) { - markWorkInProgressReceivedUpdate(); - } + if (current !== null) { + if (!checkIfWorkInProgressReceivedUpdate()) { + // If there were no changes to props or state, we need to check if there + // was a context change. We didn't already do this because there's no + // 1:1 correspondence between dependencies and hooks. Although, because + // there almost always is in the common case (`readContext` is an + // internal API), we could compare in there. OTOH, we only hit this case + // if everything else bails out, so on the whole it might be better to + // keep the comparison out of the common path. + const currentDependencies = current.dependencies; + if ( + currentDependencies !== null && + checkIfContextChanged(currentDependencies) + ) { + markWorkInProgressReceivedUpdate(); } } } diff --git a/packages/react-reconciler/src/ReactFiberNewContext.js b/packages/react-reconciler/src/ReactFiberNewContext.js index 6a779cfd4ab4c..b10dc5ce547ae 100644 --- a/packages/react-reconciler/src/ReactFiberNewContext.js +++ b/packages/react-reconciler/src/ReactFiberNewContext.js @@ -15,24 +15,13 @@ import type { } from './ReactInternalTypes'; import type {StackCursor} from './ReactFiberStack'; import type {Lanes} from './ReactFiberLane'; -import type {SharedQueue} from './ReactFiberClassUpdateQueue'; import type {TransitionStatus} from './ReactFiberConfig'; import type {Hook} from './ReactFiberHooks'; import {isPrimaryRenderer, HostTransitionContext} from './ReactFiberConfig'; import {createCursor, push, pop} from './ReactFiberStack'; -import { - ContextProvider, - ClassComponent, - DehydratedFragment, -} from './ReactWorkTags'; -import { - NoLanes, - isSubsetOfLanes, - includesSomeLane, - mergeLanes, - pickArbitraryLane, -} from './ReactFiberLane'; +import {ContextProvider, DehydratedFragment} from './ReactWorkTags'; +import {NoLanes, isSubsetOfLanes, mergeLanes} from './ReactFiberLane'; import { NoFlags, DidPropagateContext, @@ -40,12 +29,7 @@ import { } from './ReactFiberFlags'; import is from 'shared/objectIs'; -import {createUpdate, ForceUpdate} from './ReactFiberClassUpdateQueue'; -import {markWorkInProgressReceivedUpdate} from './ReactFiberBeginWork'; -import { - enableLazyContextPropagation, - enableRenderableContext, -} from 'shared/ReactFeatureFlags'; +import {enableRenderableContext} from 'shared/ReactFeatureFlags'; import {getHostTransitionProvider} from './ReactFiberHostContext'; const valueCursor: StackCursor = createCursor(null); @@ -210,157 +194,16 @@ export function propagateContextChange( context: ReactContext, renderLanes: Lanes, ): void { - if (enableLazyContextPropagation) { - // TODO: This path is only used by Cache components. Update - // lazilyPropagateParentContextChanges to look for Cache components so they - // can take advantage of lazy propagation. - const forcePropagateEntireTree = true; - propagateContextChanges( - workInProgress, - [context], - renderLanes, - forcePropagateEntireTree, - ); - } else { - propagateContextChange_eager(workInProgress, context, renderLanes); - } -} - -function propagateContextChange_eager( - workInProgress: Fiber, - context: ReactContext, - renderLanes: Lanes, -): void { - // Only used by eager implementation - if (enableLazyContextPropagation) { - return; - } - let fiber = workInProgress.child; - if (fiber !== null) { - // Set the return pointer of the child to the work-in-progress fiber. - fiber.return = workInProgress; - } - while (fiber !== null) { - let nextFiber; - - // Visit this fiber. - const list = fiber.dependencies; - if (list !== null) { - nextFiber = fiber.child; - - let dependency = list.firstContext; - while (dependency !== null) { - // Check if the context matches. - if (dependency.context === context) { - // Match! Schedule an update on this fiber. - if (fiber.tag === ClassComponent) { - // Schedule a force update on the work-in-progress. - const lane = pickArbitraryLane(renderLanes); - const update = createUpdate(lane); - update.tag = ForceUpdate; - // TODO: Because we don't have a work-in-progress, this will add the - // update to the current fiber, too, which means it will persist even if - // this render is thrown away. Since it's a race condition, not sure it's - // worth fixing. - - // Inlined `enqueueUpdate` to remove interleaved update check - const updateQueue = fiber.updateQueue; - if (updateQueue === null) { - // Only occurs if the fiber has been unmounted. - } else { - const sharedQueue: SharedQueue = (updateQueue: any).shared; - const pending = sharedQueue.pending; - if (pending === null) { - // This is the first update. Create a circular list. - update.next = update; - } else { - update.next = pending.next; - pending.next = update; - } - sharedQueue.pending = update; - } - } - - fiber.lanes = mergeLanes(fiber.lanes, renderLanes); - const alternate = fiber.alternate; - if (alternate !== null) { - alternate.lanes = mergeLanes(alternate.lanes, renderLanes); - } - scheduleContextWorkOnParentPath( - fiber.return, - renderLanes, - workInProgress, - ); - - // Mark the updated lanes on the list, too. - list.lanes = mergeLanes(list.lanes, renderLanes); - - // Since we already found a match, we can stop traversing the - // dependency list. - break; - } - dependency = dependency.next; - } - } else if (fiber.tag === ContextProvider) { - // Don't scan deeper if this is a matching provider - nextFiber = fiber.type === workInProgress.type ? null : fiber.child; - } else if (fiber.tag === DehydratedFragment) { - // If a dehydrated suspense boundary is in this subtree, we don't know - // if it will have any context consumers in it. The best we can do is - // mark it as having updates. - const parentSuspense = fiber.return; - - if (parentSuspense === null) { - throw new Error( - 'We just came from a parent so we must have had a parent. This is a bug in React.', - ); - } - - parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes); - const alternate = parentSuspense.alternate; - if (alternate !== null) { - alternate.lanes = mergeLanes(alternate.lanes, renderLanes); - } - // This is intentionally passing this fiber as the parent - // because we want to schedule this fiber as having work - // on its children. We'll use the childLanes on - // this fiber to indicate that a context has changed. - scheduleContextWorkOnParentPath( - parentSuspense, - renderLanes, - workInProgress, - ); - nextFiber = fiber.sibling; - } else { - // Traverse down. - nextFiber = fiber.child; - } - - if (nextFiber !== null) { - // Set the return pointer of the child to the work-in-progress fiber. - nextFiber.return = fiber; - } else { - // No child. Traverse to next sibling. - nextFiber = fiber; - while (nextFiber !== null) { - if (nextFiber === workInProgress) { - // We're back to the root of this subtree. Exit. - nextFiber = null; - break; - } - const sibling = nextFiber.sibling; - if (sibling !== null) { - // Set the return pointer of the sibling to the work-in-progress fiber. - sibling.return = nextFiber.return; - nextFiber = sibling; - break; - } - // No more siblings. Traverse up. - nextFiber = nextFiber.return; - } - } - fiber = nextFiber; - } + // TODO: This path is only used by Cache components. Update + // lazilyPropagateParentContextChanges to look for Cache components so they + // can take advantage of lazy propagation. + const forcePropagateEntireTree = true; + propagateContextChanges( + workInProgress, + [context], + renderLanes, + forcePropagateEntireTree, + ); } function propagateContextChanges( @@ -369,10 +212,6 @@ function propagateContextChanges( renderLanes: Lanes, forcePropagateEntireTree: boolean, ): void { - // Only used by lazy implementation - if (!enableLazyContextPropagation) { - return; - } let fiber = workInProgress.child; if (fiber !== null) { // Set the return pointer of the child to the work-in-progress fiber. @@ -527,10 +366,6 @@ function propagateParentContextChanges( renderLanes: Lanes, forcePropagateEntireTree: boolean, ) { - if (!enableLazyContextPropagation) { - return; - } - // Collect all the parent providers that changed. Since this is usually small // number, we use an Array instead of Set. let contexts = null; @@ -637,9 +472,6 @@ function propagateParentContextChanges( export function checkIfContextChanged( currentDependencies: Dependencies, ): boolean { - if (!enableLazyContextPropagation) { - return false; - } // Iterate over the current dependencies to see if something changed. This // only gets called if props and state has already bailed out, so it's a // relatively uncommon path, except at the root of a changed subtree. @@ -669,20 +501,8 @@ export function prepareToReadContext( const dependencies = workInProgress.dependencies; if (dependencies !== null) { - if (enableLazyContextPropagation) { - // Reset the work-in-progress list - dependencies.firstContext = null; - } else { - const firstContext = dependencies.firstContext; - if (firstContext !== null) { - if (includesSomeLane(dependencies.lanes, renderLanes)) { - // Context list has a pending update. Mark that this fiber performed work. - markWorkInProgressReceivedUpdate(); - } - // Reset the work-in-progress list - dependencies.firstContext = null; - } - } + // Reset the work-in-progress list + dependencies.firstContext = null; } } @@ -749,9 +569,7 @@ function readContextForConsumer( lanes: NoLanes, firstContext: contextItem, }; - if (enableLazyContextPropagation) { - consumer.flags |= NeedsPropagation; - } + consumer.flags |= NeedsPropagation; } else { // Append a new context item. lastContextDependency = lastContextDependency.next = contextItem; diff --git a/packages/react-reconciler/src/ReactFiberThrow.js b/packages/react-reconciler/src/ReactFiberThrow.js index a4bdb84e6c4e7..a777331699082 100644 --- a/packages/react-reconciler/src/ReactFiberThrow.js +++ b/packages/react-reconciler/src/ReactFiberThrow.js @@ -39,7 +39,6 @@ import { } from './ReactFiberFlags'; import {NoMode, ConcurrentMode} from './ReactTypeOfMode'; import { - enableLazyContextPropagation, enableUpdaterTracking, enablePostpone, disableLegacyMode, @@ -199,21 +198,19 @@ function initializeClassErrorUpdate( } function resetSuspendedComponent(sourceFiber: Fiber, rootRenderLanes: Lanes) { - if (enableLazyContextPropagation) { - const currentSourceFiber = sourceFiber.alternate; - if (currentSourceFiber !== null) { - // Since we never visited the children of the suspended component, we - // need to propagate the context change now, to ensure that we visit - // them during the retry. - // - // We don't have to do this for errors because we retry errors without - // committing in between. So this is specific to Suspense. - propagateParentContextChangesToDeferredTree( - currentSourceFiber, - sourceFiber, - rootRenderLanes, - ); - } + const currentSourceFiber = sourceFiber.alternate; + if (currentSourceFiber !== null) { + // Since we never visited the children of the suspended component, we + // need to propagate the context change now, to ensure that we visit + // them during the retry. + // + // We don't have to do this for errors because we retry errors without + // committing in between. So this is specific to Suspense. + propagateParentContextChangesToDeferredTree( + currentSourceFiber, + sourceFiber, + rootRenderLanes, + ); } // Reset the memoizedState to what it was before we attempted to render it. diff --git a/packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js b/packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js index 340e973b2f0b3..019119edf7ce8 100644 --- a/packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js +++ b/packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js @@ -35,11 +35,6 @@ describe('ReactLazyContextPropagation', () => { seededCache = null; }); - // NOTE: These tests are not specific to the lazy propagation (as opposed to - // eager propagation). The behavior should be the same in both - // implementations. These are tests that are more relevant to the lazy - // propagation implementation, though. - function createTextCache() { if (seededCache !== null) { // Trick to seed a cache before it exists. diff --git a/packages/react/src/__tests__/ReactContextValidator-test.js b/packages/react/src/__tests__/ReactContextValidator-test.js index 3f24e5bed8d18..359857af15c61 100644 --- a/packages/react/src/__tests__/ReactContextValidator-test.js +++ b/packages/react/src/__tests__/ReactContextValidator-test.js @@ -350,13 +350,7 @@ describe('ReactContextValidator', () => { expect(componentWillUpdateNextContext).toBe(secondContext); expect(renderContext).toBe(secondContext); expect(componentDidUpdateContext).toBe(secondContext); - - if (gate(flags => flags.enableLazyContextPropagation)) { - expect(shouldComponentUpdateWasCalled).toBe(true); - } else { - // sCU is not called in this case because React force updates when a provider re-renders - expect(shouldComponentUpdateWasCalled).toBe(false); - } + expect(shouldComponentUpdateWasCalled).toBe(true); }); it('should re-render PureComponents when context Provider updates', async () => { diff --git a/packages/shared/ReactFeatureFlags.js b/packages/shared/ReactFeatureFlags.js index 8caf79fbf285d..fff1dcf4d9ddb 100644 --- a/packages/shared/ReactFeatureFlags.js +++ b/packages/shared/ReactFeatureFlags.js @@ -99,8 +99,6 @@ export const enableObjectFiber = false; export const enableTransitionTracing = false; -export const enableLazyContextPropagation = true; - // FB-only usage. The new API has different semantics. export const enableLegacyHidden = false; diff --git a/packages/shared/forks/ReactFeatureFlags.native-fb.js b/packages/shared/forks/ReactFeatureFlags.native-fb.js index 6c14a9ece37a0..2e37d9aeee5f1 100644 --- a/packages/shared/forks/ReactFeatureFlags.native-fb.js +++ b/packages/shared/forks/ReactFeatureFlags.native-fb.js @@ -53,7 +53,6 @@ export const enableFizzExternalRuntime = true; export const enableGetInspectorDataForInstanceInProduction = true; export const enableHalt = false; export const enableInfiniteRenderLoopDetection = false; -export const enableLazyContextPropagation = true; export const enableLegacyCache = false; export const enableLegacyFBSupport = false; export const enableLegacyHidden = false; diff --git a/packages/shared/forks/ReactFeatureFlags.native-oss.js b/packages/shared/forks/ReactFeatureFlags.native-oss.js index 6dce24e57fcd7..6c86d9f60d405 100644 --- a/packages/shared/forks/ReactFeatureFlags.native-oss.js +++ b/packages/shared/forks/ReactFeatureFlags.native-oss.js @@ -42,7 +42,6 @@ export const enableGetInspectorDataForInstanceInProduction = false; export const enableHalt = false; export const enableHiddenSubtreeInsertionEffectCleanup = false; export const enableInfiniteRenderLoopDetection = false; -export const enableLazyContextPropagation = true; export const enableLegacyCache = false; export const enableLegacyFBSupport = false; export const enableLegacyHidden = false; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.js index 53057d78d7390..6ba73ae150413 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.js @@ -48,7 +48,6 @@ export const syncLaneExpirationMs = 250; export const transitionLaneExpirationMs = 5000; export const disableSchedulerTimeoutInWorkLoop = false; -export const enableLazyContextPropagation = true; export const enableLegacyHidden = false; export const enableTransitionTracing = false; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js index 66e4329cb829d..14e351fb2f078 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js @@ -32,8 +32,6 @@ export const enableFizzExternalRuntime = true; export const enableGetInspectorDataForInstanceInProduction = false; export const enableHalt = false; export const enableInfiniteRenderLoopDetection = false; -export const enableLazyContextPropagation = true; -export const enableContextProfiling = false; export const enableHiddenSubtreeInsertionEffectCleanup = true; export const enableLegacyCache = false; export const enableLegacyFBSupport = false; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js index b71ff7a266b4a..91eab54c310a4 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js @@ -50,7 +50,6 @@ export const syncLaneExpirationMs = 250; export const transitionLaneExpirationMs = 5000; export const disableSchedulerTimeoutInWorkLoop = false; -export const enableLazyContextPropagation = true; export const enableLegacyHidden = false; export const enableTransitionTracing = false; diff --git a/packages/shared/forks/ReactFeatureFlags.www.js b/packages/shared/forks/ReactFeatureFlags.www.js index 8054a14bbc8a6..a0efa66cb348b 100644 --- a/packages/shared/forks/ReactFeatureFlags.www.js +++ b/packages/shared/forks/ReactFeatureFlags.www.js @@ -56,7 +56,6 @@ export const enableUseEffectEventHook = true; export const enableMoveBefore = false; export const disableInputAttributeSyncing = false; export const enableLegacyFBSupport = true; -export const enableLazyContextPropagation = true; export const enableHydrationLaneScheduling = true;