From 3e1029b2f323250be2acf1a438c1f445c99451ce Mon Sep 17 00:00:00 2001 From: Jack Pope Date: Tue, 23 Jul 2024 15:24:12 -0400 Subject: [PATCH 1/4] Remove forceConcurrentByDefaultForTesting flag --- .../react-art/src/__tests__/ReactART-test.js | 52 -------- .../ReactDOMNativeEventHeuristic-test.js | 6 +- ...DOMServerPartialHydration-test.internal.js | 9 +- packages/react-reconciler/src/ReactFiber.js | 10 +- .../src/__tests__/ReactExpiration-test.js | 124 ++++++------------ .../ReactHooksWithNoopRenderer-test.js | 48 +++---- .../__tests__/ReactInterleavedUpdates-test.js | 55 -------- .../__tests__/ReactSuspense-test.internal.js | 68 ---------- .../ReactSuspenseWithNoopRenderer-test.js | 21 +-- .../src/__tests__/ReactUse-test.js | 2 - packages/shared/ReactFeatureFlags.js | 3 - .../forks/ReactFeatureFlags.native-fb.js | 1 - .../forks/ReactFeatureFlags.native-oss.js | 1 - .../forks/ReactFeatureFlags.test-renderer.js | 1 - ...actFeatureFlags.test-renderer.native-fb.js | 1 - .../ReactFeatureFlags.test-renderer.www.js | 1 - .../forks/ReactFeatureFlags.www-dynamic.js | 1 - .../shared/forks/ReactFeatureFlags.www.js | 2 - scripts/jest/setupTests.www.js | 3 - 19 files changed, 68 insertions(+), 341 deletions(-) diff --git a/packages/react-art/src/__tests__/ReactART-test.js b/packages/react-art/src/__tests__/ReactART-test.js index 15c01e8e89721..b62977b3236c5 100644 --- a/packages/react-art/src/__tests__/ReactART-test.js +++ b/packages/react-art/src/__tests__/ReactART-test.js @@ -397,58 +397,6 @@ describe('ReactART', () => { doClick(instance); expect(onClick2).toBeCalled(); }); - - // @gate forceConcurrentByDefaultForTesting - it('can concurrently render with a "primary" renderer while sharing context', async () => { - const CurrentRendererContext = React.createContext(null); - - function Yield(props) { - Scheduler.log(props.value); - return null; - } - - let ops = []; - function LogCurrentRenderer() { - return ( - - {currentRenderer => { - ops.push(currentRenderer); - return null; - }} - - ); - } - - ReactNoop.render( - - - - - - , - ); - - await waitFor(['A']); - - const root = ReactDOMClient.createRoot(container); - // We use flush sync here because we expect this to render in between - // while the concurrent render is yieldy where as act would flush both. - ReactDOM.flushSync(() => { - root.render( - - - - - - , - ); - }); - - ops = []; - await waitFor(['B', 'C']); - - expect(ops).toEqual(['Test']); - }); }); describe('ReactARTComponents', () => { diff --git a/packages/react-dom/src/__tests__/ReactDOMNativeEventHeuristic-test.js b/packages/react-dom/src/__tests__/ReactDOMNativeEventHeuristic-test.js index 13b754ecf050f..fe332a9d3cab0 100644 --- a/packages/react-dom/src/__tests__/ReactDOMNativeEventHeuristic-test.js +++ b/packages/react-dom/src/__tests__/ReactDOMNativeEventHeuristic-test.js @@ -313,11 +313,7 @@ describe('ReactDOMNativeEventHeuristic-test', () => { expect(container.textContent).toEqual('not hovered'); await waitFor(['hovered']); - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - expect(container.textContent).toEqual('not hovered'); - } else { - expect(container.textContent).toEqual('hovered'); - } + expect(container.textContent).toEqual('hovered'); }); expect(container.textContent).toEqual('hovered'); }); diff --git a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js index 36f7c95ba6531..e9354b0bf259d 100644 --- a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js +++ b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js @@ -2551,14 +2551,7 @@ describe('ReactDOMServerPartialHydration', () => { suspend = true; await act(async () => { - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - await waitFor(['Before']); - // This took a long time to render. - Scheduler.unstable_advanceTime(1000); - await waitFor(['After']); - } else { - await waitFor(['Before', 'After']); - } + await waitFor(['Before', 'After']); // This will cause us to skip the second row completely. }); diff --git a/packages/react-reconciler/src/ReactFiber.js b/packages/react-reconciler/src/ReactFiber.js index a72921e4753fd..2b18089be99da 100644 --- a/packages/react-reconciler/src/ReactFiber.js +++ b/packages/react-reconciler/src/ReactFiber.js @@ -31,7 +31,6 @@ import { enableProfilerTimer, enableScopeAPI, enableLegacyHidden, - forceConcurrentByDefaultForTesting, allowConcurrentByDefault, enableTransitionTracing, enableDebugTracing, @@ -534,11 +533,6 @@ export function createHostRootFiber( mode |= StrictLegacyMode | StrictEffectsMode; } if ( - // We only use this flag for our repo tests to check both behaviors. - forceConcurrentByDefaultForTesting - ) { - mode |= ConcurrentUpdatesByDefaultMode; - } else if ( // Only for internal experiments. allowConcurrentByDefault && concurrentUpdatesByDefaultOverride @@ -588,8 +582,8 @@ export function createFiberFromTypeAndProps( fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) - ? HostSingleton - : HostComponent; + ? HostSingleton + : HostComponent; } else if (supportsResources) { const hostContext = getHostContext(); fiberTag = isHostHoistableType(type, pendingProps, hostContext) diff --git a/packages/react-reconciler/src/__tests__/ReactExpiration-test.js b/packages/react-reconciler/src/__tests__/ReactExpiration-test.js index cd09ca347885b..24dcf838a650b 100644 --- a/packages/react-reconciler/src/__tests__/ReactExpiration-test.js +++ b/packages/react-reconciler/src/__tests__/ReactExpiration-test.js @@ -125,44 +125,27 @@ describe('ReactExpiration', () => { } it('increases priority of updates as time progresses', async () => { - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - ReactNoop.render(); - expect(ReactNoop).toMatchRenderedOutput(null); - - // Nothing has expired yet because time hasn't advanced. - flushNextRenderIfExpired(); - expect(ReactNoop).toMatchRenderedOutput(null); - // Advance time a bit, but not enough to expire the low pri update. - ReactNoop.expire(4500); - flushNextRenderIfExpired(); - expect(ReactNoop).toMatchRenderedOutput(null); - // Advance by another second. Now the update should expire and flush. - ReactNoop.expire(500); - flushNextRenderIfExpired(); - expect(ReactNoop).toMatchRenderedOutput(); - } else { - ReactNoop.render(); - React.startTransition(() => { - ReactNoop.render(); - }); - await waitFor(['Step 1']); + ReactNoop.render(); + React.startTransition(() => { + ReactNoop.render(); + }); + await waitFor(['Step 1']); - expect(ReactNoop).toMatchRenderedOutput('Step 1'); + expect(ReactNoop).toMatchRenderedOutput('Step 1'); - // Nothing has expired yet because time hasn't advanced. - await unstable_waitForExpired([]); - expect(ReactNoop).toMatchRenderedOutput('Step 1'); + // Nothing has expired yet because time hasn't advanced. + await unstable_waitForExpired([]); + expect(ReactNoop).toMatchRenderedOutput('Step 1'); - // Advance time a bit, but not enough to expire the low pri update. - ReactNoop.expire(4500); - await unstable_waitForExpired([]); - expect(ReactNoop).toMatchRenderedOutput('Step 1'); + // Advance time a bit, but not enough to expire the low pri update. + ReactNoop.expire(4500); + await unstable_waitForExpired([]); + expect(ReactNoop).toMatchRenderedOutput('Step 1'); - // Advance by a little bit more. Now the update should expire and flush. - ReactNoop.expire(500); - await unstable_waitForExpired(['Step 2']); - expect(ReactNoop).toMatchRenderedOutput('Step 2'); - } + // Advance by a little bit more. Now the update should expire and flush. + ReactNoop.expire(500); + await unstable_waitForExpired(['Step 2']); + expect(ReactNoop).toMatchRenderedOutput('Step 2'); }); it('two updates of like priority in the same event always flush within the same batch', async () => { @@ -408,57 +391,36 @@ describe('ReactExpiration', () => { jest.resetModules(); Scheduler = require('scheduler'); - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - // Before importing the renderer, advance the current time by a number - // larger than the maximum allowed for bitwise operations. - const maxSigned31BitInt = 1073741823; - Scheduler.unstable_advanceTime(maxSigned31BitInt * 100); - // Now import the renderer. On module initialization, it will read the - // current time. - ReactNoop = require('react-noop-renderer'); - ReactNoop.render('Hi'); + const InternalTestUtils = require('internal-test-utils'); + waitFor = InternalTestUtils.waitFor; + assertLog = InternalTestUtils.assertLog; + unstable_waitForExpired = InternalTestUtils.unstable_waitForExpired; - // The update should not have expired yet. - flushNextRenderIfExpired(); - await waitFor([]); - expect(ReactNoop).toMatchRenderedOutput(null); - // Advance the time some more to expire the update. - Scheduler.unstable_advanceTime(10000); - flushNextRenderIfExpired(); - await waitFor([]); - expect(ReactNoop).toMatchRenderedOutput('Hi'); - } else { - const InternalTestUtils = require('internal-test-utils'); - waitFor = InternalTestUtils.waitFor; - assertLog = InternalTestUtils.assertLog; - unstable_waitForExpired = InternalTestUtils.unstable_waitForExpired; - - // Before importing the renderer, advance the current time by a number - // larger than the maximum allowed for bitwise operations. - const maxSigned31BitInt = 1073741823; - Scheduler.unstable_advanceTime(maxSigned31BitInt * 100); - - // Now import the renderer. On module initialization, it will read the - // current time. - ReactNoop = require('react-noop-renderer'); - React = require('react'); - - ReactNoop.render(); - React.startTransition(() => { - ReactNoop.render(); - }); - await waitFor(['Step 1']); + // Before importing the renderer, advance the current time by a number + // larger than the maximum allowed for bitwise operations. + const maxSigned31BitInt = 1073741823; + Scheduler.unstable_advanceTime(maxSigned31BitInt * 100); - // The update should not have expired yet. - await unstable_waitForExpired([]); + // Now import the renderer. On module initialization, it will read the + // current time. + ReactNoop = require('react-noop-renderer'); + React = require('react'); - expect(ReactNoop).toMatchRenderedOutput('Step 1'); + ReactNoop.render(); + React.startTransition(() => { + ReactNoop.render(); + }); + await waitFor(['Step 1']); - // Advance the time some more to expire the update. - Scheduler.unstable_advanceTime(10000); - await unstable_waitForExpired(['Step 2']); - expect(ReactNoop).toMatchRenderedOutput('Step 2'); - } + // The update should not have expired yet. + await unstable_waitForExpired([]); + + expect(ReactNoop).toMatchRenderedOutput('Step 1'); + + // Advance the time some more to expire the update. + Scheduler.unstable_advanceTime(10000); + await unstable_waitForExpired(['Step 2']); + expect(ReactNoop).toMatchRenderedOutput('Step 2'); }); it('should measure callback timeout relative to current time, not start-up time', async () => { diff --git a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js index 14e01dd502db6..452163e4e4b63 100644 --- a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js +++ b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js @@ -1540,39 +1540,21 @@ describe('ReactHooksWithNoopRenderer', () => { expect(ReactNoop).toMatchRenderedOutput(); // Rendering again should flush the previous commit's effects - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { + React.startTransition(() => { ReactNoop.render(, () => Scheduler.log('Sync effect'), ); - } else { - React.startTransition(() => { - ReactNoop.render(, () => - Scheduler.log('Sync effect'), - ); - }); - } + }); await waitFor(['Schedule update [0]', 'Count: 0']); - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - expect(ReactNoop).toMatchRenderedOutput( - , - ); - await waitFor(['Sync effect']); - expect(ReactNoop).toMatchRenderedOutput(); - - ReactNoop.flushPassiveEffects(); - assertLog(['Schedule update [1]']); - await waitForAll(['Count: 1']); - } else { - expect(ReactNoop).toMatchRenderedOutput(); - await waitFor([ - 'Count: 0', - 'Sync effect', - 'Schedule update [1]', - 'Count: 1', - ]); - } + expect(ReactNoop).toMatchRenderedOutput(); + await waitFor([ + 'Count: 0', + 'Sync effect', + 'Schedule update [1]', + 'Count: 1', + ]); expect(ReactNoop).toMatchRenderedOutput(); }); @@ -3446,10 +3428,14 @@ describe('ReactHooksWithNoopRenderer', () => { let totalRefUpdates = 0; function Counter(props, ref) { const [count, dispatch] = useReducer(reducer, 0); - useImperativeHandle(ref, () => { - totalRefUpdates++; - return {count, dispatch}; - }, [count]); + useImperativeHandle( + ref, + () => { + totalRefUpdates++; + return {count, dispatch}; + }, + [count], + ); return ; } diff --git a/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js b/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js index e8b40f63ab7ab..f40004b9eaf34 100644 --- a/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js +++ b/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js @@ -86,61 +86,6 @@ describe('ReactInterleavedUpdates', () => { expect(root).toMatchRenderedOutput('222'); }); - // @gate forceConcurrentByDefaultForTesting - it('low priority update during an interleaved event is not processed during the current render', async () => { - // Same as previous test, but the interleaved update is lower priority than - // the in-progress render. - const updaters = []; - - function Child() { - const [state, setState] = useState(0); - useEffect(() => { - updaters.push(setState); - }, []); - return ; - } - - function updateChildren(value) { - for (let i = 0; i < updaters.length; i++) { - const setState = updaters[i]; - setState(value); - } - } - - const root = ReactNoop.createRoot(); - - await act(async () => { - root.render( - <> - - - - , - ); - }); - assertLog([0, 0, 0]); - expect(root).toMatchRenderedOutput('000'); - - await act(async () => { - updateChildren(1); - // Partially render the children. Only the first one. - await waitFor([1]); - - // In an interleaved event, schedule an update on each of the children. - // Including the two that haven't rendered yet. - startTransition(() => { - updateChildren(2); - }); - - // We should continue rendering without including the interleaved updates. - await waitForPaint([1, 1]); - expect(root).toMatchRenderedOutput('111'); - }); - // The interleaved updates flush in a separate render. - assertLog([2, 2, 2]); - expect(root).toMatchRenderedOutput('222'); - }); - it('regression for #24350: does not add to main update queue until interleaved update queue has been cleared', async () => { let setStep; function App() { diff --git a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js index 8e1ba771a7dd5..88c6e38160eea 100644 --- a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js +++ b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js @@ -378,74 +378,6 @@ describe('ReactSuspense', () => { expect(container.textContent).toEqual('AB'); }); - // @gate !disableLegacyMode && forceConcurrentByDefaultForTesting - it( - 'interrupts current render when something suspends with a ' + - "delay and we've already skipped over a lower priority update in " + - 'a parent', - async () => { - const root = ReactDOMClient.createRoot(container); - - function interrupt() { - // React has a heuristic to batch all updates that occur within the same - // event. This is a trick to circumvent that heuristic. - ReactDOM.render('whatever', document.createElement('div')); - } - - function App({shouldSuspend, step}) { - return ( - <> - - }> - {shouldSuspend ? : null} - - - - - ); - } - - root.render(); - await waitForAll(['A0', 'B0', 'C0']); - expect(container.textContent).toEqual('A0B0C0'); - - // This update will suspend. - root.render(); - - // Do a bit of work - await waitFor(['A1']); - - // Schedule another update. This will have lower priority because it's - // a transition. - React.startTransition(() => { - root.render(); - }); - - // Interrupt to trigger a restart. - interrupt(); - - await waitFor([ - // Should have restarted the first update, because of the interruption - 'A1', - 'Suspend! [Async]', - 'Loading...', - 'B1', - ]); - - // Should not have committed loading state - expect(container.textContent).toEqual('A0B0C0'); - - // After suspending, should abort the first update and switch to the - // second update. So, C1 should not appear in the log. - // TODO: This should work even if React does not yield to the main - // thread. Should use same mechanism as selective hydration to interrupt - // the render before the end of the current slice of work. - await waitForAll(['A2', 'B2', 'C2']); - - expect(container.textContent).toEqual('A2B2C2'); - }, - ); - // @gate !disableLegacyMode it('mounts a lazy class component in non-concurrent mode (legacy)', async () => { class Class extends React.Component { diff --git a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js index 3249a42368f6a..a0b0670726de2 100644 --- a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js +++ b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js @@ -2234,27 +2234,14 @@ describe('ReactSuspenseWithNoopRenderer', () => { await waitForAll(['Foo', 'A']); expect(ReactNoop).toMatchRenderedOutput(); - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { + React.startTransition(() => { ReactNoop.render(); - } else { - React.startTransition(() => { - ReactNoop.render(); - }); - } + }); await waitForAll(['Foo', 'A', 'Suspend! [B]', 'Loading B...']); - if (gate(flags => flags.forceConcurrentByDefaultForTesting)) { - expect(ReactNoop).toMatchRenderedOutput( - <> - - - , - ); - } else { - // Transitions never fall back. - expect(ReactNoop).toMatchRenderedOutput(); - } + // Transitions never fall back. + expect(ReactNoop).toMatchRenderedOutput(); }); // @gate enableLegacyCache diff --git a/packages/react-reconciler/src/__tests__/ReactUse-test.js b/packages/react-reconciler/src/__tests__/ReactUse-test.js index f648f76aefe53..1dae8a56dd25f 100644 --- a/packages/react-reconciler/src/__tests__/ReactUse-test.js +++ b/packages/react-reconciler/src/__tests__/ReactUse-test.js @@ -1656,7 +1656,6 @@ describe('ReactUse', () => { expect(root).toMatchRenderedOutput('C'); }); - // @gate !forceConcurrentByDefaultForTesting it('an async component outside of a Suspense boundary crashes with an error (resolves in microtask)', async () => { class ErrorBoundary extends React.Component { state = {error: null}; @@ -1708,7 +1707,6 @@ describe('ReactUse', () => { ); }); - // @gate !forceConcurrentByDefaultForTesting it('an async component outside of a Suspense boundary crashes with an error (resolves in macrotask)', async () => { class ErrorBoundary extends React.Component { state = {error: null}; diff --git a/packages/shared/ReactFeatureFlags.js b/packages/shared/ReactFeatureFlags.js index 2e7c9ffea4952..2e3ffd81191c8 100644 --- a/packages/shared/ReactFeatureFlags.js +++ b/packages/shared/ReactFeatureFlags.js @@ -217,9 +217,6 @@ export const enableUseDeferredValueInitialArg = true; // when we plan to enable them. // ----------------------------------------------------------------------------- -// Enables time slicing for updates that aren't wrapped in startTransition. -export const forceConcurrentByDefaultForTesting = false; - // Adds an opt-in to time slicing for updates that aren't wrapped in startTransition. export const allowConcurrentByDefault = false; diff --git a/packages/shared/forks/ReactFeatureFlags.native-fb.js b/packages/shared/forks/ReactFeatureFlags.native-fb.js index 8a5f784ea943f..0e00c97a1aae8 100644 --- a/packages/shared/forks/ReactFeatureFlags.native-fb.js +++ b/packages/shared/forks/ReactFeatureFlags.native-fb.js @@ -85,7 +85,6 @@ export const enableUseDeferredValueInitialArg = true; export const enableUseEffectEventHook = false; export const enableUseMemoCacheHook = true; export const favorSafetyOverHydrationPerf = true; -export const forceConcurrentByDefaultForTesting = false; export const renameElementSymbol = false; export const retryLaneExpirationMs = 5000; export const syncLaneExpirationMs = 250; diff --git a/packages/shared/forks/ReactFeatureFlags.native-oss.js b/packages/shared/forks/ReactFeatureFlags.native-oss.js index e1780bf019faa..ce2bc8251cb1a 100644 --- a/packages/shared/forks/ReactFeatureFlags.native-oss.js +++ b/packages/shared/forks/ReactFeatureFlags.native-oss.js @@ -76,7 +76,6 @@ export const enableUseDeferredValueInitialArg = true; export const enableUseEffectEventHook = false; export const enableUseMemoCacheHook = true; export const favorSafetyOverHydrationPerf = true; -export const forceConcurrentByDefaultForTesting = false; export const passChildrenWhenCloningPersistedNodes = false; export const renameElementSymbol = true; export const retryLaneExpirationMs = 5000; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.js index 4208674d503be..310a64ba778e7 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.js @@ -53,7 +53,6 @@ export const transitionLaneExpirationMs = 5000; export const disableSchedulerTimeoutInWorkLoop = false; export const enableLazyContextPropagation = false; export const enableLegacyHidden = false; -export const forceConcurrentByDefaultForTesting = false; export const allowConcurrentByDefault = false; export const consoleManagedByDevToolsDuringStrictMode = false; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js index f23cdfe8136d3..4b3ceb37bdf48 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js @@ -72,7 +72,6 @@ export const enableUseDeferredValueInitialArg = true; export const enableUseEffectEventHook = false; export const enableUseMemoCacheHook = true; export const favorSafetyOverHydrationPerf = true; -export const forceConcurrentByDefaultForTesting = false; export const passChildrenWhenCloningPersistedNodes = false; export const renameElementSymbol = false; export const retryLaneExpirationMs = 5000; diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js index 1364d2b81abb0..8c487e27c8239 100644 --- a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js +++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js @@ -56,7 +56,6 @@ export const transitionLaneExpirationMs = 5000; export const disableSchedulerTimeoutInWorkLoop = false; export const enableLazyContextPropagation = false; export const enableLegacyHidden = false; -export const forceConcurrentByDefaultForTesting = false; export const allowConcurrentByDefault = true; export const consoleManagedByDevToolsDuringStrictMode = false; diff --git a/packages/shared/forks/ReactFeatureFlags.www-dynamic.js b/packages/shared/forks/ReactFeatureFlags.www-dynamic.js index 49814e0d9d6e4..faf87deb6e0ab 100644 --- a/packages/shared/forks/ReactFeatureFlags.www-dynamic.js +++ b/packages/shared/forks/ReactFeatureFlags.www-dynamic.js @@ -29,7 +29,6 @@ export const enableRetryLaneExpiration = __VARIANT__; export const enableTransitionTracing = __VARIANT__; export const enableUseDeferredValueInitialArg = __VARIANT__; export const favorSafetyOverHydrationPerf = __VARIANT__; -export const forceConcurrentByDefaultForTesting = __VARIANT__; export const renameElementSymbol = __VARIANT__; export const retryLaneExpirationMs = 5000; export const syncLaneExpirationMs = 250; diff --git a/packages/shared/forks/ReactFeatureFlags.www.js b/packages/shared/forks/ReactFeatureFlags.www.js index ef118515c0cff..02726ce6b24c5 100644 --- a/packages/shared/forks/ReactFeatureFlags.www.js +++ b/packages/shared/forks/ReactFeatureFlags.www.js @@ -102,8 +102,6 @@ export const consoleManagedByDevToolsDuringStrictMode = true; export const enableFizzExternalRuntime = true; -export const forceConcurrentByDefaultForTesting = false; - export const passChildrenWhenCloningPersistedNodes = false; export const enableAsyncDebugInfo = false; diff --git a/scripts/jest/setupTests.www.js b/scripts/jest/setupTests.www.js index 485f1b80b683f..ba0ee287fd4bd 100644 --- a/scripts/jest/setupTests.www.js +++ b/scripts/jest/setupTests.www.js @@ -8,9 +8,6 @@ jest.mock('shared/ReactFeatureFlags', () => { ); const actual = jest.requireActual('shared/forks/ReactFeatureFlags.www'); - // This flag is only used by tests, it should never be set elsewhere. - actual.forceConcurrentByDefaultForTesting = !__VARIANT__; - // Flags that aren't currently used, but we still want to force variants to keep the // code live. actual.disableInputAttributeSyncing = __VARIANT__; From fff01acda1d7f41651ad23168f1c4c2b79a6d985 Mon Sep 17 00:00:00 2001 From: Jack Pope Date: Tue, 23 Jul 2024 17:05:19 -0400 Subject: [PATCH 2/4] lint fixes --- packages/react-art/src/__tests__/ReactART-test.js | 10 +--------- .../src/__tests__/ReactExpiration-test.js | 9 --------- 2 files changed, 1 insertion(+), 18 deletions(-) diff --git a/packages/react-art/src/__tests__/ReactART-test.js b/packages/react-art/src/__tests__/ReactART-test.js index b62977b3236c5..6658cde5f6634 100644 --- a/packages/react-art/src/__tests__/ReactART-test.js +++ b/packages/react-art/src/__tests__/ReactART-test.js @@ -23,23 +23,15 @@ import Circle from 'react-art/Circle'; import Rectangle from 'react-art/Rectangle'; import Wedge from 'react-art/Wedge'; -const {act, waitFor} = require('internal-test-utils'); +const {act} = require('internal-test-utils'); // Isolate DOM renderer. jest.resetModules(); // share isomorphic jest.mock('scheduler', () => Scheduler); jest.mock('react', () => React); -const ReactDOM = require('react-dom'); const ReactDOMClient = require('react-dom/client'); -// Isolate the noop renderer -jest.resetModules(); -// share isomorphic -jest.mock('scheduler', () => Scheduler); -jest.mock('react', () => React); -const ReactNoop = require('react-noop-renderer'); - let Group; let Shape; let Surface; diff --git a/packages/react-reconciler/src/__tests__/ReactExpiration-test.js b/packages/react-reconciler/src/__tests__/ReactExpiration-test.js index 24dcf838a650b..1d659cae3c3bf 100644 --- a/packages/react-reconciler/src/__tests__/ReactExpiration-test.js +++ b/packages/react-reconciler/src/__tests__/ReactExpiration-test.js @@ -115,15 +115,6 @@ describe('ReactExpiration', () => { } } - function flushNextRenderIfExpired() { - // This will start rendering the next level of work. If the work hasn't - // expired yet, React will exit without doing anything. If it has expired, - // it will schedule a sync task. - Scheduler.unstable_flushExpired(); - // Flush the sync task. - ReactNoop.flushSync(); - } - it('increases priority of updates as time progresses', async () => { ReactNoop.render(); React.startTransition(() => { From 3ee981e78d6efc3a6363f15d46eaadb2b42923ce Mon Sep 17 00:00:00 2001 From: Jack Pope Date: Tue, 23 Jul 2024 17:12:24 -0400 Subject: [PATCH 3/4] more lint --- packages/react-reconciler/src/ReactFiber.js | 4 ++-- .../src/__tests__/ReactHooksWithNoopRenderer-test.js | 12 ++++-------- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/packages/react-reconciler/src/ReactFiber.js b/packages/react-reconciler/src/ReactFiber.js index 2b18089be99da..7db42bc9ce67a 100644 --- a/packages/react-reconciler/src/ReactFiber.js +++ b/packages/react-reconciler/src/ReactFiber.js @@ -582,8 +582,8 @@ export function createFiberFromTypeAndProps( fiberTag = isHostHoistableType(type, pendingProps, hostContext) ? HostHoistable : isHostSingletonType(type) - ? HostSingleton - : HostComponent; + ? HostSingleton + : HostComponent; } else if (supportsResources) { const hostContext = getHostContext(); fiberTag = isHostHoistableType(type, pendingProps, hostContext) diff --git a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js index 452163e4e4b63..b0d1182278135 100644 --- a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js +++ b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js @@ -3428,14 +3428,10 @@ describe('ReactHooksWithNoopRenderer', () => { let totalRefUpdates = 0; function Counter(props, ref) { const [count, dispatch] = useReducer(reducer, 0); - useImperativeHandle( - ref, - () => { - totalRefUpdates++; - return {count, dispatch}; - }, - [count], - ); + useImperativeHandle(ref, () => { + totalRefUpdates++; + return {count, dispatch}; + }, [count]); return ; } From ddb10af7b7614e0f7fc1588f4d706a6439f90725 Mon Sep 17 00:00:00 2001 From: Jack Pope Date: Tue, 23 Jul 2024 17:26:40 -0400 Subject: [PATCH 4/4] Fix ReactProfiler test --- .../src/__tests__/ReactProfiler-test.internal.js | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/packages/react/src/__tests__/ReactProfiler-test.internal.js b/packages/react/src/__tests__/ReactProfiler-test.internal.js index 367992dfd333a..c4d72ffee7241 100644 --- a/packages/react/src/__tests__/ReactProfiler-test.internal.js +++ b/packages/react/src/__tests__/ReactProfiler-test.internal.js @@ -170,17 +170,6 @@ describe(`onRender`, () => { 'read current time', 'read current time', ]); - } else if (gate(flags => !flags.allowConcurrentByDefault)) { - assertLog([ - 'read current time', - 'read current time', - 'read current time', - 'read current time', - 'read current time', - 'read current time', - 'read current time', - // TODO: why is there one less in this case? - ]); } else { assertLog([ 'read current time', @@ -190,7 +179,6 @@ describe(`onRender`, () => { 'read current time', 'read current time', 'read current time', - 'read current time', ]); } });