Add cloneMultiple method to the ShadowNode class (facebook#50624)

Summary:
This PR adds a new cloning method, allowing for updating multiple nodes in a single transaction. It works in two phases:
1. Find which nodes have to be cloned (i.e. nodes given on input and all their ancestors)
2. Clone nodes in the bottom up order - so that every node is cloned exactly once

So the idea is that when we want to update all the red nodes in this picture, we first find the nodes in the green area and the clone only them in the correct order (children are cloned before parents):
![Screenshot 2025-04-10 at 14 31 14](https://github.com/user-attachments/assets/f397eeff-8279-4d0c-bf87-083bfb44b86a)

Adapting this method [brought a huge performance gain to reanimated](software-mansion/react-native-reanimated#6214). I want to upstream it, so that:
1. we can optimize it further, because making it a part of the `ShadowNode` class gives us access to the parent field in `ShadowNodeFamily` so we can traverse the tree upwards, allowing for a optimal implementation of the first phase (in reanimated we repeatedly call `getAncestors`, which revisits some nodes multiple times)
2. the community can use it

A naive approach that calls `cloneTree` for every node is much slower, as it has to repeat many operations.
## Changelog:

[GENERAL] [ADDED] - Added `cloneMultiple` to `ShadowNode` class.

Pull Request resolved: facebook#50624

Test Plan:
I tested it with the following reanimated implementation and everything works fine:

<details>

```c++
const auto callback =
      [&](const ShadowNode &shadowNode,
          const std::optional<ShadowNode::ListOfShared> &newChildren) {
        return shadowNode.clone(
            {mergeProps(shadowNode, propsMap, shadowNode.getFamily()),
             newChildren
                 ? std::make_shared<ShadowNode::ListOfShared>(*newChildren)
                 : ShadowNodeFragment::childrenPlaceholder(),
             shadowNode.getState()});
      };
  return std::static_pointer_cast<RootShadowNode>(
      oldRootNode.cloneMultiple(families, callback));

```

</details>

I would like to add tests for it, but I'm not sure what's the best approach for that in the repo.

Reviewed By: mdvacca

Differential Revision: D75284060

Pulled By: javache

fbshipit-source-id: 0704c4386c3041eb368adf6950d46de197479058

Author: bartlomiejbloniarz

packages/react-native/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -401,6 +401,79 @@ std::shared_ptr<ShadowNode> ShadowNode::cloneTree(
   return std::const_pointer_cast<ShadowNode>(childNode);
 }
 
+namespace {
+
+std::shared_ptr<ShadowNode> cloneMultipleRecursive(
+    const ShadowNode& shadowNode,
+    const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
+    const std::unordered_map<const ShadowNodeFamily*, int>& childrenCount,
+    const std::function<std::shared_ptr<
+        ShadowNode>(const ShadowNode&, const ShadowNodeFragment&)>& callback) {
+  const auto* family = &shadowNode.getFamily();
+  auto& children = shadowNode.getChildren();
+  std::shared_ptr<ShadowNode::ListOfShared> newChildren;
+  auto count = childrenCount.at(family);
+
+  for (int i = 0; count > 0 && i < children.size(); i++) {
+    const auto childFamily = &children[i]->getFamily();
+    if (childrenCount.contains(childFamily)) {
+      count--;
+      if (!newChildren) {
+        newChildren = std::make_shared<ShadowNode::ListOfShared>(children);
+      }
+      (*newChildren)[i] = cloneMultipleRecursive(
+          *children[i], familiesToUpdate, childrenCount, callback);
+    }
+  }
+
+  ShadowNodeFragment fragment{.children = newChildren};
+  if (familiesToUpdate.contains(family)) {
+    return callback(shadowNode, fragment);
+  }
+  return shadowNode.clone(fragment);
+}
+
+} // namespace
+
+std::shared_ptr<ShadowNode> ShadowNode::cloneMultiple(
+    const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
+    const std::function<std::shared_ptr<ShadowNode>(
+        const ShadowNode& oldShadowNode,
+        const ShadowNodeFragment& fragment)>& callback) const {
+  std::unordered_map<const ShadowNodeFamily*, int> childrenCount;
+
+  for (const auto& family : familiesToUpdate) {
+    if (childrenCount.contains(family)) {
+      continue;
+    }
+
+    childrenCount[family] = 0;
+
+    auto ancestor = family->parent_.lock();
+    while ((ancestor != nullptr) && ancestor != family_) {
+      auto ancestorIt = childrenCount.find(ancestor.get());
+      if (ancestorIt != childrenCount.end()) {
+        ancestorIt->second++;
+        break;
+      }
+      childrenCount[ancestor.get()] = 1;
+
+      ancestor = ancestor->parent_.lock();
+    }
+
+    if (ancestor == family_) {
+      childrenCount[ancestor.get()]++;
+    }
+  }
+
+  if (childrenCount.empty()) {
+    return nullptr;
+  }
+
+  return cloneMultipleRecursive(
+      *this, familiesToUpdate, childrenCount, callback);
+}
+
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE

packages/react-native/ReactCommon/react/renderer/core/ShadowNode.h

@@ -37,7 +37,7 @@ class ShadowNode : public Sealable,
   using Weak [[deprecated("Use std::weak_ptr<const ShadowNode> instead")]] =
       std::weak_ptr<const ShadowNode>;
   // TODO(T223558094): delete this in the next version.
-  using Unshared [[deprecated("Use std::weak_ptr<const ShadowNode> instead")]] =
+  using Unshared [[deprecated("Use std::shared_ptr<ShadowNode> instead")]] =
       std::shared_ptr<ShadowNode>;
   using ListOfShared = std::vector<Shared>;
   using ListOfWeak = std::vector<std::weak_ptr<const ShadowNode>>;
@@ -111,6 +111,19 @@ class ShadowNode : public Sealable,
       const std::function<std::shared_ptr<ShadowNode>(
           const ShadowNode& oldShadowNode)>& callback) const;
 
+  /*
+   * Clones the nodes (and the subtree containing all the nodes) by
+   * replacing the `oldShadowNode` for every `shadowNodeFamily` from
+   * `familiesToUpdate` with a node that `callback` returns.
+   *
+   * Returns `nullptr` if the operation cannot be performed successfully.
+   */
+  std::shared_ptr<ShadowNode> cloneMultiple(
+      const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
+      const std::function<std::shared_ptr<ShadowNode>(
+          const ShadowNode& oldShadowNode,
+          const ShadowNodeFragment& fragment)>& callback) const;
+
 #pragma mark - Getters
 
   ComponentName getComponentName() const;

packages/react-native/ReactCommon/react/renderer/core/tests/ShadowNodeTest.cpp

@@ -32,7 +32,7 @@ class ShadowNodeTest : public testing::Test {
      *  </AB>
      *  <AC/>
      * </A>
-     * </Z>
+     * <Z/>
      */
 
     auto props = std::make_shared<const TestProps>();
@@ -295,3 +295,33 @@ TEST_F(ShadowNodeTest, handleRuntimeReferenceTransferOnClone) {
   // The wrappedShadowNode should still reference nodeABRev2
   EXPECT_EQ(wrappedShadowNode->shadowNode, nodeABRev2);
 }
+
+TEST_F(ShadowNodeTest, cloneMultiple) {
+  auto newProps = std::make_shared<const TestProps>();
+  auto newRoot = nodeA_->cloneMultiple(
+      {&nodeA_->getFamily(), &nodeAB_->getFamily()},
+      [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
+        return oldShadowNode.clone({
+            .props = newProps,
+            .children = fragment.children,
+            .state = fragment.state,
+        });
+      });
+
+  EXPECT_EQ(newRoot->getTag(), nodeA_->getTag());
+  EXPECT_EQ(newRoot->getProps(), newProps);
+
+  auto newNodeAA = newRoot->getChildren()[0];
+  EXPECT_EQ(newNodeAA->getTag(), nodeAA_->getTag());
+  EXPECT_EQ(newNodeAA->getProps(), nodeAA_->getProps());
+  // AA was cloned when its parent was cloned as it was shared
+  EXPECT_NE(newNodeAA.get(), nodeAA_.get());
+
+  auto newNodeAB = newRoot->getChildren()[1];
+  EXPECT_EQ(newNodeAB->getTag(), nodeAB_->getTag());
+  EXPECT_EQ(newNodeAB->getProps(), newProps);
+
+  auto newNodeABA = newNodeAB->getChildren()[0];
+  EXPECT_EQ(newNodeABA->getTag(), nodeABA_->getTag());
+  EXPECT_EQ(newNodeABA.get(), nodeABA_.get());
+}