Reduce allocations in VirtualizedList render and scroll path (#58593)

Summary:
`VirtualizedList`/`FlatList`/`SectionList` re-run a small amount of
bookkeeping on every render and on every scroll event (60–120 Hz on
ProMotion displays). This PR removes three allocations from those hot
paths without changing any observable behavior:

1. **`VirtualizedList.render` no longer builds a `Set` for
   `stickyHeaderIndices` on every render** when the prop is not provided
   (the common case). The Set is now only created when the prop is
   present; the two `.has()` lookups use optional access.
2. **`ChildListCollection.forEach` returns early when there are no nested
   child lists** (the common case) instead of allocating a
   `Map.values()` iterator. This is called from `_onScroll` and the four
   other scroll callbacks on every scroll event.
3. **`_orientation()` caches its result** and only rebuilds the object
   when the `horizontal` prop changes. `I18nManager.isRTL` is a
   module-load constant (only changes on app reload), so the cache is
   invalidated solely by the `horizontal` prop. The object is replaced,
   never mutated, which keeps `ListMetricsAggregator`'s field-based
   invalidation correct.

## Changelog:

[GENERAL][CHANGED] - Reduce allocations in the `VirtualizedList` render and scroll path (avoid per-render `Set` allocation for `stickyHeaderIndices`, per-scroll-event `Map` iterator for the empty nested-list collection, and per-call `orientation` object allocation)

Pull Request resolved: #58593

Test Plan:
- `yarn test packages/virtualized-lists` → 9 suites, 186 passed, 69
  snapshots:
  - `ChildListCollection-test.js` (new): forEach over populated/empty
    collection, removal, `forEachInCell`/`anyInCell`
  - `VirtualizedList-test.js`: `stickyHeaderIndices` not forwarded when
    the prop is absent (with `ListHeaderComponent`), forwarded when
    provided; orientation cache identity + invalidation on
    `horizontal` change
- `yarn flow-check` → 0 errors
- `yarn lint` → 0 errors, 0 warnings
- `yarn format-check` (changed files)

Micro-benchmark (Node v24, V8, 2M iterations, before vs after, same
machine; the real-world benefit is dominated by reduced GC pressure,
which is largest on low-end Android):

Reviewed By: Abbondanzo

Differential Revision: D121177373

Pulled By: javache

fbshipit-source-id: 1befd7e6d90fbd1fcea9c4cc8cf6d575c6c26111

Author: secitr

packages/virtualized-lists/Lists/ChildListCollection.js

@@ -42,6 +42,11 @@ export default class ChildListCollection<TList> {
   }
 
   forEach(fn: TList => void): void {
+    // Fast-path for the common case of a list without nested child lists,
+    // which avoids allocating a Map iterator on every scroll event.
+    if (this._cellKeyToChildren.size === 0) {
+      return;
+    }
     for (const listSet of this._cellKeyToChildren.values()) {
       for (const list of listSet) {
         fn(list);

packages/virtualized-lists/Lists/VirtualizedList.js

@@ -255,8 +255,7 @@ class VirtualizedList extends StateSafePureComponent<
       return;
     }
 
-    const {horizontal, rtl} = this._orientation();
-    if (horizontal && rtl && !this._listMetrics.hasContentLength()) {
+    if (this._isHorizontalRTL() && !this._listMetrics.hasContentLength()) {
       console.warn(
         'scrollToOffset may not be called in RTL before content is laid out',
       );
@@ -277,9 +276,7 @@ class VirtualizedList extends StateSafePureComponent<
       const cartOffset = this._listMetrics.cartesianOffset(
         offset + this._scrollMetrics.visibleLength,
       );
-      /* $FlowFixMe[constant-condition] Error discovered during Constant
-       * Condition roll out. See https://fburl.com/workplace/1v97vimq. */
-      return horizontal ? {x: cartOffset} : {y: cartOffset};
+      return {x: cartOffset};
     } else {
       return horizontal ? {x: offset} : {y: offset};
     }
@@ -437,13 +434,6 @@ class VirtualizedList extends StateSafePureComponent<
       'VirtualizedList: The windowSize prop must be present and set to a value greater than 0.',
     );
 
-    invariant(
-      /* $FlowFixMe[constant-condition] Error discovered during Constant
-       * Condition roll out. See https://fburl.com/workplace/1v97vimq. */
-      getItemCount,
-      'VirtualizedList: The "getItemCount" prop must be provided',
-    );
-
     const itemCount = getItemCount(data);
 
     if (
@@ -786,7 +776,7 @@ class VirtualizedList extends StateSafePureComponent<
   _pushCells(
     cells: Array<Object>,
     stickyHeaderIndices: Array<number>,
-    stickyIndicesFromProps: Set<number>,
+    stickyIndicesFromProps: ?Set<number>,
     first: number,
     last: number,
     inversionStyle: StyleProp<ViewStyle>,
@@ -814,7 +804,7 @@ class VirtualizedList extends StateSafePureComponent<
       const key = VirtualizedList._keyExtractor(item, ii, this.props);
 
       this._indicesToKeys.set(ii, key);
-      if (stickyIndicesFromProps.has(ii + stickyOffset)) {
+      if (stickyIndicesFromProps?.has(ii + stickyOffset)) {
         stickyHeaderIndices.push(cells.length);
       }
 
@@ -945,12 +935,16 @@ class VirtualizedList extends StateSafePureComponent<
         : styles.verticallyInverted
       : null;
     const cells: Array<any | React.Node> = [];
-    const stickyIndicesFromProps = new Set(this.props.stickyHeaderIndices);
+    // Avoid allocating a Set on every render when no sticky headers are
+    // configured (the common case).
+    const stickyHeaderIndicesProp = this.props.stickyHeaderIndices;
+    const stickyIndicesFromProps =
+      stickyHeaderIndicesProp != null ? new Set(stickyHeaderIndicesProp) : null;
     const stickyHeaderIndices = [];
 
     // 1. Add cell for ListHeaderComponent
     if (ListHeaderComponent) {
-      if (stickyIndicesFromProps.has(0)) {
+      if (stickyIndicesFromProps?.has(0)) {
         stickyHeaderIndices.push(0);
       }
       const element = isValidElement(ListHeaderComponent) ? (
@@ -1549,7 +1543,11 @@ class VirtualizedList extends StateSafePureComponent<
   }
 
   _selectOffset({x, y}: Readonly<{x: number, y: number, ...}>): number {
-    return this._orientation().horizontal ? x : y;
+    return horizontalOrDefault(this.props.horizontal) ? x : y;
+  }
+
+  _isHorizontalRTL(): boolean {
+    return horizontalOrDefault(this.props.horizontal) && I18nManager.isRTL;
   }
 
   _orientation(): ListOrientation {
@@ -1802,8 +1800,7 @@ class VirtualizedList extends StateSafePureComponent<
 
   _offsetFromScrollEvent(e: ScrollEvent): number {
     const {contentOffset, contentSize, layoutMeasurement} = e.nativeEvent;
-    const {horizontal, rtl} = this._orientation();
-    if (horizontal && rtl) {
+    if (this._isHorizontalRTL()) {
       return (
         this._selectLength(contentSize) -
         (this._selectOffset(contentOffset) +

packages/virtualized-lists/Lists/__tests__/ChildListCollection-test.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import ChildListCollection from '../ChildListCollection';
+
+describe('ChildListCollection', function () {
+  it('iterates over all child lists with forEach', function () {
+    const collection = new ChildListCollection<string>();
+    collection.add('a', 'cell1');
+    collection.add('b', 'cell1');
+    collection.add('c', 'cell2');
+
+    const visited = [];
+    collection.forEach(list => {
+      visited.push(list);
+    });
+    expect(visited.sort()).toEqual(['a', 'b', 'c']);
+    expect(collection.size()).toBe(3);
+  });
+
+  it('does not call the callback when the collection is empty', function () {
+    const collection = new ChildListCollection<string>();
+    const callback = jest.fn();
+    collection.forEach(callback);
+    expect(callback).not.toHaveBeenCalled();
+    expect(collection.size()).toBe(0);
+  });
+
+  it('stops iterating entries after they are removed', function () {
+    const collection = new ChildListCollection<string>();
+    collection.add('a', 'cell1');
+    collection.remove('a');
+
+    const visited = [];
+    collection.forEach(list => {
+      visited.push(list);
+    });
+    expect(visited).toEqual([]);
+    expect(collection.size()).toBe(0);
+  });
+
+  it('supports forEachInCell and anyInCell', function () {
+    const collection = new ChildListCollection<string>();
+    collection.add('a', 'cell1');
+    collection.add('b', 'cell2');
+
+    const visited = [];
+    collection.forEachInCell('cell1', list => {
+      visited.push(list);
+    });
+    expect(visited).toEqual(['a']);
+
+    expect(collection.anyInCell('cell2', list => list === 'b')).toBe(true);
+    expect(collection.anyInCell('cell1', list => list === 'b')).toBe(false);
+    expect(collection.anyInCell('missing', () => true)).toBe(false);
+  });
+});

packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js

@@ -1052,6 +1052,49 @@ describe('VirtualizedList', () => {
     expect(component).toMatchSnapshot();
   });
 
+  it('does not forward stickyHeaderIndices when the prop is absent', async () => {
+    let scrollProps;
+    await act(() => {
+      create(
+        <VirtualizedList
+          ListHeaderComponent={() => createElement('Header')}
+          data={[{key: 'i1'}, {key: 'i2'}]}
+          renderItem={({item}) => <item value={item.key} />}
+          getItem={(data, index) => data[index]}
+          getItemCount={data => data.length}
+          renderScrollComponent={props => {
+            scrollProps = props;
+            return createElement('MockScrollView', props);
+          }}
+        />,
+      );
+    });
+    expect(scrollProps).not.toBe(undefined);
+    expect(scrollProps.stickyHeaderIndices).toEqual([]);
+  });
+
+  it('forwards stickyHeaderIndices including the header index when provided', async () => {
+    let scrollProps;
+    await act(() => {
+      create(
+        <VirtualizedList
+          ListHeaderComponent={() => createElement('Header')}
+          data={[{key: 'i1'}, {key: 'i2'}]}
+          renderItem={({item}) => <item value={item.key} />}
+          getItem={(data, index) => data[index]}
+          getItemCount={data => data.length}
+          stickyHeaderIndices={[0]}
+          renderScrollComponent={props => {
+            scrollProps = props;
+            return createElement('MockScrollView', props);
+          }}
+        />,
+      );
+    });
+    expect(scrollProps).not.toBe(undefined);
+    expect(scrollProps.stickyHeaderIndices).toEqual([0]);
+  });
+
   it('does not add a sticky header to the render mask when no sticky headers are configured', () => {
     const expectedRegions = [
       {first: 0, last: 9, isSpacer: true},