react-native-tvos 0.74.3-0 → 0.75.2-0

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

@@ -7,16 +7,17 @@
 
 #include "ShadowTree.h"
 
+#include <cxxreact/SystraceSection.h>
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewShadowNode.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/LayoutPrimitives.h>
-#include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/mounting/ShadowTreeRevision.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 #include <react/renderer/telemetry/TransactionTelemetry.h>
-#include <react/utils/CoreFeatures.h>
+#include "updateMountedFlag.h"
 
 #include "ShadowTreeDelegate.h"
 
@@ -25,25 +26,50 @@ namespace facebook::react {
 using CommitStatus = ShadowTree::CommitStatus;
 using CommitMode = ShadowTree::CommitMode;
 
-// --- Clone-less progress state algorithm ---
+// --- 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) {
-  newShadowNode.progressStateIfNecessary();
+static void progressStateIfNecessary(
+    ShadowNode& newShadowNode,
+    const ShadowNode& baseShadowNode);
 
-  for (const auto& childNode : newShadowNode.getChildren()) {
-    progressStateIfNecessary(const_cast<ShadowNode&>(*childNode));
+/*
+ * 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) {
-  newShadowNode.progressStateIfNecessary();
-
   auto& newChildren = newShadowNode.getChildren();
   auto& baseChildren = baseShadowNode.getChildren();
 
@@ -63,21 +89,51 @@ static void progressStateIfNecessary(
     }
 
     if (!ShadowNode::sameFamily(newChildNode, baseChildNode)) {
-      // The nodes are not of the same family. Tree hierarchy has changed
-      // and we have to fall back to full sub-tree traversal from this point on.
+      // React has changed the structure of the tree. We will realign the
+      // structure below.
       break;
     }
 
-    progressStateIfNecessary(
-        const_cast<ShadowNode&>(newChildNode), baseChildNode);
+    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];
-    progressStateIfNecessary(const_cast<ShadowNode&>(newChildNode));
+    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 Clone-less progress state algorithm ---
+
+// --- End of State Alignment Mechanism algorithm ---
 
 /*
  * Generates (possibly) a new tree where all nodes with non-obsolete `State`
@@ -120,7 +176,7 @@ static ShadowNode::Unshared progressState(const ShadowNode& shadowNode) {
 
   return shadowNode.clone({
       ShadowNodeFragment::propsPlaceholder(),
-      areChildrenChanged ? std::make_shared<ShadowNode::ListOfShared const>(
+      areChildrenChanged ? std::make_shared<const ShadowNode::ListOfShared>(
                                std::move(newChildren))
                          : ShadowNodeFragment::childrenPlaceholder(),
       isStateChanged ? newState : ShadowNodeFragment::statePlaceholder(),
@@ -207,72 +263,13 @@ static ShadowNode::Unshared progressState(
 
   return shadowNode.clone({
       ShadowNodeFragment::propsPlaceholder(),
-      areChildrenChanged ? std::make_shared<ShadowNode::ListOfShared const>(
+      areChildrenChanged ? std::make_shared<const ShadowNode::ListOfShared>(
                                std::move(newChildren))
                          : ShadowNodeFragment::childrenPlaceholder(),
       isStateChanged ? newState : ShadowNodeFragment::statePlaceholder(),
   });
 }
 
-static void updateMountedFlag(
-    const ShadowNode::ListOfShared& oldChildren,
-    const ShadowNode::ListOfShared& newChildren) {
-  // This is a simplified version of Diffing algorithm that only updates
-  // `mounted` flag on `ShadowNode`s. The algorithm sets "mounted" flag before
-  // "unmounted" to allow `ShadowNode` detect a situation where the node was
-  // remounted.
-
-  if (&oldChildren == &newChildren) {
-    // Lists are identical, nothing to do.
-    return;
-  }
-
-  if (oldChildren.empty() && newChildren.empty()) {
-    // Both lists are empty, nothing to do.
-    return;
-  }
-
-  size_t index;
-
-  // Stage 1: Mount and unmount "updated" children.
-  for (index = 0; index < oldChildren.size() && index < newChildren.size();
-       index++) {
-    const auto& oldChild = oldChildren[index];
-    const auto& newChild = newChildren[index];
-
-    if (oldChild == newChild) {
-      // Nodes are identical, skipping the subtree.
-      continue;
-    }
-
-    if (!ShadowNode::sameFamily(*oldChild, *newChild)) {
-      // Totally different nodes, updating is impossible.
-      break;
-    }
-
-    newChild->setMounted(true);
-    oldChild->setMounted(false);
-
-    updateMountedFlag(oldChild->getChildren(), newChild->getChildren());
-  }
-
-  size_t lastIndexAfterFirstStage = index;
-
-  // State 2: Mount new children.
-  for (index = lastIndexAfterFirstStage; index < newChildren.size(); index++) {
-    const auto& newChild = newChildren[index];
-    newChild->setMounted(true);
-    updateMountedFlag({}, newChild->getChildren());
-  }
-
-  // State 3: Unmount old children.
-  for (index = lastIndexAfterFirstStage; index < oldChildren.size(); index++) {
-    const auto& oldChild = oldChildren[index];
-    oldChild->setMounted(false);
-    updateMountedFlag(oldChild->getChildren(), {});
-  }
-}
-
 ShadowTree::ShadowTree(
     SurfaceId surfaceId,
     const LayoutConstraints& layoutConstraints,
@@ -398,7 +395,7 @@ CommitStatus ShadowTree::tryCommit(
   }
 
   if (commitOptions.enableStateReconciliation) {
-    if (CoreFeatures::enableClonelessStateProgression) {
+    if (ReactNativeFeatureFlags::useStateAlignmentMechanism()) {
       progressStateIfNecessary(*newRootShadowNode, *oldRootShadowNode);
     } else {
       auto updatedNewRootShadowNode =
@@ -437,7 +434,8 @@ CommitStatus ShadowTree::tryCommit(
       return CommitStatus::Cancelled;
     }
 
-    if (CoreFeatures::enableGranularShadowTreeStateReconciliation) {
+    if (ReactNativeFeatureFlags::
+            enableGranularShadowTreeStateReconciliation()) {
       auto lastRevisionNumberWithNewStateChanged =
           lastRevisionNumberWithNewState != lastRevisionNumberWithNewState_;
       // Commit should only fail if we propagated the wrong state.
@@ -455,7 +453,6 @@ CommitStatus ShadowTree::tryCommit(
 
     {
       std::scoped_lock dispatchLock(EventEmitter::DispatchMutex());
-
       updateMountedFlag(
           currentRevision_.rootShadowNode->getChildren(),
           newRootShadowNode->getChildren());
@@ -465,6 +462,7 @@ CommitStatus ShadowTree::tryCommit(
     telemetry.setRevisionNumber(static_cast<int>(newRevisionNumber));
 
     // Seal the shadow node so it can no longer be mutated
+    // Does nothing in release.
     newRootShadowNode->sealRecursive();
 
     newRevision = ShadowTreeRevision{
@@ -519,15 +517,14 @@ void ShadowTree::emitLayoutEvents(
 
   for (const auto* layoutableNode : affectedLayoutableNodes) {
     // Only instances of `ViewShadowNode` (and subclasses) are supported.
-    const auto& viewShadowNode =
-        static_cast<const ViewShadowNode&>(*layoutableNode);
-    const auto& viewEventEmitter =
-        static_cast<const ViewEventEmitter&>(*viewShadowNode.getEventEmitter());
+
+    const auto& viewEventEmitter = static_cast<const BaseViewEventEmitter&>(
+        *layoutableNode->getEventEmitter());
 
     // Checking if the `onLayout` event was requested for the particular Shadow
     // Node.
     const auto& viewProps =
-        static_cast<const ViewProps&>(*viewShadowNode.getProps());
+        static_cast<const BaseViewProps&>(*layoutableNode->getProps());
     if (!viewProps.onLayout) {
       continue;
     }

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

@@ -85,14 +85,4 @@ bool ShadowViewNodePair::operator!=(const ShadowViewNodePair& rhs) const {
   return !(*this == rhs);
 }
 
-bool ShadowViewNodePairLegacy::operator==(
-    const ShadowViewNodePairLegacy& rhs) const {
-  return this->shadowNode == rhs.shadowNode;
-}
-
-bool ShadowViewNodePairLegacy::operator!=(
-    const ShadowViewNodePairLegacy& rhs) const {
-  return !(*this == rhs);
-}
-
 } // namespace facebook::react

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

@@ -64,11 +64,19 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
  */
 struct ShadowViewNodePair final {
   using NonOwningList = std::vector<ShadowViewNodePair*>;
-  using OwningList = 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};
 
@@ -93,30 +101,6 @@ struct ShadowViewNodePair final {
   }
 };
 
-/*
- * Describes pair of a `ShadowView` and a `ShadowNode`.
- * This is not exposed to the mounting layer.
- *
- */
-struct ShadowViewNodePairLegacy final {
-  using OwningList = std::vector<ShadowViewNodePairLegacy>;
-
-  ShadowView shadowView;
-  const ShadowNode* shadowNode;
-  bool flattened{false};
-  bool isConcreteView{true};
-
-  size_t mountIndex{0};
-
-  bool inOtherTree{false};
-
-  /*
-   * The stored pointer to `ShadowNode` represents an identity of the pair.
-   */
-  bool operator==(const ShadowViewNodePairLegacy& rhs) const;
-  bool operator!=(const ShadowViewNodePairLegacy& rhs) const;
-};
-
 } // namespace facebook::react
 
 namespace std {

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

@@ -0,0 +1,313 @@
+/*
+ * 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.
+ */
+
+#include "StubViewTree.h"
+
+#include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
+
+#ifdef STUB_VIEW_TREE_VERBOSE
+#define STUB_VIEW_LOG(code) code
+#else
+#define STUB_VIEW_LOG(code)
+#endif
+
+namespace facebook::react {
+
+StubViewTree::StubViewTree(const ShadowView& shadowView) {
+  auto view = std::make_shared<StubView>();
+  view->update(shadowView);
+  rootTag_ = shadowView.tag;
+  registry_[shadowView.tag] = view;
+}
+
+const StubView& StubViewTree::getRootStubView() const {
+  return *registry_.at(rootTag_);
+}
+
+const StubView& StubViewTree::getStubView(Tag tag) const {
+  return *registry_.at(tag);
+}
+
+size_t StubViewTree::size() const {
+  return registry_.size();
+}
+
+void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
+  STUB_VIEW_LOG({ LOG(ERROR) << "StubView: Mutating Begin"; });
+  for (const auto& mutation : mutations) {
+    switch (mutation.type) {
+      case ShadowViewMutation::Create: {
+        react_native_assert(mutation.parentShadowView == ShadowView{});
+        react_native_assert(mutation.oldChildShadowView == ShadowView{});
+        react_native_assert(mutation.newChildShadowView.props);
+        auto stubView = std::make_shared<StubView>();
+        stubView->update(mutation.newChildShadowView);
+        auto tag = mutation.newChildShadowView.tag;
+        STUB_VIEW_LOG({
+          LOG(ERROR) << "StubView: Create [" << tag << "] ##"
+                     << std::hash<ShadowView>{}((ShadowView)*stubView);
+        });
+        if (hasTag(tag)) {
+          LOG(ERROR) << "StubView: Create [" << tag << "]: tag already exists"
+                     << (tag == rootTag_ ? " (and it's the root tag)" : "")
+                     << ". The current registry: ";
+          dumpTags(LOG(ERROR));
+        }
+        react_native_assert(!hasTag(tag));
+        registry_[tag] = stubView;
+        break;
+      }
+
+      case ShadowViewMutation::Delete: {
+        STUB_VIEW_LOG({
+          LOG(ERROR) << "StubView: Delete [" << mutation.oldChildShadowView.tag
+                     << "] ##"
+                     << std::hash<ShadowView>{}(mutation.oldChildShadowView);
+        });
+        react_native_assert(mutation.parentShadowView == ShadowView{});
+        react_native_assert(mutation.newChildShadowView == ShadowView{});
+        auto tag = mutation.oldChildShadowView.tag;
+        react_native_assert(hasTag(tag));
+        auto stubView = registry_[tag];
+        if ((ShadowView)(*stubView) != mutation.oldChildShadowView) {
+          LOG(ERROR)
+              << "StubView: ASSERT FAILURE: DELETE mutation assertion failure: oldChildShadowView does not match stubView: ["
+              << mutation.oldChildShadowView.tag << "] stub hash: ##"
+              << std::hash<ShadowView>{}((ShadowView)*stubView)
+              << " old mutation hash: ##"
+              << std::hash<ShadowView>{}(mutation.oldChildShadowView);
+#if RN_DEBUG_STRING_CONVERTIBLE
+          LOG(ERROR) << "StubView: "
+                     << getDebugPropsDescription((ShadowView)*stubView, {});
+          LOG(ERROR) << "OldChildShadowView: "
+                     << getDebugPropsDescription(
+                            mutation.oldChildShadowView, {});
+#endif
+        }
+        react_native_assert(
+            (ShadowView)(*stubView) == mutation.oldChildShadowView);
+        registry_.erase(tag);
+        break;
+      }
+
+      case ShadowViewMutation::Insert: {
+        if (!mutation.mutatedViewIsVirtual()) {
+          react_native_assert(mutation.oldChildShadowView == ShadowView{});
+          auto parentTag = mutation.parentShadowView.tag;
+          auto childTag = mutation.newChildShadowView.tag;
+          if (!hasTag(parentTag)) {
+            LOG(ERROR)
+                << "StubView: ASSERT FAILURE: INSERT mutation assertion failure: parentTag not found: ["
+                << parentTag << "] inserting child: [" << childTag << "]";
+          }
+          if (!hasTag(childTag)) {
+            LOG(ERROR)
+                << "StubView: ASSERT FAILURE: INSERT mutation assertion failure: childTag not found: ["
+                << parentTag << "] inserting child: [" << childTag << "]";
+          }
+          react_native_assert(hasTag(parentTag));
+          auto parentStubView = registry_[parentTag];
+          react_native_assert(hasTag(childTag));
+          auto childStubView = registry_[childTag];
+          childStubView->update(mutation.newChildShadowView);
+          STUB_VIEW_LOG({
+            LOG(ERROR) << "StubView: Insert [" << childTag << "] into ["
+                       << parentTag << "] @" << mutation.index << "("
+                       << parentStubView->children.size() << " children)";
+          });
+          react_native_assert(childStubView->parentTag == NO_VIEW_TAG);
+          react_native_assert(
+              mutation.index >= 0 &&
+              parentStubView->children.size() >=
+                  static_cast<size_t>(mutation.index));
+          childStubView->parentTag = parentTag;
+          parentStubView->children.insert(
+              parentStubView->children.begin() + mutation.index, childStubView);
+        } else {
+          auto childTag = mutation.newChildShadowView.tag;
+          react_native_assert(hasTag(childTag));
+          auto childStubView = registry_[childTag];
+          childStubView->update(mutation.newChildShadowView);
+        }
+        break;
+      }
+
+      case ShadowViewMutation::Remove: {
+        if (!mutation.mutatedViewIsVirtual()) {
+          react_native_assert(mutation.newChildShadowView == ShadowView{});
+          auto parentTag = mutation.parentShadowView.tag;
+          auto childTag = mutation.oldChildShadowView.tag;
+          if (!hasTag(parentTag)) {
+            LOG(ERROR)
+                << "StubView: ASSERT FAILURE: REMOVE mutation assertion failure: parentTag not found: ["
+                << parentTag << "] removing child: [" << childTag << "]";
+          }
+          react_native_assert(hasTag(parentTag));
+          auto parentStubView = registry_[parentTag];
+          STUB_VIEW_LOG({
+            LOG(ERROR) << "StubView: Remove [" << childTag << "] from ["
+                       << parentTag << "] @" << mutation.index << " with "
+                       << parentStubView->children.size() << " children";
+          });
+          react_native_assert(
+              mutation.index >= 0 &&
+              parentStubView->children.size() >
+                  static_cast<size_t>(mutation.index));
+          react_native_assert(hasTag(childTag));
+          auto childStubView = registry_[childTag];
+          if ((ShadowView)(*childStubView) != mutation.oldChildShadowView) {
+            LOG(ERROR)
+                << "StubView: ASSERT FAILURE: REMOVE mutation assertion failure: oldChildShadowView does not match oldStubView: ["
+                << mutation.oldChildShadowView.tag << "] stub hash: ##"
+                << std::hash<ShadowView>{}((ShadowView)*childStubView)
+                << " old mutation hash: ##"
+                << std::hash<ShadowView>{}(mutation.oldChildShadowView);
+#if RN_DEBUG_STRING_CONVERTIBLE
+            LOG(ERROR) << "ChildStubView: "
+                       << getDebugPropsDescription(
+                              (ShadowView)*childStubView, {});
+            LOG(ERROR) << "OldChildShadowView: "
+                       << getDebugPropsDescription(
+                              mutation.oldChildShadowView, {});
+#endif
+          }
+          react_native_assert(
+              (ShadowView)(*childStubView) == mutation.oldChildShadowView);
+          react_native_assert(childStubView->parentTag == parentTag);
+          STUB_VIEW_LOG({
+            std::string strChildList = "";
+            int i = 0;
+            for (const auto& child : parentStubView->children) {
+              strChildList.append(std::to_string(i));
+              strChildList.append(":");
+              strChildList.append(std::to_string(child->tag));
+              strChildList.append(", ");
+              i++;
+            }
+            LOG(ERROR) << "StubView: BEFORE REMOVE: Children of " << parentTag
+                       << ": " << strChildList;
+          });
+          react_native_assert(
+              mutation.index >= 0 &&
+              parentStubView->children.size() >
+                  static_cast<size_t>(mutation.index) &&
+              parentStubView->children[mutation.index]->tag ==
+                  childStubView->tag);
+          childStubView->parentTag = NO_VIEW_TAG;
+          parentStubView->children.erase(
+              parentStubView->children.begin() + mutation.index);
+        }
+        break;
+      }
+
+      case ShadowViewMutation::RemoveDeleteTree: {
+        // TODO: do something here
+        break;
+      }
+
+      case ShadowViewMutation::Update: {
+        STUB_VIEW_LOG({
+          LOG(ERROR) << "StubView: Update [" << mutation.newChildShadowView.tag
+                     << "] old hash: ##"
+                     << std::hash<ShadowView>{}(mutation.oldChildShadowView)
+                     << " new hash: ##"
+                     << std::hash<ShadowView>{}(mutation.newChildShadowView);
+        });
+        react_native_assert(mutation.oldChildShadowView.tag != 0);
+        react_native_assert(mutation.newChildShadowView.tag != 0);
+        react_native_assert(mutation.newChildShadowView.props);
+        react_native_assert(
+            mutation.newChildShadowView.tag == mutation.oldChildShadowView.tag);
+        react_native_assert(hasTag(mutation.newChildShadowView.tag));
+        auto oldStubView = registry_[mutation.newChildShadowView.tag];
+        react_native_assert(oldStubView->tag != 0);
+        if ((ShadowView)(*oldStubView) != mutation.oldChildShadowView) {
+          LOG(ERROR)
+              << "StubView: ASSERT FAILURE: UPDATE mutation assertion failure: oldChildShadowView does not match oldStubView: ["
+              << mutation.oldChildShadowView.tag << "] old stub hash: ##"
+              << std::hash<ShadowView>{}((ShadowView)*oldStubView)
+              << " old mutation hash: ##"
+              << std::hash<ShadowView>{}(mutation.oldChildShadowView);
+#if RN_DEBUG_STRING_CONVERTIBLE
+          LOG(ERROR) << "OldStubView: "
+                     << getDebugPropsDescription((ShadowView)*oldStubView, {});
+          LOG(ERROR) << "OldChildShadowView: "
+                     << getDebugPropsDescription(
+                            mutation.oldChildShadowView, {});
+#endif
+        }
+        react_native_assert(
+            (ShadowView)(*oldStubView) == mutation.oldChildShadowView);
+        oldStubView->update(mutation.newChildShadowView);
+
+        // Hash for stub view and the ShadowView should be identical - this
+        // tests that StubView and ShadowView hash are equivalent.
+        react_native_assert(
+            std::hash<ShadowView>{}((ShadowView)*oldStubView) ==
+            std::hash<ShadowView>{}(mutation.newChildShadowView));
+
+        break;
+      }
+    }
+  }
+  STUB_VIEW_LOG({ LOG(ERROR) << "StubView: Mutating End"; });
+
+  // For iOS especially: flush logs because some might be lost on iOS if an
+  // assert is hit right after this.
+  google::FlushLogFiles(google::GLOG_INFO);
+}
+
+std::ostream& StubViewTree::dumpTags(std::ostream& stream) {
+  for (const auto& pair : registry_) {
+    auto& stubView = *registry_.at(pair.first);
+    stream << "[" << stubView.tag << "]##"
+           << std::hash<ShadowView>{}((ShadowView)stubView) << " ";
+  }
+  return stream;
+}
+
+bool operator==(const StubViewTree& lhs, const StubViewTree& rhs) {
+  if (lhs.registry_.size() != rhs.registry_.size()) {
+    STUB_VIEW_LOG({
+      LOG(ERROR) << "Registry sizes are different. Sizes: LHS: "
+                 << lhs.registry_.size() << " RHS: " << rhs.registry_.size();
+
+      LOG(ERROR) << "Tags in LHS: ";
+      lhs.dumpTagsHash(LOG(ERROR));
+
+      LOG(ERROR) << "Tags in RHS: ";
+      rhs.dumpTagsHash(LOG(ERROR));
+    });
+
+    return false;
+  }
+
+  for (const auto& pair : lhs.registry_) {
+    auto& lhsStubView = *lhs.registry_.at(pair.first);
+    auto& rhsStubView = *rhs.registry_.at(pair.first);
+
+    if (lhsStubView != rhsStubView) {
+      STUB_VIEW_LOG({
+        LOG(ERROR) << "Registry entries are different. LHS: ["
+                   << lhsStubView.tag << "] ##"
+                   << std::hash<ShadowView>{}((ShadowView)lhsStubView)
+                   << " RHS: [" << rhsStubView.tag << "] ##"
+                   << std::hash<ShadowView>{}((ShadowView)rhsStubView);
+      });
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool operator!=(const StubViewTree& lhs, const StubViewTree& rhs) {
+  return !(lhs == rhs);
+}
+
+} // namespace facebook::react