react-native-tvos 0.85.3-0 → 0.86.0-0

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -13,9 +13,14 @@
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/element/ComponentBuilder.h>
+#include <react/renderer/element/Element.h>
+#include <react/renderer/element/testUtils.h>
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 #include <react/renderer/mounting/stubs/stubs.h>
 #include <react/test_utils/Entropy.h>
 #include <react/test_utils/shadowTreeGeneration.h>
@@ -346,7 +351,35 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
 
 using namespace facebook::react;
 
-TEST(
+namespace {
+
+class LISFeatureFlagsOverride
+    : public facebook::react::ReactNativeFeatureFlagsDefaults {
+ public:
+  bool useLISAlgorithmInDifferentiator() override {
+    return true;
+  }
+};
+
+} // namespace
+
+// Parametrized lifecycle tests: each test runs with both the greedy
+// algorithm (false) and the LIS algorithm (true).
+class ShadowTreeLifecycleTest : public ::testing::TestWithParam<bool> {
+ protected:
+  void SetUp() override {
+    if (GetParam()) {
+      facebook::react::ReactNativeFeatureFlags::override(
+          std::make_unique<LISFeatureFlagsOverride>());
+    }
+  }
+
+  void TearDown() override {
+    facebook::react::ReactNativeFeatureFlags::dangerouslyReset();
+  }
+};
+
+TEST_P(
     ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
@@ -356,7 +389,7 @@ TEST(
       /* stages */ 32);
 }
 
-TEST(
+TEST_P(
     ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener2) {
   testShadowNodeTreeLifeCycle(
@@ -366,7 +399,7 @@ TEST(
       /* stages */ 32);
 }
 
-TEST(
+TEST_P(
     ShadowTreeLifecycleTest,
     stableSmallerTreeMoreIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
@@ -376,7 +409,7 @@ TEST(
       /* stages */ 32);
 }
 
-TEST(
+TEST_P(
     ShadowTreeLifecycleTest,
     unstableSmallerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -386,7 +419,7 @@ TEST(
       /* stages */ 32);
 }
 
-TEST(
+TEST_P(
     ShadowTreeLifecycleTest,
     unstableBiggerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -396,7 +429,7 @@ TEST(
       /* stages */ 32);
 }
 
-TEST(
+TEST_P(
     ShadowTreeLifecycleTest,
     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -407,20 +440,18 @@ TEST(
 }
 
 // failing test case found 4-25-2021
-// TODO: T213669056
-// TEST(
-//     ShadowTreeLifecycleTest,
-//     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011)
-//     {
-//   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
-//       /* seed */ 1167342011,
-//       /* size */ 32,
-//       /* repeats */ 512,
-//       /* stages */ 32);
-// }
+TEST_P(
+    ShadowTreeLifecycleTest,
+    unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011) {
+  testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
+      /* seed */ 1167342011,
+      /* size */ 32,
+      /* repeats */ 512,
+      /* stages */ 32);
+}
 
 // You may uncomment this - locally only! - to generate failing seeds.
-// TEST(
+// TEST_P(
 //     ShadowTreeLifecycleTest,
 //     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflatteningManyRandom)
 //     {
@@ -435,3 +466,268 @@ TEST(
 //         /* stages */ 32);
 //   }
 // }
+
+// Demonstrates that the LIS algorithm produces fewer mutations than the
+// greedy algorithm for a simple child reorder: [A,B,C,D,E] → [B,C,D,E,A].
+// The greedy two-pointer walk encounters A vs B mismatch and generates
+// excessive REMOVE+INSERT pairs. The LIS algorithm identifies that B,C,D,E
+// are already in increasing order and only moves A.
+TEST_P(ShadowTreeLifecycleTest, moveFirstChildToLast) {
+  auto builder = simpleComponentBuilder();
+
+  auto makeProps = [](const std::string& id) {
+    auto props = std::make_shared<ViewShadowNodeProps>();
+    props->nativeId = id;
+    return props;
+  };
+
+  // clang-format off
+  auto rootElement =
+      Element<RootShadowNode>()
+        .tag(1)
+        .children({
+          Element<ViewShadowNode>().tag(2).props(makeProps("A")),
+          Element<ViewShadowNode>().tag(3).props(makeProps("B")),
+          Element<ViewShadowNode>().tag(4).props(makeProps("C")),
+          Element<ViewShadowNode>().tag(5).props(makeProps("D")),
+          Element<ViewShadowNode>().tag(6).props(makeProps("E")),
+        });
+  // clang-format on
+
+  auto rootNode = builder.build(rootElement);
+
+  // Clone root with children reordered to [B, C, D, E, A].
+  auto children = rootNode->getChildren();
+  auto reorderedChildren =
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+  for (size_t i = 1; i < children.size(); i++) {
+    reorderedChildren->push_back(children[i]);
+  }
+  reorderedChildren->push_back(children[0]);
+
+  auto reorderedRootNode = std::static_pointer_cast<const RootShadowNode>(
+      rootNode->ShadowNode::clone(
+          ShadowNodeFragment{
+              .props = ShadowNodeFragment::propsPlaceholder(),
+              .children = reorderedChildren}));
+
+  auto expected =
+      buildStubViewTreeWithoutUsingDifferentiator(*reorderedRootNode);
+  auto mutations = calculateShadowViewMutations(*rootNode, *reorderedRootNode);
+
+  auto isMoveOp = [](const ShadowViewMutation& m) {
+    return m.type == ShadowViewMutation::Remove ||
+        m.type == ShadowViewMutation::Insert;
+  };
+
+  if (ReactNativeFeatureFlags::useLISAlgorithmInDifferentiator()) {
+    // LIS: 1 REMOVE + 1 INSERT = 2 move ops.
+    EXPECT_EQ(std::count_if(mutations.begin(), mutations.end(), isMoveOp), 2);
+  } else {
+    // Greedy: 4 REMOVE + 4 INSERT = 8 move ops.
+    EXPECT_EQ(std::count_if(mutations.begin(), mutations.end(), isMoveOp), 8);
+  }
+
+  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
+  viewTree.mutate(mutations);
+  EXPECT_EQ(viewTree, expected);
+}
+
+// Exercises the LIS path where concreteChanged=true AND flattening
+// consumption occur simultaneously. Z(tag=7) is reordered to break head/tail
+// matching, forcing A, W, and C into the LIS path. W(tag=3) loses testId
+// (concrete→non-concrete, concreteChanged=true) while remaining in the LIS.
+// updateMatchedPairSubtrees triggers the flattener which promotes B(tag=6).
+// The if(!concreteChanged) block that normally checks consumption is bypassed,
+// so this test verifies the combination still produces correct mutations.
+TEST_P(ShadowTreeLifecycleTest, concreteChangedWithFlattening) {
+  auto builder = simpleComponentBuilder();
+
+  auto concreteProps = [](const std::string& id) {
+    auto props = std::make_shared<ViewShadowNodeProps>();
+    props->testId = id;
+    return props;
+  };
+
+  // clang-format off
+  // Old: Root -> [Z, A, W(concrete, child B), C]
+  // Old flattened: [Z(7), A(2), W(3), C(4)]
+  auto rootElement =
+      Element<RootShadowNode>()
+        .tag(1)
+        .children({
+          Element<ViewShadowNode>().tag(7).props(concreteProps("Z")),
+          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
+          Element<ViewShadowNode>().tag(3).props(concreteProps("W"))
+            .children({
+              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
+            }),
+          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
+        });
+  // clang-format on
+
+  auto rootNode = builder.build(rootElement);
+  auto children = rootNode->getChildren();
+  // children: [Z(7), A(2), W(3), C(4)]
+
+  // W loses testId → non-concrete (flattened). B(tag=6) promoted.
+  auto flatW = children[2]->clone(
+      ShadowNodeFragment{.props = std::make_shared<ViewShadowNodeProps>()});
+
+  // New: Root -> [A, W(flattened), C, Z] — Z moved to end.
+  // New flattened: [A(2), W(3,non-concrete), B(6), C(4), Z(7)]
+  // Z's move breaks head matching; A, W, C enter LIS path.
+  // Among old remaining [Z,A,W,C] mapped to new positions,
+  // LIS includes A,W,C (increasing order), W has concreteChanged=true.
+  auto newChildren =
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+  newChildren->push_back(children[1]); // A
+  newChildren->push_back(flatW); // W (flattened)
+  newChildren->push_back(children[3]); // C
+  newChildren->push_back(children[0]); // Z (moved to end)
+
+  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
+      rootNode->ShadowNode::clone(
+          ShadowNodeFragment{
+              .props = ShadowNodeFragment::propsPlaceholder(),
+              .children = newChildren}));
+
+  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
+  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
+  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
+  viewTree.mutate(mutations);
+  EXPECT_EQ(viewTree, expected);
+}
+
+// Reverse: W(tag=3) gains testId (non-concrete→concrete, concreteChanged=true)
+// while in the LIS path. B(tag=6) was promoted by flattening and now gets
+// absorbed back into W via unflattening. Z reorder breaks head matching.
+TEST_P(ShadowTreeLifecycleTest, concreteChangedWithUnflatteningInLIS) {
+  auto builder = simpleComponentBuilder();
+
+  auto concreteProps = [](const std::string& id) {
+    auto props = std::make_shared<ViewShadowNodeProps>();
+    props->testId = id;
+    return props;
+  };
+
+  // clang-format off
+  // Old: Root -> [Z, A, W(NON-concrete, child B(concrete)), C]
+  // Old flattened: [Z(7), A(2), W(3,non-concrete), B(6), C(4)]
+  auto rootElement =
+      Element<RootShadowNode>()
+        .tag(1)
+        .children({
+          Element<ViewShadowNode>().tag(7).props(concreteProps("Z")),
+          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
+          Element<ViewShadowNode>().tag(3)
+            .children({
+              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
+            }),
+          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
+        });
+  // clang-format on
+
+  auto rootNode = builder.build(rootElement);
+  auto children = rootNode->getChildren();
+
+  // W gains testId → concrete (unflattened). B absorbed back into W.
+  auto concreteW =
+      children[2]->clone(ShadowNodeFragment{.props = concreteProps("W")});
+
+  // New: Root -> [A, W(concrete), C, Z] — Z moved to end.
+  // New flattened: [A(2), W(3), C(4), Z(7)]
+  auto newChildren =
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+  newChildren->push_back(children[1]); // A
+  newChildren->push_back(concreteW); // W (concrete)
+  newChildren->push_back(children[3]); // C
+  newChildren->push_back(children[0]); // Z (moved to end)
+
+  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
+      rootNode->ShadowNode::clone(
+          ShadowNodeFragment{
+              .props = ShadowNodeFragment::propsPlaceholder(),
+              .children = newChildren}));
+
+  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
+  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
+  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
+  viewTree.mutate(mutations);
+  EXPECT_EQ(viewTree, expected);
+}
+
+// Tests that the LIS algorithm produces correct mutations when child
+// reordering coincides with a view's flattening transition. When W(tag=3)
+// becomes flattened (loses testId), its child B(tag=6) is promoted to the
+// parent level in the flattened view. The LIS pre-computation maps old
+// children to new positions, but the flattener may consume entries from
+// newRemainingPairs during flatten/unflatten processing. This test verifies
+// the runtime newRemainingPairs check correctly handles this interaction.
+TEST_P(ShadowTreeLifecycleTest, reorderWithFlatteningTransition) {
+  auto builder = simpleComponentBuilder();
+
+  auto concreteProps = [](const std::string& id) {
+    auto props = std::make_shared<ViewShadowNodeProps>();
+    props->testId = id;
+    return props;
+  };
+
+  // clang-format off
+  // Old tree: Root -> [A, W(concrete with testId, child B), C, D]
+  auto rootElement =
+      Element<RootShadowNode>()
+        .tag(1)
+        .children({
+          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
+          Element<ViewShadowNode>().tag(3).props(concreteProps("W"))
+            .children({
+              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
+            }),
+          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
+          Element<ViewShadowNode>().tag(5).props(concreteProps("D")),
+        });
+  // clang-format on
+
+  auto rootNode = builder.build(rootElement);
+  auto children = rootNode->getChildren();
+  // children: [A(2), W(3), C(4), D(5)]
+
+  // Clone W without testId to make it non-concrete (flattened).
+  // B(tag=6) will be promoted to the parent level.
+  auto flatW = children[1]->clone(
+      ShadowNodeFragment{.props = std::make_shared<ViewShadowNodeProps>()});
+
+  // New tree: Root -> [C, D, A, W(flattened)]
+  // Reorder [A,W,C,D] -> [C,D,A,W(flattened)]
+  auto reorderedChildren =
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+  reorderedChildren->push_back(children[2]); // C
+  reorderedChildren->push_back(children[3]); // D
+  reorderedChildren->push_back(children[0]); // A
+  reorderedChildren->push_back(flatW); // W (flattened)
+
+  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
+      rootNode->ShadowNode::clone(
+          ShadowNodeFragment{
+              .props = ShadowNodeFragment::propsPlaceholder(),
+              .children = reorderedChildren}));
+
+  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
+  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
+  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
+  viewTree.mutate(mutations);
+  EXPECT_EQ(viewTree, expected);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Greedy,
+    ShadowTreeLifecycleTest,
+    ::testing::Values(false),
+    [](const auto&) { return "Greedy"; });
+
+INSTANTIATE_TEST_SUITE_P(
+    LIS,
+    ShadowTreeLifecycleTest,
+    ::testing::Values(true),
+    [](const auto&) { return "LIS"; });

package/ReactCommon/react/renderer/mounting/updateMountedFlag.cpp

@@ -29,6 +29,25 @@ void updateMountedFlag(
     return;
   }
 
+  // Mounted flags shouldn't be updated during the React revision merge
+  // because they were already set during the React branch commit. Setting them
+  // again would double-increment the EventEmitter's additive enable counter.
+  bool shouldUpdateMountedFlag =
+      commitSource != ShadowTreeCommitSource::ReactRevisionMerge;
+
+  // Runtime shadow node references are updated during the React revision
+  // commits so that JS can access layout data from the merged tree.
+  bool shouldUpdateRuntimeReference =
+      (commitSource == ShadowTreeCommitSource::React &&
+       ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit()) ||
+      (ReactNativeFeatureFlags::
+           updateRuntimeShadowNodeReferencesOnCommitThread() &&
+       ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread());
+
+  if (!shouldUpdateMountedFlag && !shouldUpdateRuntimeReference) {
+    return;
+  }
+
   size_t index = 0;
 
   // Stage 1: Mount and unmount "updated" children.
@@ -47,15 +66,12 @@ void updateMountedFlag(
       break;
     }
 
-    newChild->setMounted(true);
-    oldChild->setMounted(false);
+    if (shouldUpdateMountedFlag) {
+      newChild->setMounted(true);
+      oldChild->setMounted(false);
+    }
 
-    if ((commitSource == ShadowTreeCommitSource::React &&
-         ReactNativeFeatureFlags::
-             updateRuntimeShadowNodeReferencesOnCommit()) ||
-        (ReactNativeFeatureFlags::
-             updateRuntimeShadowNodeReferencesOnCommitThread() &&
-         ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread())) {
+    if (shouldUpdateRuntimeReference) {
       newChild->updateRuntimeShadowNodeReference(newChild);
     }
 
@@ -68,14 +84,12 @@ void updateMountedFlag(
   // State 2: Mount new children.
   for (index = lastIndexAfterFirstStage; index < newChildren.size(); index++) {
     const auto& newChild = newChildren[index];
-    newChild->setMounted(true);
-
-    if ((commitSource == ShadowTreeCommitSource::React &&
-         ReactNativeFeatureFlags::
-             updateRuntimeShadowNodeReferencesOnCommit()) ||
-        (ReactNativeFeatureFlags::
-             updateRuntimeShadowNodeReferencesOnCommitThread() &&
-         ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread())) {
+
+    if (shouldUpdateMountedFlag) {
+      newChild->setMounted(true);
+    }
+
+    if (shouldUpdateRuntimeReference) {
       newChild->updateRuntimeShadowNodeReference(newChild);
     }
 
@@ -83,10 +97,14 @@ void updateMountedFlag(
   }
 
   // State 3: Unmount old children.
-  for (index = lastIndexAfterFirstStage; index < oldChildren.size(); index++) {
-    const auto& oldChild = oldChildren[index];
-    oldChild->setMounted(false);
-    updateMountedFlag(oldChild->getChildren(), {}, commitSource);
+  if (shouldUpdateMountedFlag) {
+    for (index = lastIndexAfterFirstStage; index < oldChildren.size();
+         index++) {
+      const auto& oldChild = oldChildren[index];
+      oldChild->setMounted(false);
+
+      updateMountedFlag(oldChild->getChildren(), {}, commitSource);
+    }
   }
 }
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -858,11 +858,10 @@ TEST_P(RuntimeSchedulerTest, scheduleTaskFromTask) {
 
 TEST_P(RuntimeSchedulerTest, handlingError) {
   bool didRunTask = false;
-  auto firstCallback =
-      createHostFunctionFromLambda([this, &didRunTask](bool /*unused*/) {
+  auto firstCallback = createHostFunctionFromLambda(
+      [this, &didRunTask](bool /*unused*/) -> jsi::Value {
         didRunTask = true;
         throw jsi::JSError(*runtime_, "Test error");
-        return jsi::Value::undefined();
       });
 
   runtimeScheduler_->scheduleTask(
@@ -1169,27 +1168,26 @@ TEST_P(RuntimeSchedulerTest, errorInTaskShouldNotStopMicrotasks) {
   auto microtaskRan = false;
   auto taskRan = false;
 
-  auto callback = createHostFunctionFromLambda([&](bool /* unused */) {
-    taskRan = true;
-
-    auto microtaskCallback = jsi::Function::createFromHostFunction(
-        *runtime_,
-        jsi::PropNameID::forUtf8(*runtime_, "microtask1"),
-        3,
-        [&](jsi::Runtime& /*unused*/,
-            const jsi::Value& /*unused*/,
-            const jsi::Value* /*arguments*/,
-            size_t /*unused*/) -> jsi::Value {
-          microtaskRan = true;
-          return jsi::Value::undefined();
-        });
-
-    runtime_->queueMicrotask(microtaskCallback);
+  auto callback =
+      createHostFunctionFromLambda([&](bool /* unused */) -> jsi::Value {
+        taskRan = true;
+
+        auto microtaskCallback = jsi::Function::createFromHostFunction(
+            *runtime_,
+            jsi::PropNameID::forUtf8(*runtime_, "microtask1"),
+            3,
+            [&](jsi::Runtime& /*unused*/,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* /*arguments*/,
+                size_t /*unused*/) -> jsi::Value {
+              microtaskRan = true;
+              return jsi::Value::undefined();
+            });
 
-    throw jsi::JSError(*runtime_, "Test error");
+        runtime_->queueMicrotask(microtaskCallback);
 
-    return jsi::Value::undefined();
-  });
+        throw jsi::JSError(*runtime_, "Test error");
+      });
 
   runtimeScheduler_->scheduleTask(
       SchedulerPriority::NormalPriority, std::move(callback));

package/ReactCommon/react/renderer/scheduler/CMakeLists.txt

@@ -30,6 +30,7 @@ target_link_libraries(react_renderer_scheduler
         react_renderer_observers_events
         react_renderer_runtimescheduler
         react_renderer_uimanager
+        react_renderer_viewtransition
         react_utils
         rrc_root
         rrc_view