react-native-tvos 0.76.5-0 → 0.77.0-0

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

@@ -12,6 +12,7 @@
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <algorithm>
+
 #include "ShadowView.h"
 
 #ifdef DEBUG_LOGS_DIFFER
@@ -39,6 +40,16 @@ enum class NoBreadcrumb {};
 
 namespace facebook::react {
 
+enum class ReparentMode { Flatten, Unflatten };
+
+bool ShadowViewNodePair::operator==(const ShadowViewNodePair& rhs) const {
+  return this->shadowNode == rhs.shadowNode;
+}
+
+bool ShadowViewNodePair::operator!=(const ShadowViewNodePair& rhs) const {
+  return !(*this == rhs);
+}
+
 /*
  * Extremely simple and naive implementation of a map.
  * The map is simple but it's optimized for particular constraints that we have
@@ -184,7 +195,7 @@ static bool shouldFirstPairComesBeforeSecondOne(
  * Reorders pairs in-place based on `orderIndex` using a stable sort algorithm.
  */
 static void reorderInPlaceIfNeeded(
-    ShadowViewNodePair::NonOwningList& pairs) noexcept {
+    std::vector<ShadowViewNodePair*>& pairs) noexcept {
   if (pairs.size() < 2) {
     return;
   }
@@ -206,7 +217,7 @@ static void reorderInPlaceIfNeeded(
 }
 
 static void sliceChildShadowNodeViewPairsRecursively(
-    ShadowViewNodePair::NonOwningList& pairList,
+    std::vector<ShadowViewNodePair*>& pairList,
     size_t& startOfStaticIndex,
     ViewNodePairScope& scope,
     Point layoutOffset,
@@ -234,13 +245,17 @@ static void sliceChildShadowNodeViewPairsRecursively(
     // shuffling their children around.
     bool childrenFormStackingContexts = shadowNode.getTraits().check(
         ShadowNodeTraits::Trait::ChildrenFormStackingContext);
-    bool isConcreteView =
-        childShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView) ||
-        childrenFormStackingContexts;
-    bool areChildrenFlattened =
+    bool isConcreteView = (childShadowNode.getTraits().check(
+                               ShadowNodeTraits::Trait::FormsView) ||
+                           childrenFormStackingContexts) &&
         !childShadowNode.getTraits().check(
-            ShadowNodeTraits::Trait::FormsStackingContext) &&
-        !childrenFormStackingContexts;
+            ShadowNodeTraits::Trait::ForceFlattenView);
+    bool areChildrenFlattened =
+        (!childShadowNode.getTraits().check(
+             ShadowNodeTraits::Trait::FormsStackingContext) &&
+         !childrenFormStackingContexts) ||
+        childShadowNode.getTraits().check(
+            ShadowNodeTraits::Trait::ForceFlattenView);
 
     Point storedOrigin = {};
     if (areChildrenFlattened) {
@@ -273,13 +288,13 @@ static void sliceChildShadowNodeViewPairsRecursively(
   }
 }
 
-ShadowViewNodePair::NonOwningList sliceChildShadowNodeViewPairs(
+std::vector<ShadowViewNodePair*> sliceChildShadowNodeViewPairs(
     const ShadowViewNodePair& shadowNodePair,
     ViewNodePairScope& scope,
     bool allowFlattened,
     Point layoutOffset) {
   const auto& shadowNode = *shadowNodePair.shadowNode;
-  auto pairList = ShadowViewNodePair::NonOwningList{};
+  auto pairList = std::vector<ShadowViewNodePair*>{};
 
   if (shadowNodePair.flattened && shadowNodePair.isConcreteView &&
       !allowFlattened) {
@@ -287,6 +302,7 @@ ShadowViewNodePair::NonOwningList sliceChildShadowNodeViewPairs(
   }
 
   size_t startOfStaticIndex = 0;
+
   sliceChildShadowNodeViewPairsRecursively(
       pairList, startOfStaticIndex, scope, layoutOffset, shadowNode);
 
@@ -307,7 +323,7 @@ ShadowViewNodePair::NonOwningList sliceChildShadowNodeViewPairs(
  * possible. This can account for adding parent LayoutMetrics that are
  * important to take into account, but tricky, in (un)flattening cases.
  */
-static ShadowViewNodePair::NonOwningList
+static std::vector<ShadowViewNodePair*>
 sliceChildShadowNodeViewPairsFromViewNodePair(
     const ShadowViewNodePair& shadowViewNodePair,
     ViewNodePairScope& scope,
@@ -333,8 +349,8 @@ static_assert(
     std::is_move_constructible<ShadowViewNodePair>::value,
     "`ShadowViewNodePair` must be `move constructible`.");
 static_assert(
-    std::is_move_constructible<ShadowViewNodePair::NonOwningList>::value,
-    "`ShadowViewNodePair::NonOwningList` must be `move constructible`.");
+    std::is_move_constructible<std::vector<ShadowViewNodePair*>>::value,
+    "`std::vector<ShadowViewNodePair*>` must be `move constructible`.");
 
 static_assert(
     std::is_move_assignable<ShadowViewMutation>::value,
@@ -345,16 +361,13 @@ static_assert(
 static_assert(
     std::is_move_assignable<ShadowViewNodePair>::value,
     "`ShadowViewNodePair` must be `move assignable`.");
-static_assert(
-    std::is_move_assignable<ShadowViewNodePair::NonOwningList>::value,
-    "`ShadowViewNodePair::NonOwningList` must be `move assignable`.");
 
 static void calculateShadowViewMutations(
     ViewNodePairScope& scope,
     ShadowViewMutation::List& mutations,
     const ShadowView& parentShadowView,
-    ShadowViewNodePair::NonOwningList&& oldChildPairs,
-    ShadowViewNodePair::NonOwningList&& newChildPairs);
+    std::vector<ShadowViewNodePair*>&& oldChildPairs,
+    std::vector<ShadowViewNodePair*>&& newChildPairs);
 
 struct OrderedMutationInstructionContainer {
   ShadowViewMutation::List createMutations{};
@@ -370,7 +383,7 @@ static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
     TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
-    ShadowViewNodePair::NonOwningList& oldChildPairs,
+    std::vector<ShadowViewNodePair*>& oldChildPairs,
     const ShadowView& parentShadowView,
     const ShadowViewNodePair& oldPair,
     const ShadowViewNodePair& newPair);
@@ -405,7 +418,7 @@ static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
     TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
-    ShadowViewNodePair::NonOwningList& oldChildPairs,
+    std::vector<ShadowViewNodePair*>& oldChildPairs,
     const ShadowView& parentShadowView,
     const ShadowViewNodePair& oldPair,
     const ShadowViewNodePair& newPair) {
@@ -626,7 +639,7 @@ static void calculateShadowViewMutationsFlattener(
   });
 
   // Step 1: iterate through entire tree
-  ShadowViewNodePair::NonOwningList treeChildren =
+  std::vector<ShadowViewNodePair*> treeChildren =
       sliceChildShadowNodeViewPairsFromViewNodePair(node, scope);
 
   DEBUG_LOGS({
@@ -1042,8 +1055,8 @@ static void calculateShadowViewMutations(
     ViewNodePairScope& scope,
     ShadowViewMutation::List& mutations,
     const ShadowView& parentShadowView,
-    ShadowViewNodePair::NonOwningList&& oldChildPairs,
-    ShadowViewNodePair::NonOwningList&& newChildPairs) {
+    std::vector<ShadowViewNodePair*>&& oldChildPairs,
+    std::vector<ShadowViewNodePair*>&& newChildPairs) {
   if (oldChildPairs.empty() && newChildPairs.empty()) {
     return;
   }

package/ReactCommon/react/renderer/mounting/Differentiator.h

@@ -14,7 +14,46 @@
 
 namespace facebook::react {
 
-enum class ReparentMode { Flatten, Unflatten };
+/*
+ * Describes pair of a `ShadowView` and a `ShadowNode`.
+ * This is not exposed to the mounting layer.
+ */
+struct ShadowViewNodePair final {
+  ShadowView shadowView;
+  const ShadowNode* shadowNode;
+
+  /**
+   * The ShadowNode does not form a stacking context, and the native views
+   * corresponding to its children may be parented to an ancestor.
+   */
+  bool flattened{false};
+
+  /**
+   * Whether this ShadowNode should create a corresponding native view.
+   */
+  bool isConcreteView{true};
+  Point contextOrigin{0, 0};
+
+  size_t mountIndex{0};
+
+  /**
+   * This is nullptr unless `inOtherTree` is set to true.
+   * We rely on this only for marginal cases. TODO: could we
+   * rely on this more heavily to simplify the diffing algorithm
+   * overall?
+   */
+  mutable const ShadowViewNodePair* otherTreePair{nullptr};
+
+  /*
+   * The stored pointer to `ShadowNode` represents an identity of the pair.
+   */
+  bool operator==(const ShadowViewNodePair& rhs) const;
+  bool operator!=(const ShadowViewNodePair& rhs) const;
+
+  bool inOtherTree() const {
+    return this->otherTreePair != nullptr;
+  }
+};
 
 /**
  * During differ, we need to keep some `ShadowViewNodePair`s in memory.
@@ -53,7 +92,7 @@ ShadowViewMutation::List calculateShadowViewMutations(
  * flattened view hierarchy. The V2 version preserves nodes even if they do
  * not form views and their children are flattened.
  */
-ShadowViewNodePair::NonOwningList sliceChildShadowNodeViewPairs(
+std::vector<ShadowViewNodePair*> sliceChildShadowNodeViewPairs(
     const ShadowViewNodePair& shadowNodePair,
     ViewNodePairScope& viewNodePairScope,
     bool allowFlattened = false,

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

@@ -6,6 +6,11 @@
  */
 
 #include "MountingCoordinator.h"
+
+#include <cxxreact/SystraceSection.h>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+#include <condition_variable>
 #include "updateMountedFlag.h"
 
 #ifdef RN_SHADOW_TREE_INTROSPECTION
@@ -13,12 +18,6 @@
 #include <sstream>
 #endif
 
-#include <condition_variable>
-
-#include <cxxreact/SystraceSection.h>
-#include <react/debug/react_native_assert.h>
-#include <react/renderer/mounting/ShadowViewMutation.h>
-
 namespace facebook::react {
 
 MountingCoordinator::MountingCoordinator(const ShadowTreeRevision& baseRevision)
@@ -104,6 +103,9 @@ std::optional<MountingTransaction> MountingCoordinator::pullTransaction(
   }
 
   // Override case
+#ifdef RN_SHADOW_TREE_INTROSPECTION
+  bool didOverridePullTransaction = false;
+#endif
   for (const auto& delegate : mountingOverrideDelegates_) {
     auto mountingOverrideDelegate = delegate.lock();
     auto shouldOverridePullTransaction = mountingOverrideDelegate &&
@@ -130,6 +132,9 @@ std::optional<MountingTransaction> MountingCoordinator::pullTransaction(
 
       transaction = mountingOverrideDelegate->pullTransaction(
           surfaceId_, number_, telemetry, std::move(mutations));
+#ifdef RN_SHADOW_TREE_INTROSPECTION
+      didOverridePullTransaction = true;
+#endif
     }
   }
 
@@ -148,7 +153,7 @@ std::optional<MountingTransaction> MountingCoordinator::pullTransaction(
     // If the transaction was overridden, we don't have a model of the shadow
     // tree therefore we cannot validate the validity of the mutation
     // instructions.
-    if (!shouldOverridePullTransaction && lastRevision_.has_value()) {
+    if (!didOverridePullTransaction && lastRevision_.has_value()) {
       auto stubViewTree = buildStubViewTreeWithoutUsingDifferentiator(
           *lastRevision_->rootShadowNode);
 

package/ReactCommon/react/renderer/mounting/MountingCoordinator.h

@@ -17,7 +17,6 @@
 #include <react/renderer/mounting/MountingTransaction.h>
 #include <react/renderer/mounting/ShadowTreeRevision.h>
 #include <react/renderer/mounting/TelemetryController.h>
-#include "ShadowTreeRevision.h"
 
 #ifdef RN_SHADOW_TREE_INTROSPECTION
 #include <react/renderer/mounting/stubs/stubs.h>
@@ -34,8 +33,6 @@ namespace facebook::react {
  */
 class MountingCoordinator final {
  public:
-  using Shared = std::shared_ptr<const MountingCoordinator>;
-
   /*
    * The constructor is meant to be used only inside `ShadowTree`, and it's
    * `public` only to enable using with `std::make_shared<>`.

package/ReactCommon/react/renderer/mounting/MountingOverrideDelegate.h

@@ -30,10 +30,11 @@ class MountingOverrideDelegate {
    * - Calling
    * - Telemetry, if appropriate
    *
-   * @param surfaceId
-   * @param number
-   * @param mountingCoordinator
-   * @return
+   * @param surfaceId the Id of the surface to be mounted
+   * @param number of the transaction
+   * @param telemetry object associated with the transaction
+   * @param mutations list of the mutations from the ShadowTree
+   * @return the mounting transaction, if it was created
    */
   virtual std::optional<MountingTransaction> pullTransaction(
       SurfaceId surfaceId,

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

@@ -26,115 +26,6 @@ namespace facebook::react {
 using CommitStatus = ShadowTree::CommitStatus;
 using CommitMode = ShadowTree::CommitMode;
 
-// --- State Alignment Mechanism algorithm ---
-// Note: Ideally, we don't have to const_cast but our use of constness in
-// C++ is overly restrictive. We do const_cast here but the only place where
-// we change ShadowNode is by calling `ShadowNode::progressStateIfNecessary`
-// where checks are in place to avoid manipulating a sealed ShadowNode.
-
-static void progressStateIfNecessary(
-    ShadowNode& newShadowNode,
-    const ShadowNode& baseShadowNode);
-
-/*
- * Looks at the new parent, new child and base child node to determine how to
- * reconcile the state.
- *
- * Only to be called when baseChildNode has trait `ClonedByNativeStateUpdate`.
- */
-static void progressStateIfNecessary(
-    ShadowNode& newShadowNode,
-    const ShadowNode& newChildNode,
-    const ShadowNode& baseChildNode,
-    size_t suggestedIndex) {
-  auto& shadowNode = const_cast<ShadowNode&>(newChildNode);
-  if (shadowNode.progressStateIfNecessary()) {
-    // State was progressed without the need to clone.
-    // We are done with this node, but need to keep traversing.
-    progressStateIfNecessary(shadowNode, baseChildNode);
-  } else if (newChildNode.getHasBeenPromoted()) {
-    // `newShadowNode` was cloned from react and cloned from a native state
-    // update. This child node was cloned only from a native state update.
-    // This is branching and it is safe to promote the new branch from
-    // native state update.
-    auto clonedChildNode = baseChildNode.clone({});
-    newShadowNode.replaceChild(newChildNode, clonedChildNode, suggestedIndex);
-  } else {
-    // `newShadowNode` was cloned from react and cloned from a native state
-    // update. This child node was cloned also by react.
-    // we can't reason about this on this layer and need to keep traversing.
-    progressStateIfNecessary(shadowNode, baseChildNode);
-  }
-}
-
-static void progressStateIfNecessary(
-    ShadowNode& newShadowNode,
-    const ShadowNode& baseShadowNode) {
-  auto& newChildren = newShadowNode.getChildren();
-  auto& baseChildren = baseShadowNode.getChildren();
-
-  auto newChildrenSize = newChildren.size();
-  auto baseChildrenSize = baseChildren.size();
-  auto index = size_t{0};
-
-  for (index = 0; index < newChildrenSize && index < baseChildrenSize;
-       ++index) {
-    const auto& newChildNode = *newChildren[index];
-    const auto& baseChildNode = *baseChildren[index];
-
-    if (&newChildNode == &baseChildNode) {
-      // Nodes are identical. They are shared between `newShadowNode` and
-      // `baseShadowNode` and it is safe to skipping.
-      continue;
-    }
-
-    if (!ShadowNode::sameFamily(newChildNode, baseChildNode)) {
-      // React has changed the structure of the tree. We will realign the
-      // structure below.
-      break;
-    }
-
-    if (!baseChildNode.getTraits().check(
-            ShadowNodeTraits::Trait::ClonedByNativeStateUpdate)) {
-      // was not cloned with a new state, we can continue.
-      continue;
-    }
-
-    progressStateIfNecessary(newShadowNode, newChildNode, baseChildNode, index);
-  }
-
-  // === Realigning the tree ===
-
-  auto unprocessedBaseChildren = baseChildren.begin();
-  std::advance(unprocessedBaseChildren, index);
-  for (; index < newChildrenSize; ++index) {
-    const auto& newChildNode = *newChildren[index];
-    auto baseChildNodeIterator = std::find_if(
-        unprocessedBaseChildren,
-        baseChildren.end(),
-        [&newChildNode](auto baseChildNode) {
-          return ShadowNode::sameFamily(newChildNode, *baseChildNode);
-        });
-    if (baseChildNodeIterator == baseChildren.end()) {
-      // This must never happen and there is a mismatch between the two trees.
-      // No way of recover from this, let's just continue.
-      continue;
-    }
-
-    const auto& baseChildNode = *(*baseChildNodeIterator);
-
-    if (!baseChildNode.getTraits().check(
-            ShadowNodeTraits::Trait::ClonedByNativeStateUpdate)) {
-      // was not cloned with a new state, we can continue.
-      continue;
-    }
-
-    progressStateIfNecessary(newShadowNode, newChildNode, baseChildNode, index);
-  }
-}
-
-// --- End of State Alignment Mechanism algorithm ---
-
 /*
  * Generates (possibly) a new tree where all nodes with non-obsolete `State`
  * objects. If all `State` objects in the tree are not obsolete for the moment
@@ -340,15 +231,14 @@ CommitMode ShadowTree::getCommitMode() const {
   return commitMode_;
 }
 
-MountingCoordinator::Shared ShadowTree::getMountingCoordinator() const {
+std::shared_ptr<const MountingCoordinator> ShadowTree::getMountingCoordinator()
+    const {
   return mountingCoordinator_;
 }
 
 CommitStatus ShadowTree::commit(
     const ShadowTreeCommitTransaction& transaction,
     const CommitOptions& commitOptions) const {
-  SystraceSection s("ShadowTree::commit");
-
   [[maybe_unused]] int attempts = 0;
 
   while (true) {
@@ -368,7 +258,7 @@ CommitStatus ShadowTree::commit(
 CommitStatus ShadowTree::tryCommit(
     const ShadowTreeCommitTransaction& transaction,
     const CommitOptions& commitOptions) const {
-  SystraceSection s("ShadowTree::tryCommit");
+  SystraceSection s("ShadowTree::commit");
 
   auto telemetry = TransactionTelemetry{};
   telemetry.willCommit();
@@ -389,21 +279,16 @@ CommitStatus ShadowTree::tryCommit(
   const auto& oldRootShadowNode = oldRevision.rootShadowNode;
   auto newRootShadowNode = transaction(*oldRevision.rootShadowNode);
 
-  if (!newRootShadowNode ||
-      (commitOptions.shouldYield && commitOptions.shouldYield())) {
+  if (!newRootShadowNode) {
     return CommitStatus::Cancelled;
   }
 
   if (commitOptions.enableStateReconciliation) {
-    if (ReactNativeFeatureFlags::useStateAlignmentMechanism()) {
-      progressStateIfNecessary(*newRootShadowNode, *oldRootShadowNode);
-    } else {
-      auto updatedNewRootShadowNode =
-          progressState(*newRootShadowNode, *oldRootShadowNode);
-      if (updatedNewRootShadowNode) {
-        newRootShadowNode =
-            std::static_pointer_cast<RootShadowNode>(updatedNewRootShadowNode);
-      }
+    auto updatedNewRootShadowNode =
+        progressState(*newRootShadowNode, *oldRootShadowNode);
+    if (updatedNewRootShadowNode) {
+      newRootShadowNode =
+          std::static_pointer_cast<RootShadowNode>(updatedNewRootShadowNode);
     }
   }
 
@@ -411,8 +296,7 @@ CommitStatus ShadowTree::tryCommit(
   newRootShadowNode = delegate_.shadowTreeWillCommit(
       *this, oldRootShadowNode, newRootShadowNode);
 
-  if (!newRootShadowNode ||
-      (commitOptions.shouldYield && commitOptions.shouldYield())) {
+  if (!newRootShadowNode) {
     return CommitStatus::Cancelled;
   }
 
@@ -430,10 +314,6 @@ CommitStatus ShadowTree::tryCommit(
     // Updating `currentRevision_` in unique manner if it hasn't changed.
     std::unique_lock lock(commitMutex_);
 
-    if (commitOptions.shouldYield && commitOptions.shouldYield()) {
-      return CommitStatus::Cancelled;
-    }
-
     if (ReactNativeFeatureFlags::
             enableGranularShadowTreeStateReconciliation()) {
       auto lastRevisionNumberWithNewStateChanged =

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -66,10 +66,6 @@ class ShadowTree final {
     // will then let React run layout effects and apply updates before paint.
     // For all other commits, should be true.
     bool mountSynchronously{true};
-
-    // Called during `tryCommit` phase. Returning true indicates current commit
-    // should yield to the next commit.
-    std::function<bool()> shouldYield;
   };
 
   /*
@@ -127,11 +123,10 @@ class ShadowTree final {
   /**
    * Forces the ShadowTree to ping its delegate that an update is available.
    * Useful for animations on Android.
-   * @return
    */
   void notifyDelegatesOfUpdates() const;
 
-  MountingCoordinator::Shared getMountingCoordinator() const;
+  std::shared_ptr<const MountingCoordinator> getMountingCoordinator() const;
 
  private:
   constexpr static ShadowTreeRevision::Number INITIAL_REVISION{0};
@@ -149,7 +144,7 @@ class ShadowTree final {
   mutable ShadowTreeRevision currentRevision_; // Protected by `commitMutex_`.
   mutable ShadowTreeRevision::Number
       lastRevisionNumberWithNewState_; // Protected by `commitMutex_`.
-  MountingCoordinator::Shared mountingCoordinator_;
+  std::shared_ptr<const MountingCoordinator> mountingCoordinator_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/mounting/ShadowTreeDelegate.h

@@ -33,7 +33,7 @@ class ShadowTreeDelegate {
    * Called right after Shadow Tree commit a new state of the tree.
    */
   virtual void shadowTreeDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) const = 0;
 
   virtual ~ShadowTreeDelegate() noexcept = default;

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

@@ -77,12 +77,4 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
 
 #endif
 
-bool ShadowViewNodePair::operator==(const ShadowViewNodePair& rhs) const {
-  return this->shadowNode == rhs.shadowNode;
-}
-
-bool ShadowViewNodePair::operator!=(const ShadowViewNodePair& rhs) const {
-  return !(*this == rhs);
-}
-
 } // namespace facebook::react

package/ReactCommon/react/renderer/mounting/ShadowView.h

@@ -57,50 +57,6 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
 
 #endif
 
-/*
- * Describes pair of a `ShadowView` and a `ShadowNode`.
- * This is not exposed to the mounting layer.
- *
- */
-struct ShadowViewNodePair final {
-  using NonOwningList = std::vector<ShadowViewNodePair*>;
-
-  ShadowView shadowView;
-  const ShadowNode* shadowNode;
-
-  /**
-   * The ShadowNode does not form a stacking context, and the native views
-   * corresponding to its children may be parented to an ancestor.
-   */
-  bool flattened{false};
-
-  /**
-   * Whether this ShadowNode should create a corresponding native view.
-   */
-  bool isConcreteView{true};
-  Point contextOrigin{0, 0};
-
-  size_t mountIndex{0};
-
-  /**
-   * This is nullptr unless `inOtherTree` is set to true.
-   * We rely on this only for marginal cases. TODO: could we
-   * rely on this more heavily to simplify the diffing algorithm
-   * overall?
-   */
-  mutable const ShadowViewNodePair* otherTreePair{nullptr};
-
-  /*
-   * The stored pointer to `ShadowNode` represents an identity of the pair.
-   */
-  bool operator==(const ShadowViewNodePair& rhs) const;
-  bool operator!=(const ShadowViewNodePair& rhs) const;
-
-  bool inOtherTree() const {
-    return this->otherTreePair != nullptr;
-  }
-};
-
 } // namespace facebook::react
 
 namespace std {

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.cpp

@@ -257,9 +257,9 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
   google::FlushLogFiles(google::GLOG_INFO);
 }
 
-std::ostream& StubViewTree::dumpTags(std::ostream& stream) {
+std::ostream& StubViewTree::dumpTags(std::ostream& stream) const {
   for (const auto& pair : registry_) {
-    auto& stubView = *registry_.at(pair.first);
+    auto& stubView = *pair.second;
     stream << "[" << stubView.tag << "]##"
            << std::hash<ShadowView>{}((ShadowView)stubView) << " ";
   }
@@ -273,10 +273,10 @@ bool operator==(const StubViewTree& lhs, const StubViewTree& rhs) {
                  << lhs.registry_.size() << " RHS: " << rhs.registry_.size();
 
       LOG(ERROR) << "Tags in LHS: ";
-      lhs.dumpTagsHash(LOG(ERROR));
+      lhs.dumpTags(LOG(ERROR));
 
       LOG(ERROR) << "Tags in RHS: ";
-      rhs.dumpTagsHash(LOG(ERROR));
+      rhs.dumpTags(LOG(ERROR));
     });
 
     return false;

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.h

@@ -41,7 +41,7 @@ class StubViewTree {
   friend bool operator==(const StubViewTree& lhs, const StubViewTree& rhs);
   friend bool operator!=(const StubViewTree& lhs, const StubViewTree& rhs);
 
-  std::ostream& dumpTags(std::ostream& stream);
+  std::ostream& dumpTags(std::ostream& stream) const;
 
   bool hasTag(Tag tag) const {
     return registry_.find(tag) != registry_.end();

package/ReactCommon/react/renderer/mounting/stubs/stubs.h

@@ -8,8 +8,8 @@
 #pragma once
 
 #include <react/renderer/core/ShadowNode.h>
-#include "StubView.h"
-#include "StubViewTree.h"
+#include <react/renderer/mounting/stubs/StubView.h>
+#include <react/renderer/mounting/stubs/StubViewTree.h>
 
 namespace facebook::react {
 

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

@@ -252,8 +252,8 @@ TEST_F(StackingContextTest, mostPropsDoNotForceViewsToMaterialize) {
 
   mutateViewShadowNodeProps_(nodeAA_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.setPadding(yoga::Edge::All, yoga::value::points(42));
-    yogaStyle.setMargin(yoga::Edge::All, yoga::value::points(42));
+    yogaStyle.setPadding(yoga::Edge::All, yoga::StyleLength::points(42));
+    yogaStyle.setMargin(yoga::Edge::All, yoga::StyleLength::points(42));
     yogaStyle.setPositionType(yoga::PositionType::Absolute);
     props.shadowRadius = 42;
     props.shadowOffset = Size{42, 42};
@@ -264,7 +264,7 @@ TEST_F(StackingContextTest, mostPropsDoNotForceViewsToMaterialize) {
     auto& yogaStyle = props.yogaStyle;
     props.zIndex = 42;
     yogaStyle.setPositionType(yoga::PositionType::Static);
-    yogaStyle.setMargin(yoga::Edge::All, yoga::value::points(42));
+    yogaStyle.setMargin(yoga::Edge::All, yoga::StyleLength::points(42));
     props.shadowColor = clearColor();
     props.shadowOpacity = 0.42;
   });