react-native 0.0.0-201c10733 → 0.0.0-268efb102

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

@@ -9,22 +9,35 @@
 
 #include <better/map.h>
 #include <better/small_vector.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <algorithm>
 #include "ShadowView.h"
 
-// Uncomment this to enable verbose diffing logs, which can be useful for
-// debugging.
-// #define DEBUG_LOGS_DIFFER
-
 #ifdef DEBUG_LOGS_DIFFER
 #include <glog/logging.h>
+#define DEBUG_LOGS_BREADCRUMBS 1
 #define DEBUG_LOGS(code) code
 #else
 #define DEBUG_LOGS(code)
 #endif
 
+#ifdef DEBUG_LOGS_BREADCRUMBS
+#define BREADCRUMB_TYPE std::string
+#define DIFF_BREADCRUMB(X) (breadcrumb + " - " + std::string(X))
+#define CREATE_DIFF_BREADCRUMB(X) std::to_string(X)
+#else
+
+enum class NoBreadcrumb {};
+
+#define BREADCRUMB_TYPE NoBreadcrumb const &
+#define DIFF_BREADCRUMB(X) \
+  {}
+#define CREATE_DIFF_BREADCRUMB(X) \
+  {}
+#endif
+
 namespace facebook {
 namespace react {
 
@@ -86,7 +99,7 @@ class TinyMap final {
   inline Iterator find(KeyT key) {
     cleanVector();
 
-    assert(key != 0);
+    react_native_assert(key != 0);
 
     if (begin_() == nullptr) {
       return end();
@@ -102,7 +115,7 @@ class TinyMap final {
   }
 
   inline void insert(Pair pair) {
-    assert(pair.first != 0);
+    react_native_assert(pair.first != 0);
     vector_.push_back(pair);
   }
 
@@ -156,30 +169,31 @@ class TinyMap final {
   }
 
   better::small_vector<Pair, DefaultSize> vector_;
-  int numErased_{0};
-  int erasedAtFront_{0};
+  size_t numErased_{0};
+  size_t erasedAtFront_{0};
 };
 
 /*
  * Sorting comparator for `reorderInPlaceIfNeeded`.
  */
 static bool shouldFirstPairComesBeforeSecondOne(
-    ShadowViewNodePair const &lhs,
-    ShadowViewNodePair const &rhs) noexcept {
-  return lhs.shadowNode->getOrderIndex() < rhs.shadowNode->getOrderIndex();
+    ShadowViewNodePair const *lhs,
+    ShadowViewNodePair const *rhs) noexcept {
+  return lhs->shadowNode->getOrderIndex() < rhs->shadowNode->getOrderIndex();
 }
 
 /*
  * Reorders pairs in-place based on `orderIndex` using a stable sort algorithm.
  */
-static void reorderInPlaceIfNeeded(ShadowViewNodePair::List &pairs) noexcept {
+static void reorderInPlaceIfNeeded(
+    ShadowViewNodePair::NonOwningList &pairs) noexcept {
   if (pairs.size() < 2) {
     return;
   }
 
   auto isReorderNeeded = false;
   for (auto const &pair : pairs) {
-    if (pair.shadowNode->getOrderIndex() != 0) {
+    if (pair->shadowNode->getOrderIndex() != 0) {
       isReorderNeeded = true;
       break;
     }
@@ -193,8 +207,13 @@ static void reorderInPlaceIfNeeded(ShadowViewNodePair::List &pairs) noexcept {
       pairs.begin(), pairs.end(), &shouldFirstPairComesBeforeSecondOne);
 }
 
+static inline bool shadowNodeIsConcrete(ShadowNode const &shadowNode) {
+  return shadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView);
+}
+
 static void sliceChildShadowNodeViewPairsRecursivelyV2(
-    ShadowViewNodePair::List &pairList,
+    ShadowViewNodePair::NonOwningList &pairList,
+    ViewNodePairScope &scope,
     Point layoutOffset,
     ShadowNode const &shadowNode) {
   for (auto const &sharedChildShadowNode : shadowNode.getChildren()) {
@@ -218,25 +237,34 @@ static void sliceChildShadowNodeViewPairsRecursivelyV2(
     // This might not be a FormsView, or a FormsStackingContext. We let the
     // differ handle removal of flattened views from the Mounting layer and
     // shuffling their children around.
-    bool isConcreteView =
-        childShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView);
+    bool isConcreteView = shadowNodeIsConcrete(childShadowNode);
     bool areChildrenFlattened = !childShadowNode.getTraits().check(
         ShadowNodeTraits::Trait::FormsStackingContext);
-    pairList.push_back(
-        {shadowView, &childShadowNode, areChildrenFlattened, isConcreteView});
-
-    if (!childShadowNode.getTraits().check(
-            ShadowNodeTraits::Trait::FormsStackingContext)) {
+    Point storedOrigin = {};
+    if (areChildrenFlattened) {
+      storedOrigin = origin;
+    }
+    scope.push_back(
+        {shadowView,
+         &childShadowNode,
+         areChildrenFlattened,
+         isConcreteView,
+         storedOrigin});
+    pairList.push_back(&scope.back());
+
+    if (areChildrenFlattened) {
       sliceChildShadowNodeViewPairsRecursivelyV2(
-          pairList, origin, childShadowNode);
+          pairList, scope, origin, childShadowNode);
     }
   }
 }
 
-ShadowViewNodePair::List sliceChildShadowNodeViewPairsV2(
+ShadowViewNodePair::NonOwningList sliceChildShadowNodeViewPairsV2(
     ShadowNode const &shadowNode,
-    bool allowFlattened) {
-  auto pairList = ShadowViewNodePair::List{};
+    ViewNodePairScope &scope,
+    bool allowFlattened,
+    Point layoutOffset) {
+  auto pairList = ShadowViewNodePair::NonOwningList{};
 
   if (!shadowNode.getTraits().check(
           ShadowNodeTraits::Trait::FormsStackingContext) &&
@@ -245,23 +273,41 @@ ShadowViewNodePair::List sliceChildShadowNodeViewPairsV2(
     return pairList;
   }
 
-  sliceChildShadowNodeViewPairsRecursivelyV2(pairList, {0, 0}, shadowNode);
+  sliceChildShadowNodeViewPairsRecursivelyV2(
+      pairList, scope, layoutOffset, shadowNode);
 
   // Sorting pairs based on `orderIndex` if needed.
   reorderInPlaceIfNeeded(pairList);
 
   // Set list and mountIndex for each after reordering
   size_t mountIndex = 0;
-  for (auto &child : pairList) {
-    child.mountIndex = (child.isConcreteView ? mountIndex++ : -1);
+  for (auto child : pairList) {
+    child->mountIndex = (child->isConcreteView ? mountIndex++ : -1);
   }
 
   return pairList;
 }
 
+/**
+ * Prefer calling this over `sliceChildShadowNodeViewPairsV2` directly, when
+ * possible. This can account for adding parent LayoutMetrics that are
+ * important to take into account, but tricky, in (un)flattening cases.
+ */
+static ShadowViewNodePair::NonOwningList
+sliceChildShadowNodeViewPairsFromViewNodePair(
+    ShadowViewNodePair const &shadowViewNodePair,
+    ViewNodePairScope &scope,
+    bool allowFlattened = false) {
+  return sliceChildShadowNodeViewPairsV2(
+      *shadowViewNodePair.shadowNode,
+      scope,
+      allowFlattened,
+      shadowViewNodePair.contextOrigin);
+}
+
 /*
- * Before we start to diff, let's make sure all our core data structures are in
- * good shape to deliver the best performance.
+ * Before we start to diff, let's make sure all our core data structures are
+ * in good shape to deliver the best performance.
  */
 static_assert(
     std::is_move_constructible<ShadowViewMutation>::value,
@@ -273,8 +319,8 @@ static_assert(
     std::is_move_constructible<ShadowViewNodePair>::value,
     "`ShadowViewNodePair` must be `move constructible`.");
 static_assert(
-    std::is_move_constructible<ShadowViewNodePair::List>::value,
-    "`ShadowViewNodePair::List` must be `move constructible`.");
+    std::is_move_constructible<ShadowViewNodePair::NonOwningList>::value,
+    "`ShadowViewNodePair::NonOwningList` must be `move constructible`.");
 
 static_assert(
     std::is_move_assignable<ShadowViewMutation>::value,
@@ -286,29 +332,52 @@ static_assert(
     std::is_move_assignable<ShadowViewNodePair>::value,
     "`ShadowViewNodePair` must be `move assignable`.");
 static_assert(
-    std::is_move_assignable<ShadowViewNodePair::List>::value,
-    "`ShadowViewNodePair::List` must be `move assignable`.");
+    std::is_move_assignable<ShadowViewNodePair::NonOwningList>::value,
+    "`ShadowViewNodePair::NonOwningList` must be `move assignable`.");
 
-// Forward declaration
 static void calculateShadowViewMutationsV2(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
     ShadowViewMutation::List &mutations,
     ShadowView const &parentShadowView,
-    ShadowViewNodePair::List &&oldChildPairs,
-    ShadowViewNodePair::List &&newChildPairs);
+    ShadowViewNodePair::NonOwningList &&oldChildPairs,
+    ShadowViewNodePair::NonOwningList &&newChildPairs);
 
 struct OrderedMutationInstructionContainer {
-  ShadowViewMutation::List &createMutations;
-  ShadowViewMutation::List &deleteMutations;
-  ShadowViewMutation::List &insertMutations;
-  ShadowViewMutation::List &removeMutations;
-  ShadowViewMutation::List &updateMutations;
-  ShadowViewMutation::List &downwardMutations;
-  ShadowViewMutation::List &destructiveDownwardMutations;
+  ShadowViewMutation::List createMutations{};
+  ShadowViewMutation::List deleteMutations{};
+  ShadowViewMutation::List insertMutations{};
+  ShadowViewMutation::List removeMutations{};
+  ShadowViewMutation::List updateMutations{};
+  ShadowViewMutation::List downwardMutations{};
+  ShadowViewMutation::List destructiveDownwardMutations{};
 };
 
+static void updateMatchedPairSubtrees(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
+    OrderedMutationInstructionContainer &mutationContainer,
+    TinyMap<Tag, ShadowViewNodePair *> &newRemainingPairs,
+    ShadowViewNodePair::NonOwningList &oldChildPairs,
+    ShadowViewNodePair::NonOwningList &newChildPairs,
+    ShadowView const &parentShadowView,
+    ShadowViewNodePair const &oldPair,
+    ShadowViewNodePair const &newPair);
+
+static void updateMatchedPair(
+    BREADCRUMB_TYPE breadcrumb,
+    OrderedMutationInstructionContainer &mutationContainer,
+    bool oldNodeFoundInOrder,
+    bool newNodeFoundInOrder,
+    ShadowView const &parentShadowView,
+    ShadowViewNodePair const &oldPair,
+    ShadowViewNodePair const &newPair);
+
 static void calculateShadowViewMutationsFlattener(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
     ReparentMode reparentMode,
-    OrderedMutationInstructionContainer &mutationInstructionContainer,
+    OrderedMutationInstructionContainer &mutationContainer,
     ShadowView const &parentShadowView,
     TinyMap<Tag, ShadowViewNodePair *> &unvisitedFlattenedNodes,
     ShadowViewNodePair const &node,
@@ -316,15 +385,210 @@ static void calculateShadowViewMutationsFlattener(
     TinyMap<Tag, ShadowViewNodePair *> *parentSubVisitedOtherOldNodes =
         nullptr);
 
+/**
+ * Updates the subtrees of any matched ShadowViewNodePair. This handles
+ * all cases of flattening/unflattening.
+ *
+ * This may modify data-structures passed to it and owned by the caller,
+ * specifically `newRemainingPairs`, and so the caller must also own
+ * the ViewNodePairScope used within.
+ */
+static void updateMatchedPairSubtrees(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
+    OrderedMutationInstructionContainer &mutationContainer,
+    TinyMap<Tag, ShadowViewNodePair *> &newRemainingPairs,
+    ShadowViewNodePair::NonOwningList &oldChildPairs,
+    ShadowViewNodePair::NonOwningList &newChildPairs,
+    ShadowView const &parentShadowView,
+    ShadowViewNodePair const &oldPair,
+    ShadowViewNodePair const &newPair) {
+  // Are we flattening or unflattening either one? If node was
+  // flattened in both trees, there's no change, just continue.
+  if (oldPair.flattened && newPair.flattened) {
+    return;
+  }
+
+  // We are either flattening or unflattening this node.
+  if (oldPair.flattened != newPair.flattened) {
+    DEBUG_LOGS({
+      LOG(ERROR)
+          << "Differ: flattening or unflattening in updateMatchedPairSubtrees: ["
+          << oldPair.shadowView.tag << "] [" << newPair.shadowView.tag << "] "
+          << oldPair.flattened << " " << newPair.flattened << " with parent: ["
+          << parentShadowView.tag << "]";
+    });
+
+    // Flattening
+    if (!oldPair.flattened) {
+      // Flatten old tree into new list
+      // At the end of this loop we still want to know which of these
+      // children are visited, so we reuse the `newRemainingPairs`
+      // map.
+      calculateShadowViewMutationsFlattener(
+          DIFF_BREADCRUMB(
+              "Flatten tree " + std::to_string(parentShadowView.tag) +
+              " into list " + std::to_string(oldPair.shadowView.tag)),
+          scope,
+          ReparentMode::Flatten,
+          mutationContainer,
+          parentShadowView,
+          newRemainingPairs,
+          oldPair);
+    }
+    // Unflattening
+    else {
+      // Construct unvisited nodes map
+      auto unvisitedOldChildPairs = TinyMap<Tag, ShadowViewNodePair *>{};
+      // We don't know where all the children of oldChildPair are
+      // within oldChildPairs, but we know that they're in the same
+      // relative order. The reason for this is because of flattening
+      // + zIndex: the children could be listed before the parent,
+      // interwoven with children from other nodes, etc.
+      auto oldFlattenedNodes =
+          sliceChildShadowNodeViewPairsFromViewNodePair(oldPair, scope, true);
+      for (size_t i = 0, j = 0;
+           i < oldChildPairs.size() && j < oldFlattenedNodes.size();
+           i++) {
+        auto &oldChild = *oldChildPairs[i];
+        if (oldChild.shadowView.tag == oldFlattenedNodes[j]->shadowView.tag) {
+          unvisitedOldChildPairs.insert({oldChild.shadowView.tag, &oldChild});
+          j++;
+        }
+      }
+
+      // Unflatten old list into new tree
+      calculateShadowViewMutationsFlattener(
+          DIFF_BREADCRUMB(
+              "Unflatten old list " + std::to_string(parentShadowView.tag) +
+              " into new tree " + std::to_string(newPair.shadowView.tag)),
+          scope,
+          ReparentMode::Unflatten,
+          mutationContainer,
+          parentShadowView,
+          unvisitedOldChildPairs,
+          newPair);
+
+      // If old nodes were not visited, we know that we can delete
+      // them now. They will be removed from the hierarchy by the
+      // outermost loop of this function.
+      // TODO: is this necessary anymore?
+      for (auto &oldFlattenedNodePtr : oldFlattenedNodes) {
+        auto &oldFlattenedNode = *oldFlattenedNodePtr;
+        auto unvisitedOldChildPairIt =
+            unvisitedOldChildPairs.find(oldFlattenedNode.shadowView.tag);
+        if (unvisitedOldChildPairIt == unvisitedOldChildPairs.end()) {
+          // Node was visited - make sure to remove it from
+          // "newRemainingPairs" map
+          auto newRemainingIt =
+              newRemainingPairs.find(oldFlattenedNode.shadowView.tag);
+          if (newRemainingIt != newRemainingPairs.end()) {
+            newRemainingPairs.erase(newRemainingIt);
+          }
+        }
+      }
+    }
+
+    return;
+  }
+
+  // Update subtrees if View is not flattened, and if node addresses
+  // are not equal
+  if (oldPair.shadowNode != newPair.shadowNode) {
+    ViewNodePairScope innerScope{};
+    auto oldGrandChildPairs =
+        sliceChildShadowNodeViewPairsFromViewNodePair(oldPair, innerScope);
+    auto newGrandChildPairs =
+        sliceChildShadowNodeViewPairsFromViewNodePair(newPair, innerScope);
+    calculateShadowViewMutationsV2(
+        DIFF_BREADCRUMB(
+            "Non-trivial update " + std::to_string(oldPair.shadowView.tag)),
+        innerScope,
+        *(newGrandChildPairs.size()
+              ? &mutationContainer.downwardMutations
+              : &mutationContainer.destructiveDownwardMutations),
+        oldPair.shadowView,
+        std::move(oldGrandChildPairs),
+        std::move(newGrandChildPairs));
+  }
+}
+
+/**
+ * Handle updates to a matched node pair, but NOT to their subtrees.
+ *
+ * Here we have (and need) knowledge of whether a node was found during
+ * in-order traversal, or out-of-order via a map lookup. Nodes are only REMOVEd
+ * or INSERTed when they are encountered via in-order-traversal, to ensure
+ * correct ordering of INSERT and REMOVE mutations.
+ */
+static void updateMatchedPair(
+    BREADCRUMB_TYPE breadcrumb,
+    OrderedMutationInstructionContainer &mutationContainer,
+    bool oldNodeFoundInOrder,
+    bool newNodeFoundInOrder,
+    ShadowView const &parentShadowView,
+    ShadowViewNodePair const &oldPair,
+    ShadowViewNodePair const &newPair) {
+  oldPair.otherTreePair = &newPair;
+  newPair.otherTreePair = &oldPair;
+
+  // Check concrete-ness of views
+  // Create/Delete and Insert/Remove if necessary
+  if (oldPair.isConcreteView != newPair.isConcreteView) {
+    if (newPair.isConcreteView) {
+      if (newNodeFoundInOrder) {
+        mutationContainer.insertMutations.push_back(
+            ShadowViewMutation::InsertMutation(
+                parentShadowView,
+                newPair.shadowView,
+                static_cast<int>(newPair.mountIndex)));
+      }
+      mutationContainer.createMutations.push_back(
+          ShadowViewMutation::CreateMutation(newPair.shadowView));
+    } else {
+      if (oldNodeFoundInOrder) {
+        mutationContainer.removeMutations.push_back(
+            ShadowViewMutation::RemoveMutation(
+                parentShadowView,
+                oldPair.shadowView,
+                static_cast<int>(oldPair.mountIndex)));
+      }
+      mutationContainer.deleteMutations.push_back(
+          ShadowViewMutation::DeleteMutation(oldPair.shadowView));
+    }
+  } else if (oldPair.isConcreteView && newPair.isConcreteView) {
+    // If we found the old node by traversing, but not the new node,
+    // it means that there's some reordering requiring a REMOVE mutation.
+    if (oldNodeFoundInOrder && !newNodeFoundInOrder) {
+      mutationContainer.removeMutations.push_back(
+          ShadowViewMutation::RemoveMutation(
+              parentShadowView,
+              newPair.shadowView,
+              static_cast<int>(oldPair.mountIndex)));
+    }
+
+    // Even if node's children are flattened, it might still be a
+    // concrete view. The case where they're different is handled
+    // above.
+    if (oldPair.shadowView != newPair.shadowView) {
+      mutationContainer.updateMutations.push_back(
+          ShadowViewMutation::UpdateMutation(
+              oldPair.shadowView, newPair.shadowView));
+    }
+  }
+}
+
 /**
  * Here we flatten or unflatten a subtree, given an unflattened node in either
  * the old or new tree, and a list of flattened nodes in the other tree.
  *
- * For example: if you are Flattening, the node will be in the old tree and the
+ * For example: if you are Flattening, the node will be in the old tree and
+ the
  * list will be from the new tree. If you are Unflattening, the opposite is
  true.
 
- * It is currently not possible for ReactJS, and therefore React Native, to move
+ * It is currently not possible for ReactJS, and therefore React Native, to
+ move
  * a node *from* one parent to another without an entirely new subtree being
  * created. When we "reparent" in React Native here it is only because
  intermediate
@@ -335,7 +599,8 @@ static void calculateShadowViewMutationsFlattener(
  * expanding vertically in that way.
 
  * Sketch of algorithm:
- * 0. Create a map of nodes in the flattened list. This should be done *before*
+ * 0. Create a map of nodes in the flattened list. This should be done
+ *before*
  *    calling this function.
  * 1. Traverse the Node Subtree; remove elements from the map as they are
  *    visited in the tree.
@@ -346,13 +611,16 @@ static void calculateShadowViewMutationsFlattener(
  *    View if we're flattening.
  *    If a node is in the list but not the map, it means it's been visited and
  *    Update has already been
- *    performed in the subtree. If it *is* in the map, it means the node is not
+ *    performed in the subtree. If it *is* in the map, it means the node is
+ not
  *    * in the Tree, and should be Deleted/Created
  *    **after this function is called**, by the caller.
  */
 static void calculateShadowViewMutationsFlattener(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
     ReparentMode reparentMode,
-    OrderedMutationInstructionContainer &mutationInstructionContainer,
+    OrderedMutationInstructionContainer &mutationContainer,
     ShadowView const &parentShadowView,
     TinyMap<Tag, ShadowViewNodePair *> &unvisitedOtherNodes,
     ShadowViewNodePair const &node,
@@ -366,8 +634,8 @@ static void calculateShadowViewMutationsFlattener(
   });
 
   // Step 1: iterate through entire tree
-  ShadowViewNodePair::List treeChildren =
-      sliceChildShadowNodeViewPairsV2(*node.shadowNode);
+  ShadowViewNodePair::NonOwningList treeChildren =
+      sliceChildShadowNodeViewPairsFromViewNodePair(node, scope);
 
   DEBUG_LOGS({
     LOG(ERROR) << "Differ Flattener 1.4: "
@@ -377,9 +645,9 @@ static void calculateShadowViewMutationsFlattener(
     LOG(ERROR) << "Differ Flattener Entry: Child Pairs: ";
     std::string strTreeChildPairs;
     for (size_t k = 0; k < treeChildren.size(); k++) {
-      strTreeChildPairs.append(std::to_string(treeChildren[k].shadowView.tag));
-      strTreeChildPairs.append(treeChildren[k].isConcreteView ? "" : "'");
-      strTreeChildPairs.append(treeChildren[k].flattened ? "*" : "");
+      strTreeChildPairs.append(std::to_string(treeChildren[k]->shadowView.tag));
+      strTreeChildPairs.append(treeChildren[k]->isConcreteView ? "" : "'");
+      strTreeChildPairs.append(treeChildren[k]->flattened ? "*" : "");
       strTreeChildPairs.append(", ");
     }
     std::string strListChildPairs;
@@ -396,7 +664,8 @@ static void calculateShadowViewMutationsFlattener(
                << strListChildPairs;
   });
 
-  // Views in other tree that are visited by sub-flattening or sub-unflattening
+  // Views in other tree that are visited by sub-flattening or
+  // sub-unflattening
   TinyMap<Tag, ShadowViewNodePair *> subVisitedOtherNewNodes{};
   TinyMap<Tag, ShadowViewNodePair *> subVisitedOtherOldNodes{};
   auto subVisitedNewMap =
@@ -413,28 +682,7 @@ static void calculateShadowViewMutationsFlattener(
   for (size_t index = 0;
        index < treeChildren.size() && index < treeChildren.size();
        index++) {
-    // First, remove all children of the tree being flattened, or insert
-    // children into parent tree if they're being unflattened. Then, look up
-    // each node in the "unvisited" list and update the nodes and subtrees if
-    // appropriate.
-    auto &treeChildPair = treeChildren[index];
-
-    //  Caller will take care of the corresponding action in the other tree.
-    if (treeChildPair.isConcreteView) {
-      if (reparentMode == ReparentMode::Flatten) {
-        mutationInstructionContainer.removeMutations.push_back(
-            ShadowViewMutation::RemoveMutation(
-                node.shadowView,
-                treeChildPair.shadowView,
-                treeChildPair.mountIndex));
-      } else {
-        mutationInstructionContainer.insertMutations.push_back(
-            ShadowViewMutation::InsertMutation(
-                node.shadowView,
-                treeChildPair.shadowView,
-                treeChildPair.mountIndex));
-      }
-    }
+    auto &treeChildPair = *treeChildren[index];
 
     // Try to find node in other tree
     auto unvisitedIt = unvisitedOtherNodes.find(treeChildPair.shadowView.tag);
@@ -443,14 +691,129 @@ static void calculateShadowViewMutationsFlattener(
              ? subVisitedNewMap->find(treeChildPair.shadowView.tag)
              : subVisitedNewMap->end());
     auto subVisitedOtherOldIt =
-        (unvisitedIt == unvisitedOtherNodes.end()
+        (unvisitedIt == unvisitedOtherNodes.end() && subVisitedNewMap->end()
              ? subVisitedOldMap->find(treeChildPair.shadowView.tag)
              : subVisitedOldMap->end());
 
-    // Find in other tree
-    if (unvisitedIt != unvisitedOtherNodes.end() ||
+    bool existsInOtherTree = unvisitedIt != unvisitedOtherNodes.end() ||
         subVisitedOtherNewIt != subVisitedNewMap->end() ||
-        subVisitedOtherOldIt != subVisitedOldMap->end()) {
+        subVisitedOtherOldIt != subVisitedOldMap->end();
+
+    auto otherTreeNodePairPtr =
+        (existsInOtherTree
+             ? (unvisitedIt != unvisitedOtherNodes.end()
+                    ? unvisitedIt->second
+                    : (subVisitedOtherNewIt != subVisitedNewMap->end()
+                           ? subVisitedOtherNewIt->second
+                           : subVisitedOtherOldIt->second))
+             : nullptr);
+
+    react_native_assert(
+        !existsInOtherTree ||
+        (unvisitedIt != unvisitedOtherNodes.end() ||
+         subVisitedOtherNewIt != subVisitedNewMap->end() ||
+         subVisitedOtherOldIt != subVisitedOldMap->end()));
+    react_native_assert(
+        unvisitedIt == unvisitedOtherNodes.end() ||
+        unvisitedIt->second->shadowView.tag == treeChildPair.shadowView.tag);
+    react_native_assert(
+        subVisitedOtherNewIt == subVisitedNewMap->end() ||
+        subVisitedOtherNewIt->second->shadowView.tag ==
+            treeChildPair.shadowView.tag);
+    react_native_assert(
+        subVisitedOtherOldIt == subVisitedOldMap->end() ||
+        subVisitedOtherOldIt->second->shadowView.tag ==
+            treeChildPair.shadowView.tag);
+
+    bool alreadyUpdated = false;
+
+    // Find in other tree and updated `otherTreePair` pointers
+    if (existsInOtherTree) {
+      react_native_assert(otherTreeNodePairPtr != nullptr);
+      auto newTreeNodePair =
+          (reparentMode == ReparentMode::Flatten ? otherTreeNodePairPtr
+                                                 : &treeChildPair);
+      auto oldTreeNodePair =
+          (reparentMode == ReparentMode::Flatten ? &treeChildPair
+                                                 : otherTreeNodePairPtr);
+
+      react_native_assert(newTreeNodePair->shadowView.tag != 0);
+      react_native_assert(oldTreeNodePair->shadowView.tag != 0);
+      react_native_assert(
+          oldTreeNodePair->shadowView.tag == newTreeNodePair->shadowView.tag);
+
+      alreadyUpdated =
+          newTreeNodePair->inOtherTree() || oldTreeNodePair->inOtherTree();
+
+      // We want to update these values unconditionally. Always do this
+      // before hitting any "continue" statements.
+      newTreeNodePair->otherTreePair = oldTreeNodePair;
+      oldTreeNodePair->otherTreePair = newTreeNodePair;
+      react_native_assert(treeChildPair.otherTreePair != nullptr);
+    }
+
+    // Remove all children (non-recursively) of tree being flattened, or
+    // insert children into parent tree if they're being unflattened.
+    //  Caller will take care of the corresponding action in the other tree
+    //  (caller will handle DELETE case if we REMOVE here; caller will handle
+    //  CREATE case if we INSERT here).
+    if (treeChildPair.isConcreteView) {
+      if (reparentMode == ReparentMode::Flatten) {
+        // treeChildPair.shadowView represents the "old" view in this case.
+        // If there's a "new" view, an UPDATE new -> old will be generated
+        // and will be executed before the REMOVE. Thus, we must actually
+        // perform a REMOVE (new view) FROM (old index) in this case so that
+        // we don't hit asserts in StubViewTree's REMOVE path.
+        // We also only do this if the "other" (newer) view is concrete. If
+        // it's not concrete, there will be no UPDATE mutation.
+        react_native_assert(existsInOtherTree == treeChildPair.inOtherTree());
+        if (treeChildPair.inOtherTree() &&
+            treeChildPair.otherTreePair->isConcreteView) {
+          mutationContainer.removeMutations.push_back(
+              ShadowViewMutation::RemoveMutation(
+                  node.shadowView,
+                  treeChildPair.otherTreePair->shadowView,
+                  static_cast<int>(treeChildPair.mountIndex)));
+        } else {
+          mutationContainer.removeMutations.push_back(
+              ShadowViewMutation::RemoveMutation(
+                  node.shadowView,
+                  treeChildPair.shadowView,
+                  static_cast<int>(treeChildPair.mountIndex)));
+        }
+      } else {
+        // treeChildParent represents the "new" version of the node, so
+        // we can safely insert it without checking in the other tree
+        mutationContainer.insertMutations.push_back(
+            ShadowViewMutation::InsertMutation(
+                node.shadowView,
+                treeChildPair.shadowView,
+                static_cast<int>(treeChildPair.mountIndex)));
+      }
+    }
+
+    // Find in other tree
+    if (existsInOtherTree) {
+      react_native_assert(otherTreeNodePairPtr != nullptr);
+      auto &otherTreeNodePair = *otherTreeNodePairPtr;
+
+      auto &newTreeNodePair =
+          (reparentMode == ReparentMode::Flatten ? otherTreeNodePair
+                                                 : treeChildPair);
+      auto &oldTreeNodePair =
+          (reparentMode == ReparentMode::Flatten ? treeChildPair
+                                                 : otherTreeNodePair);
+
+      react_native_assert(newTreeNodePair.shadowView.tag != 0);
+      react_native_assert(oldTreeNodePair.shadowView.tag != 0);
+      react_native_assert(
+          oldTreeNodePair.shadowView.tag == newTreeNodePair.shadowView.tag);
+
+      // If we've already done updates, don't repeat it.
+      if (alreadyUpdated) {
+        continue;
+      }
+
       // If we've already done updates on this node, don't repeat.
       if (reparentMode == ReparentMode::Flatten &&
           unvisitedIt == unvisitedOtherNodes.end() &&
@@ -463,28 +826,13 @@ static void calculateShadowViewMutationsFlattener(
         continue;
       }
 
-      auto &otherTreeNodePair =
-          *(unvisitedIt != unvisitedOtherNodes.end()
-                ? unvisitedIt->second
-                : (subVisitedOtherNewIt != subVisitedNewMap->end()
-                       ? subVisitedOtherNewIt->second
-                       : subVisitedOtherOldIt->second));
-
-      // If we've already done updates, don't repeat it.
-      if (treeChildPair.inOtherTree || otherTreeNodePair.inOtherTree) {
-        continue;
-      }
-
-      auto &newTreeNodePair =
-          (reparentMode == ReparentMode::Flatten ? otherTreeNodePair
-                                                 : treeChildPair);
-      auto &oldTreeNodePair =
-          (reparentMode == ReparentMode::Flatten ? treeChildPair
-                                                 : otherTreeNodePair);
-
+      // TODO: compare ShadowNode pointer instead of ShadowView here?
+      // Or ShadowNode ptr comparison before comparing ShadowView, to allow for
+      // short-circuiting? ShadowView comparison is relatively expensive vs
+      // ShadowNode.
       if (newTreeNodePair.shadowView != oldTreeNodePair.shadowView &&
           newTreeNodePair.isConcreteView && oldTreeNodePair.isConcreteView) {
-        mutationInstructionContainer.updateMutations.push_back(
+        mutationContainer.updateMutations.push_back(
             ShadowViewMutation::UpdateMutation(
                 oldTreeNodePair.shadowView, newTreeNodePair.shadowView));
       }
@@ -492,15 +840,22 @@ static void calculateShadowViewMutationsFlattener(
       // Update children if appropriate.
       if (!oldTreeNodePair.flattened && !newTreeNodePair.flattened) {
         if (oldTreeNodePair.shadowNode != newTreeNodePair.shadowNode) {
+          ViewNodePairScope innerScope{};
           calculateShadowViewMutationsV2(
-              mutationInstructionContainer.downwardMutations,
+              DIFF_BREADCRUMB(
+                  "(Un)Flattener trivial update of " +
+                  std::to_string(newTreeNodePair.shadowView.tag)),
+              innerScope,
+              mutationContainer.downwardMutations,
               newTreeNodePair.shadowView,
-              sliceChildShadowNodeViewPairsV2(*oldTreeNodePair.shadowNode),
-              sliceChildShadowNodeViewPairsV2(*newTreeNodePair.shadowNode));
+              sliceChildShadowNodeViewPairsFromViewNodePair(
+                  oldTreeNodePair, innerScope),
+              sliceChildShadowNodeViewPairsFromViewNodePair(
+                  newTreeNodePair, innerScope));
         }
       } else if (oldTreeNodePair.flattened != newTreeNodePair.flattened) {
-        // We need to handle one of the children being flattened or unflattened,
-        // in the context of a parent flattening or unflattening.
+        // We need to handle one of the children being flattened or
+        // unflattened, in the context of a parent flattening or unflattening.
         ReparentMode childReparentMode =
             (oldTreeNodePair.flattened ? ReparentMode::Unflatten
                                        : ReparentMode::Flatten);
@@ -509,8 +864,20 @@ static void calculateShadowViewMutationsFlattener(
         // This is a flatten-flatten, or unflatten-unflatten.
         if (childReparentMode == reparentMode) {
           calculateShadowViewMutationsFlattener(
+              DIFF_BREADCRUMB(
+                  std::string(
+                      reparentMode == ReparentMode::Flatten
+                          ? "Flatten-Flatten"
+                          : "Unflatten-Unflatten") +
+                  " new:" +
+                  std::to_string(
+                      reparentMode == ReparentMode::Flatten
+                          ? parentShadowView.tag
+                          : newTreeNodePair.shadowView.tag) +
+                  " old:" + std::to_string(treeChildPair.shadowView.tag)),
+              scope,
               childReparentMode,
-              mutationInstructionContainer,
+              mutationContainer,
               (reparentMode == ReparentMode::Flatten
                    ? parentShadowView
                    : newTreeNodePair.shadowView),
@@ -519,89 +886,72 @@ static void calculateShadowViewMutationsFlattener(
               subVisitedNewMap,
               subVisitedOldMap);
         } else {
-          // Unflatten parent, flatten child
-          if (childReparentMode == ReparentMode::Flatten) {
-            // Construct unvisited nodes map
-            auto unvisitedNewChildPairs = TinyMap<Tag, ShadowViewNodePair *>{};
-            // Memory note: these oldFlattenedNodes all disappear at the end of
-            // this "else" block, including any annotations we put on them.
-            auto newFlattenedNodes = sliceChildShadowNodeViewPairsV2(
-                *newTreeNodePair.shadowNode, true);
-            for (size_t i = 0; i < newFlattenedNodes.size(); i++) {
-              auto &newChild = newFlattenedNodes[i];
-
-              auto unvisitedOtherNodesIt =
-                  unvisitedOtherNodes.find(newChild.shadowView.tag);
-              if (unvisitedOtherNodesIt != unvisitedOtherNodes.end()) {
-                auto &unvisitedItPair = *unvisitedOtherNodesIt->second;
-                unvisitedNewChildPairs.insert(
-                    {unvisitedItPair.shadowView.tag, &unvisitedItPair});
-              } else {
-                unvisitedNewChildPairs.insert(
-                    {newChild.shadowView.tag, &newChild});
-              }
+          // Get flattened nodes from either new or old tree
+          auto flattenedNodes = sliceChildShadowNodeViewPairsFromViewNodePair(
+              (childReparentMode == ReparentMode::Flatten ? newTreeNodePair
+                                                          : oldTreeNodePair),
+              scope,
+              true);
+          // Construct unvisited nodes map
+          auto unvisitedRecursiveChildPairs =
+              TinyMap<Tag, ShadowViewNodePair *>{};
+          for (size_t i = 0; i < flattenedNodes.size(); i++) {
+            auto &newChild = *flattenedNodes[i];
+
+            auto unvisitedOtherNodesIt =
+                unvisitedOtherNodes.find(newChild.shadowView.tag);
+            if (unvisitedOtherNodesIt != unvisitedOtherNodes.end()) {
+              auto unvisitedItPair = *unvisitedOtherNodesIt->second;
+              unvisitedRecursiveChildPairs.insert(
+                  {unvisitedItPair.shadowView.tag, &unvisitedItPair});
+            } else {
+              unvisitedRecursiveChildPairs.insert(
+                  {newChild.shadowView.tag, &newChild});
             }
+          }
 
+          // Unflatten parent, flatten child
+          if (childReparentMode == ReparentMode::Flatten) {
             // Flatten old tree into new list
             // At the end of this loop we still want to know which of these
             // children are visited, so we reuse the `newRemainingPairs` map.
             calculateShadowViewMutationsFlattener(
+                DIFF_BREADCRUMB(
+                    std::string("Flatten old tree into new list; new:") +
+                    std::to_string(
+                        reparentMode == ReparentMode::Flatten
+                            ? parentShadowView.tag
+                            : newTreeNodePair.shadowView.tag) +
+                    " old:" + std::to_string(oldTreeNodePair.shadowView.tag)),
+                scope,
                 ReparentMode::Flatten,
-                mutationInstructionContainer,
+                mutationContainer,
                 (reparentMode == ReparentMode::Flatten
                      ? parentShadowView
                      : newTreeNodePair.shadowView),
-                unvisitedNewChildPairs,
+                unvisitedRecursiveChildPairs,
                 oldTreeNodePair,
                 subVisitedNewMap,
                 subVisitedOldMap);
-
-            for (auto &newFlattenedNode : newFlattenedNodes) {
-              auto unvisitedOldChildPairIt =
-                  unvisitedNewChildPairs.find(newFlattenedNode.shadowView.tag);
-
-              if (unvisitedOldChildPairIt == unvisitedNewChildPairs.end()) {
-                // Node was visited.
-
-                auto deleteCreateIt = deletionCreationCandidatePairs.find(
-                    newFlattenedNode.shadowView.tag);
-                if (deleteCreateIt != deletionCreationCandidatePairs.end()) {
-                  deletionCreationCandidatePairs.erase(deleteCreateIt);
-                }
-              }
-            }
           }
           // Flatten parent, unflatten child
           else {
-            // Construct unvisited nodes map
-            auto unvisitedOldChildPairs = TinyMap<Tag, ShadowViewNodePair *>{};
-            // Memory note: these oldFlattenedNodes all disappear at the end of
-            // this "else" block, including any annotations we put on them.
-            auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
-                *oldTreeNodePair.shadowNode, true);
-            for (size_t i = 0; i < oldFlattenedNodes.size(); i++) {
-              auto &oldChild = oldFlattenedNodes[i];
-
-              auto unvisitedOtherNodesIt =
-                  unvisitedOtherNodes.find(oldChild.shadowView.tag);
-              if (unvisitedOtherNodesIt != unvisitedOtherNodes.end()) {
-                auto &unvisitedItPair = *unvisitedOtherNodesIt->second;
-                unvisitedOldChildPairs.insert(
-                    {unvisitedItPair.shadowView.tag, &unvisitedItPair});
-              } else {
-                unvisitedOldChildPairs.insert(
-                    {oldChild.shadowView.tag, &oldChild});
-              }
-            }
-
             // Unflatten old list into new tree
             calculateShadowViewMutationsFlattener(
+                DIFF_BREADCRUMB(
+                    "Unflatten old list into new tree; old:" +
+                    std::to_string(
+                        reparentMode == ReparentMode::Flatten
+                            ? parentShadowView.tag
+                            : newTreeNodePair.shadowView.tag) +
+                    " new:" + std::to_string(newTreeNodePair.shadowView.tag)),
+                scope,
                 ReparentMode::Unflatten,
-                mutationInstructionContainer,
+                mutationContainer,
                 (reparentMode == ReparentMode::Flatten
                      ? parentShadowView
                      : newTreeNodePair.shadowView),
-                unvisitedOldChildPairs,
+                unvisitedRecursiveChildPairs,
                 newTreeNodePair,
                 subVisitedNewMap,
                 subVisitedOldMap);
@@ -609,45 +959,24 @@ static void calculateShadowViewMutationsFlattener(
             // If old nodes were not visited, we know that we can delete them
             // now. They will be removed from the hierarchy by the outermost
             // loop of this function.
-            for (auto &oldFlattenedNode : oldFlattenedNodes) {
-              auto unvisitedOldChildPairIt =
-                  unvisitedOldChildPairs.find(oldFlattenedNode.shadowView.tag);
-              if (unvisitedOldChildPairIt != unvisitedOldChildPairs.end()) {
-                // Node unvisited - mark the entire subtree for deletion
-                if (oldFlattenedNode.isConcreteView) {
-                  auto tag = oldFlattenedNode.shadowView.tag;
-                  auto oldRemainingChildInListIt = std::find_if(
-                      treeChildren.begin(),
-                      treeChildren.end(),
-                      [&tag](ShadowViewNodePair &nodePair) {
-                        return nodePair.shadowView.tag == tag;
-                      });
-                  if (oldRemainingChildInListIt != treeChildren.end()) {
-                    auto deleteCreateIt = deletionCreationCandidatePairs.find(
-                        oldFlattenedNode.shadowView.tag);
-                    if (deleteCreateIt ==
-                        deletionCreationCandidatePairs.end()) {
-                      deletionCreationCandidatePairs.insert(
-                          {tag, &*oldRemainingChildInListIt});
-                    }
-                  } else {
-                    // TODO: we might want to remove this block. It seems
-                    // impossible to hit this logically (and empirically, after
-                    // testing on lots of randomized and pathologically
-                    // constructed trees) but I'm leaving this here out of an
-                    // abundance of caution.
-                    mutationInstructionContainer.deleteMutations.push_back(
-                        ShadowViewMutation::DeleteMutation(
-                            oldFlattenedNode.shadowView));
-
-                    calculateShadowViewMutationsV2(
-                        mutationInstructionContainer
-                            .destructiveDownwardMutations,
-                        oldFlattenedNode.shadowView,
-                        sliceChildShadowNodeViewPairsV2(
-                            *oldFlattenedNode.shadowNode),
-                        {});
-                  }
+            for (auto unvisitedOldChildPairIt =
+                     unvisitedRecursiveChildPairs.begin();
+                 unvisitedOldChildPairIt != unvisitedRecursiveChildPairs.end();
+                 unvisitedOldChildPairIt++) {
+              if (unvisitedOldChildPairIt->first == 0) {
+                continue;
+              }
+              auto &oldFlattenedNode = *unvisitedOldChildPairIt->second;
+
+              // Node unvisited - mark the entire subtree for deletion
+              if (oldFlattenedNode.isConcreteView &&
+                  !oldFlattenedNode.inOtherTree()) {
+                Tag tag = oldFlattenedNode.shadowView.tag;
+                auto deleteCreateIt = deletionCreationCandidatePairs.find(
+                    oldFlattenedNode.shadowView.tag);
+                if (deleteCreateIt == deletionCreationCandidatePairs.end()) {
+                  deletionCreationCandidatePairs.insert(
+                      {tag, &oldFlattenedNode});
                 }
               } else {
                 // Node was visited - make sure to remove it from
@@ -657,13 +986,6 @@ static void calculateShadowViewMutationsFlattener(
                 if (newRemainingIt != unvisitedOtherNodes.end()) {
                   unvisitedOtherNodes.erase(newRemainingIt);
                 }
-
-                // We also remove it from delete/creation candidates
-                auto deleteCreateIt = deletionCreationCandidatePairs.find(
-                    oldFlattenedNode.shadowView.tag);
-                if (deleteCreateIt != deletionCreationCandidatePairs.end()) {
-                  deletionCreationCandidatePairs.erase(deleteCreateIt);
-                }
               }
             }
           }
@@ -674,35 +996,23 @@ static void calculateShadowViewMutationsFlattener(
       // concrete view. Removing the node from the unvisited list prevents the
       // caller from taking further action on this node, so make sure to
       // delete/create if the Concreteness of the node has changed.
-      if (newTreeNodePair.isConcreteView != oldTreeNodePair.isConcreteView &&
-          !newTreeNodePair.inOtherTree) {
+      if (newTreeNodePair.isConcreteView != oldTreeNodePair.isConcreteView) {
         if (newTreeNodePair.isConcreteView) {
-          mutationInstructionContainer.createMutations.push_back(
+          mutationContainer.createMutations.push_back(
               ShadowViewMutation::CreateMutation(newTreeNodePair.shadowView));
         } else {
-          mutationInstructionContainer.deleteMutations.push_back(
-              ShadowViewMutation::DeleteMutation(newTreeNodePair.shadowView));
+          mutationContainer.deleteMutations.push_back(
+              ShadowViewMutation::DeleteMutation(oldTreeNodePair.shadowView));
         }
       }
 
-      treeChildPair.inOtherTree = true;
-      otherTreeNodePair.inOtherTree = true;
-
-      if (parentSubVisitedOtherNewNodes != nullptr) {
-        parentSubVisitedOtherNewNodes->insert(
-            {newTreeNodePair.shadowView.tag, &newTreeNodePair});
-      }
-      if (parentSubVisitedOtherOldNodes != nullptr) {
-        parentSubVisitedOtherOldNodes->insert(
-            {oldTreeNodePair.shadowView.tag, &oldTreeNodePair});
-      }
-
-      if (unvisitedIt != unvisitedOtherNodes.end()) {
-        unvisitedOtherNodes.erase(unvisitedIt);
-      }
+      subVisitedNewMap->insert(
+          {newTreeNodePair.shadowView.tag, &newTreeNodePair});
+      subVisitedOldMap->insert(
+          {oldTreeNodePair.shadowView.tag, &oldTreeNodePair});
     } else {
       // Node does not in exist in other tree.
-      if (treeChildPair.isConcreteView && !treeChildPair.inOtherTree) {
+      if (treeChildPair.isConcreteView && !treeChildPair.inOtherTree()) {
         auto deletionCreationIt =
             deletionCreationCandidatePairs.find(treeChildPair.shadowView.tag);
         if (deletionCreationIt == deletionCreationCandidatePairs.end()) {
@@ -714,8 +1024,8 @@ static void calculateShadowViewMutationsFlattener(
   }
 
   // Final step: go through creation/deletion candidates and delete/create
-  // subtrees if they were never visited during the execution of the above loop
-  // and recursions.
+  // subtrees if they were never visited during the execution of the above
+  // loop and recursions.
   for (auto it = deletionCreationCandidatePairs.begin();
        it != deletionCreationCandidatePairs.end();
        it++) {
@@ -724,42 +1034,60 @@ static void calculateShadowViewMutationsFlattener(
     }
     auto &treeChildPair = *it->second;
 
-    // If node was visited during a flattening/unflattening recursion.
-    if (treeChildPair.inOtherTree) {
+    // If node was visited during a flattening/unflattening recursion,
+    // and the node in the other tree is concrete, that means it was
+    // already created/deleted and we don't need to do that here.
+    // It is always the responsibility of the matcher to update subtrees when
+    // nodes are matched.
+    if (treeChildPair.inOtherTree()) {
       continue;
     }
 
     if (reparentMode == ReparentMode::Flatten) {
-      mutationInstructionContainer.deleteMutations.push_back(
+      mutationContainer.deleteMutations.push_back(
           ShadowViewMutation::DeleteMutation(treeChildPair.shadowView));
 
       if (!treeChildPair.flattened) {
+        ViewNodePairScope innerScope{};
         calculateShadowViewMutationsV2(
-            mutationInstructionContainer.destructiveDownwardMutations,
+            DIFF_BREADCRUMB(
+                "Recursively delete tree child pair (flatten case): " +
+                std::to_string(treeChildPair.shadowView.tag)),
+            innerScope,
+            mutationContainer.destructiveDownwardMutations,
             treeChildPair.shadowView,
-            sliceChildShadowNodeViewPairsV2(*treeChildPair.shadowNode),
+            sliceChildShadowNodeViewPairsFromViewNodePair(
+                treeChildPair, innerScope),
             {});
       }
     } else {
-      mutationInstructionContainer.createMutations.push_back(
+      mutationContainer.createMutations.push_back(
           ShadowViewMutation::CreateMutation(treeChildPair.shadowView));
 
       if (!treeChildPair.flattened) {
+        ViewNodePairScope innerScope{};
         calculateShadowViewMutationsV2(
-            mutationInstructionContainer.downwardMutations,
+            DIFF_BREADCRUMB(
+                "Recursively delete tree child pair (unflatten case): " +
+                std::to_string(treeChildPair.shadowView.tag)),
+            innerScope,
+            mutationContainer.downwardMutations,
             treeChildPair.shadowView,
             {},
-            sliceChildShadowNodeViewPairsV2(*treeChildPair.shadowNode));
+            sliceChildShadowNodeViewPairsFromViewNodePair(
+                treeChildPair, innerScope));
       }
     }
   }
 }
 
 static void calculateShadowViewMutationsV2(
+    BREADCRUMB_TYPE breadcrumb,
+    ViewNodePairScope &scope,
     ShadowViewMutation::List &mutations,
     ShadowView const &parentShadowView,
-    ShadowViewNodePair::List &&oldChildPairs,
-    ShadowViewNodePair::List &&newChildPairs) {
+    ShadowViewNodePair::NonOwningList &&oldChildPairs,
+    ShadowViewNodePair::NonOwningList &&newChildPairs) {
   if (oldChildPairs.empty() && newChildPairs.empty()) {
     return;
   }
@@ -767,21 +1095,7 @@ static void calculateShadowViewMutationsV2(
   size_t index = 0;
 
   // Lists of mutations
-  auto createMutations = ShadowViewMutation::List{};
-  auto deleteMutations = ShadowViewMutation::List{};
-  auto insertMutations = ShadowViewMutation::List{};
-  auto removeMutations = ShadowViewMutation::List{};
-  auto updateMutations = ShadowViewMutation::List{};
-  auto downwardMutations = ShadowViewMutation::List{};
-  auto destructiveDownwardMutations = ShadowViewMutation::List{};
-  auto mutationInstructionContainer = OrderedMutationInstructionContainer{
-      createMutations,
-      deleteMutations,
-      insertMutations,
-      removeMutations,
-      updateMutations,
-      downwardMutations,
-      destructiveDownwardMutations};
+  auto mutationContainer = OrderedMutationInstructionContainer{};
 
   DEBUG_LOGS({
     LOG(ERROR) << "Differ Entry: Child Pairs of node: [" << parentShadowView.tag
@@ -789,19 +1103,19 @@ static void calculateShadowViewMutationsV2(
     std::string strOldChildPairs;
     for (size_t oldIndex = 0; oldIndex < oldChildPairs.size(); oldIndex++) {
       strOldChildPairs.append(
-          std::to_string(oldChildPairs[oldIndex].shadowView.tag));
+          std::to_string(oldChildPairs[oldIndex]->shadowView.tag));
       strOldChildPairs.append(
-          oldChildPairs[oldIndex].isConcreteView ? "" : "'");
-      strOldChildPairs.append(oldChildPairs[oldIndex].flattened ? "*" : "");
+          oldChildPairs[oldIndex]->isConcreteView ? "" : "'");
+      strOldChildPairs.append(oldChildPairs[oldIndex]->flattened ? "*" : "");
       strOldChildPairs.append(", ");
     }
     std::string strNewChildPairs;
     for (size_t newIndex = 0; newIndex < newChildPairs.size(); newIndex++) {
       strNewChildPairs.append(
-          std::to_string(newChildPairs[newIndex].shadowView.tag));
+          std::to_string(newChildPairs[newIndex]->shadowView.tag));
       strNewChildPairs.append(
-          newChildPairs[newIndex].isConcreteView ? "" : "'");
-      strNewChildPairs.append(newChildPairs[newIndex].flattened ? "*" : "");
+          newChildPairs[newIndex]->isConcreteView ? "" : "'");
+      strNewChildPairs.append(newChildPairs[newIndex]->flattened ? "*" : "");
       strNewChildPairs.append(", ");
     }
     LOG(ERROR) << "Differ Entry: Old Child Pairs: " << strOldChildPairs;
@@ -811,8 +1125,8 @@ static void calculateShadowViewMutationsV2(
   // Stage 1: Collecting `Update` mutations
   for (index = 0; index < oldChildPairs.size() && index < newChildPairs.size();
        index++) {
-    auto &oldChildPair = oldChildPairs[index];
-    auto &newChildPair = newChildPairs[index];
+    auto &oldChildPair = *oldChildPairs[index];
+    auto &newChildPair = *newChildPairs[index];
 
     if (oldChildPair.shadowView.tag != newChildPair.shadowView.tag) {
       DEBUG_LOGS({
@@ -826,8 +1140,8 @@ static void calculateShadowViewMutationsV2(
       break;
     }
 
-    // If either view was flattened, and that has changed this frame, don't try
-    // to update
+    // If either view was flattened, and that has changed this frame, don't
+    // try to update
     if (oldChildPair.flattened != newChildPair.flattened ||
         oldChildPair.isConcreteView != newChildPair.isConcreteView) {
       break;
@@ -846,20 +1160,27 @@ static void calculateShadowViewMutationsV2(
 
     if (newChildPair.isConcreteView &&
         oldChildPair.shadowView != newChildPair.shadowView) {
-      updateMutations.push_back(ShadowViewMutation::UpdateMutation(
-          oldChildPair.shadowView, newChildPair.shadowView));
+      mutationContainer.updateMutations.push_back(
+          ShadowViewMutation::UpdateMutation(
+              oldChildPair.shadowView, newChildPair.shadowView));
     }
 
     // Recursively update tree if ShadowNode pointers are not equal
     if (!oldChildPair.flattened &&
         oldChildPair.shadowNode != newChildPair.shadowNode) {
-      auto oldGrandChildPairs =
-          sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
-      auto newGrandChildPairs =
-          sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
+      ViewNodePairScope innerScope{};
+      auto oldGrandChildPairs = sliceChildShadowNodeViewPairsFromViewNodePair(
+          oldChildPair, innerScope);
+      auto newGrandChildPairs = sliceChildShadowNodeViewPairsFromViewNodePair(
+          newChildPair, innerScope);
       calculateShadowViewMutationsV2(
-          *(newGrandChildPairs.size() ? &downwardMutations
-                                      : &destructiveDownwardMutations),
+          DIFF_BREADCRUMB(
+              "Stage 1: Recurse on " +
+              std::to_string(oldChildPair.shadowView.tag)),
+          innerScope,
+          *(newGrandChildPairs.size()
+                ? &mutationContainer.downwardMutations
+                : &mutationContainer.destructiveDownwardMutations),
           oldChildPair.shadowView,
           std::move(oldGrandChildPairs),
           std::move(newGrandChildPairs));
@@ -872,7 +1193,7 @@ static void calculateShadowViewMutationsV2(
     // We've reached the end of the new children. We can delete+remove the
     // rest.
     for (; index < oldChildPairs.size(); index++) {
-      auto const &oldChildPair = oldChildPairs[index];
+      auto const &oldChildPair = *oldChildPairs[index];
 
       DEBUG_LOGS({
         LOG(ERROR) << "Differ Branch 2: Deleting Tag/Tree: ["
@@ -884,24 +1205,32 @@ static void calculateShadowViewMutationsV2(
         continue;
       }
 
-      deleteMutations.push_back(
+      mutationContainer.deleteMutations.push_back(
           ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
-      removeMutations.push_back(ShadowViewMutation::RemoveMutation(
-          parentShadowView, oldChildPair.shadowView, oldChildPair.mountIndex));
+      mutationContainer.removeMutations.push_back(
+          ShadowViewMutation::RemoveMutation(
+              parentShadowView,
+              oldChildPair.shadowView,
+              static_cast<int>(oldChildPair.mountIndex)));
 
       // We also have to call the algorithm recursively to clean up the entire
       // subtree starting from the removed view.
+      ViewNodePairScope innerScope{};
       calculateShadowViewMutationsV2(
-          destructiveDownwardMutations,
+          DIFF_BREADCRUMB(
+              "Trivial delete " + std::to_string(oldChildPair.shadowView.tag)),
+          innerScope,
+          mutationContainer.destructiveDownwardMutations,
           oldChildPair.shadowView,
-          sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode),
+          sliceChildShadowNodeViewPairsFromViewNodePair(
+              oldChildPair, innerScope),
           {});
     }
   } else if (index == oldChildPairs.size()) {
     // If we don't have any more existing children we can choose a fast path
     // since the rest will all be create+insert.
     for (; index < newChildPairs.size(); index++) {
-      auto const &newChildPair = newChildPairs[index];
+      auto const &newChildPair = *newChildPairs[index];
 
       DEBUG_LOGS({
         LOG(ERROR) << "Differ Branch 3: Creating Tag/Tree: ["
@@ -913,16 +1242,24 @@ static void calculateShadowViewMutationsV2(
         continue;
       }
 
-      insertMutations.push_back(ShadowViewMutation::InsertMutation(
-          parentShadowView, newChildPair.shadowView, newChildPair.mountIndex));
-      createMutations.push_back(
+      mutationContainer.insertMutations.push_back(
+          ShadowViewMutation::InsertMutation(
+              parentShadowView,
+              newChildPair.shadowView,
+              static_cast<int>(newChildPair.mountIndex)));
+      mutationContainer.createMutations.push_back(
           ShadowViewMutation::CreateMutation(newChildPair.shadowView));
 
+      ViewNodePairScope innerScope{};
       calculateShadowViewMutationsV2(
-          downwardMutations,
+          DIFF_BREADCRUMB(
+              "Trivial create " + std::to_string(newChildPair.shadowView.tag)),
+          innerScope,
+          mutationContainer.downwardMutations,
           newChildPair.shadowView,
           {},
-          sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode));
+          sliceChildShadowNodeViewPairsFromViewNodePair(
+              newChildPair, innerScope));
     }
   } else {
     // Collect map of tags in the new list
@@ -930,7 +1267,7 @@ static void calculateShadowViewMutationsV2(
     auto newInsertedPairs = TinyMap<Tag, ShadowViewNodePair *>{};
     auto deletionCandidatePairs = TinyMap<Tag, ShadowViewNodePair const *>{};
     for (; index < newChildPairs.size(); index++) {
-      auto &newChildPair = newChildPairs[index];
+      auto &newChildPair = *newChildPairs[index];
       newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
     }
 
@@ -946,8 +1283,8 @@ static void calculateShadowViewMutationsV2(
 
       // Advance both pointers if pointing to the same element
       if (haveNewPair && haveOldPair) {
-        auto const &oldChildPair = oldChildPairs[oldIndex];
-        auto const &newChildPair = newChildPairs[newIndex];
+        auto const &oldChildPair = *oldChildPairs[oldIndex];
+        auto const &newChildPair = *newChildPairs[newIndex];
 
         Tag newTag = newChildPair.shadowView.tag;
         Tag oldTag = oldChildPair.shadowView.tag;
@@ -965,139 +1302,29 @@ static void calculateShadowViewMutationsV2(
                        << " with parent: [" << parentShadowView.tag << "]";
           });
 
-          // Check concrete-ness of views
-          // Create/Delete and Insert/Remove if necessary
-          if (oldChildPair.isConcreteView != newChildPair.isConcreteView) {
-            if (newChildPair.isConcreteView) {
-              insertMutations.push_back(ShadowViewMutation::InsertMutation(
-                  parentShadowView,
-                  newChildPair.shadowView,
-                  newChildPair.mountIndex));
-              createMutations.push_back(
-                  ShadowViewMutation::CreateMutation(newChildPair.shadowView));
-            } else {
-              removeMutations.push_back(ShadowViewMutation::RemoveMutation(
-                  parentShadowView,
-                  oldChildPair.shadowView,
-                  oldChildPair.mountIndex));
-              deleteMutations.push_back(
-                  ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
-            }
-          } else if (
-              oldChildPair.isConcreteView && newChildPair.isConcreteView) {
-            // Even if node's children are flattened, it might still be a
-            // concrete view. The case where they're different is handled above.
-            if (oldChildPair.shadowView != newChildPair.shadowView) {
-              updateMutations.push_back(ShadowViewMutation::UpdateMutation(
-                  oldChildPair.shadowView, newChildPair.shadowView));
-            }
-
-            // Remove from newRemainingPairs
-            auto newRemainingPairIt = newRemainingPairs.find(oldTag);
-            if (newRemainingPairIt != newRemainingPairs.end()) {
-              newRemainingPairs.erase(newRemainingPairIt);
-            }
-          }
-
-          // Are we flattening or unflattening either one? If node was flattened
-          // in both trees, there's no change, just continue.
-          if (oldChildPair.flattened && newChildPair.flattened) {
-            newIndex++;
-            oldIndex++;
-            continue;
-          }
-          // We are either flattening or unflattening this node.
-          if (oldChildPair.flattened != newChildPair.flattened) {
-            DEBUG_LOGS({
-              LOG(ERROR) << "Differ: flattening or unflattening at branch 6: ["
-                         << oldChildPair.shadowView.tag << "] ["
-                         << newChildPair.shadowView.tag << "] "
-                         << oldChildPair.flattened << " "
-                         << newChildPair.flattened << " with parent: ["
-                         << parentShadowView.tag << "]";
-            });
-
-            // Flattening
-            if (!oldChildPair.flattened) {
-              // Flatten old tree into new list
-              // At the end of this loop we still want to know which of these
-              // children are visited, so we reuse the `newRemainingPairs` map.
-              calculateShadowViewMutationsFlattener(
-                  ReparentMode::Flatten,
-                  mutationInstructionContainer,
-                  parentShadowView,
-                  newRemainingPairs,
-                  oldChildPair);
-            }
-            // Unflattening
-            else {
-              // Construct unvisited nodes map
-              auto unvisitedOldChildPairs =
-                  TinyMap<Tag, ShadowViewNodePair *>{};
-              // We don't know where all the children of oldChildPair are within
-              // oldChildPairs, but we know that they're in the same relative
-              // order. The reason for this is because of flattening + zIndex:
-              // the children could be listed before the parent, interwoven with
-              // children from other nodes, etc.
-              auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
-                  *oldChildPair.shadowNode, true);
-              for (size_t i = 0, j = 0;
-                   i < oldChildPairs.size() && j < oldFlattenedNodes.size();
-                   i++) {
-                auto &oldChild = oldChildPairs[i];
-                if (oldChild.shadowView.tag ==
-                    oldFlattenedNodes[j].shadowView.tag) {
-                  unvisitedOldChildPairs.insert(
-                      {oldChild.shadowView.tag, &oldChild});
-                  j++;
-                }
-              }
-
-              // Unflatten old list into new tree
-              calculateShadowViewMutationsFlattener(
-                  ReparentMode::Unflatten,
-                  mutationInstructionContainer,
-                  parentShadowView,
-                  unvisitedOldChildPairs,
-                  newChildPair);
-
-              // If old nodes were not visited, we know that we can delete them
-              // now. They will be removed from the hierarchy by the outermost
-              // loop of this function.
-              for (auto &oldFlattenedNode : oldFlattenedNodes) {
-                auto unvisitedOldChildPairIt = unvisitedOldChildPairs.find(
-                    oldFlattenedNode.shadowView.tag);
-                if (unvisitedOldChildPairIt == unvisitedOldChildPairs.end()) {
-                  // Node was visited - make sure to remove it from
-                  // "newRemainingPairs" map
-                  auto newRemainingIt =
-                      newRemainingPairs.find(oldFlattenedNode.shadowView.tag);
-                  if (newRemainingIt != newRemainingPairs.end()) {
-                    newRemainingPairs.erase(newRemainingIt);
-                  }
-                }
-              }
-            }
-
-            newIndex++;
-            oldIndex++;
-            continue;
-          }
-
-          // Update subtrees if View is not flattened, and if node addresses are
-          // not equal
-          if (oldChildPair.shadowNode != newChildPair.shadowNode) {
-            auto oldGrandChildPairs =
-                sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
-            auto newGrandChildPairs =
-                sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
-            calculateShadowViewMutationsV2(
-                *(newGrandChildPairs.size() ? &downwardMutations
-                                            : &destructiveDownwardMutations),
-                oldChildPair.shadowView,
-                std::move(oldGrandChildPairs),
-                std::move(newGrandChildPairs));
-          }
+          updateMatchedPair(
+              DIFF_BREADCRUMB(
+                  "Update Matched Pairs (1): " +
+                  std::to_string(oldChildPair.shadowView.tag)),
+              mutationContainer,
+              true,
+              true,
+              parentShadowView,
+              oldChildPair,
+              newChildPair);
+
+          updateMatchedPairSubtrees(
+              DIFF_BREADCRUMB(
+                  "Update Matched Pair Subtrees (1): " +
+                  std::to_string(oldChildPair.shadowView.tag)),
+              scope,
+              mutationContainer,
+              newRemainingPairs,
+              oldChildPairs,
+              newChildPairs,
+              parentShadowView,
+              oldChildPair,
+              newChildPair);
 
           newIndex++;
           oldIndex++;
@@ -1108,7 +1335,7 @@ static void calculateShadowViewMutationsV2(
       // We have an old pair, but we either don't have any remaining new pairs
       // or we have one but it's not matched up with the old pair
       if (haveOldPair) {
-        auto const &oldChildPair = oldChildPairs[oldIndex];
+        auto const &oldChildPair = *oldChildPairs[oldIndex];
 
         Tag oldTag = oldChildPair.shadowView.tag;
 
@@ -1120,145 +1347,29 @@ static void calculateShadowViewMutationsV2(
         if (insertedIt != newInsertedPairs.end()) {
           auto const &newChildPair = *insertedIt->second;
 
-          // The node has been reordered and we are also flattening or
-          // unflattening
-          if (oldChildPair.flattened != newChildPair.flattened) {
-            DEBUG_LOGS({
-              LOG(ERROR)
-                  << "Differ: branch 7: Flattening or unflattening already-inserted node upon remove (move/reorder operation)."
-                  << oldChildPair.shadowView.tag << " "
-                  << oldChildPair.flattened << " // "
-                  << newChildPair.shadowView.tag << " "
-                  << newChildPair.flattened;
-            });
-
-            // Unflattening.
-            // The node in question was already inserted and we are
-            // *unflattening* it, so we just need to update the subtree nodes
-            // and remove them from the view hierarchy. Any of the unvisited
-            // nodes in the old tree will be deleted.
-            // TODO: can we consolidate this code? It's identical to the first
-            // block above.
-            if (!oldChildPair.flattened) {
-              // Flatten old tree into new list
-              // At the end of this loop we still want to know which of these
-              // children are visited, so we reuse the `newRemainingPairs` map.
-              calculateShadowViewMutationsFlattener(
-                  ReparentMode::Flatten,
-                  mutationInstructionContainer,
-                  parentShadowView,
-                  newRemainingPairs,
-                  oldChildPair);
-            }
-            // Unflattening
-            else {
-              // Construct unvisited nodes map
-              auto unvisitedOldChildPairs =
-                  TinyMap<Tag, ShadowViewNodePair *>{};
-              // We don't know where all the children of oldChildPair are within
-              // oldChildPairs, but we know that they're in the same relative
-              // order. The reason for this is because of flattening + zIndex:
-              // the children could be listed before the parent, interwoven with
-              // children from other nodes, etc.
-              auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
-                  *oldChildPair.shadowNode, true);
-              for (size_t i = 0, j = 0;
-                   i < oldChildPairs.size() && j < oldFlattenedNodes.size();
-                   i++) {
-                auto &oldChild = oldChildPairs[i];
-                if (oldChild.shadowView.tag ==
-                    oldFlattenedNodes[j].shadowView.tag) {
-                  unvisitedOldChildPairs.insert(
-                      {oldChild.shadowView.tag, &oldChild});
-                  j++;
-                }
-              }
-
-              // Unflatten old list into new tree
-              calculateShadowViewMutationsFlattener(
-                  ReparentMode::Unflatten,
-                  mutationInstructionContainer,
-                  parentShadowView,
-                  unvisitedOldChildPairs,
-                  newChildPair);
-
-              // If old nodes were not visited, we know that we can delete them
-              // now. They will be removed from the hierarchy by the outermost
-              // loop of this function. TODO: delete recursively? create
-              // recursively?
-              for (auto &oldFlattenedNode : oldFlattenedNodes) {
-                auto unvisitedOldChildPairIt = unvisitedOldChildPairs.find(
-                    oldFlattenedNode.shadowView.tag);
-                if (unvisitedOldChildPairIt == unvisitedOldChildPairs.end()) {
-                  // Node was visited - make sure to remove it from
-                  // "newRemainingPairs" map
-                  auto newRemainingIt =
-                      newRemainingPairs.find(oldFlattenedNode.shadowView.tag);
-                  if (newRemainingIt != newRemainingPairs.end()) {
-                    newRemainingPairs.erase(newRemainingIt);
-                  }
-                }
-              }
-            }
-          }
-
-          // Check concrete-ness of views
-          // Create/Delete and Insert/Remove if necessary
-          // TODO: document: Insert should already be handled by outermost loop,
-          // but not Remove
-          if (oldChildPair.isConcreteView != newChildPair.isConcreteView) {
-            if (newChildPair.isConcreteView) {
-              createMutations.push_back(
-                  ShadowViewMutation::CreateMutation(newChildPair.shadowView));
-            } else {
-              removeMutations.push_back(ShadowViewMutation::RemoveMutation(
-                  parentShadowView,
-                  oldChildPair.shadowView,
-                  oldChildPair.mountIndex));
-              deleteMutations.push_back(
-                  ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
-            }
-          }
-
-          // We handled this case above. We fall through to check concreteness
-          // of old/new view to remove/insert create/delete above, and then bail
-          // out here.
-          if (oldChildPair.flattened != newChildPair.flattened) {
-            newInsertedPairs.erase(insertedIt);
-            oldIndex++;
-            continue;
-          }
-
-          // old and new child pairs are both either flattened or unflattened at
-          // this point. If they're not views, we don't need to update subtrees.
-          if (oldChildPair.isConcreteView) {
-            // TODO: do we always want to remove here? There are cases where we
-            // might be able to remove this to prevent unnecessary
-            // removes/inserts in cases of (un)flattening + reorders?
-            removeMutations.push_back(ShadowViewMutation::RemoveMutation(
-                parentShadowView,
-                oldChildPair.shadowView,
-                oldChildPair.mountIndex));
-
-            if (oldChildPair.shadowView != newChildPair.shadowView) {
-              updateMutations.push_back(ShadowViewMutation::UpdateMutation(
-                  oldChildPair.shadowView, newChildPair.shadowView));
-            }
-          }
-          if (!oldChildPair.flattened &&
-              oldChildPair.shadowNode != newChildPair.shadowNode) {
-            // Update subtrees
-            auto oldGrandChildPairs =
-                sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
-            auto newGrandChildPairs =
-                sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
-            calculateShadowViewMutationsV2(
-                *(newGrandChildPairs.size() ? &downwardMutations
-                                            : &destructiveDownwardMutations),
-                oldChildPair.shadowView,
-                std::move(oldGrandChildPairs),
-                std::move(newGrandChildPairs));
-          }
+          updateMatchedPair(
+              DIFF_BREADCRUMB(
+                  "Update Matched Pairs (2): " +
+                  std::to_string(oldChildPair.shadowView.tag)),
+              mutationContainer,
+              true,
+              false,
+              parentShadowView,
+              oldChildPair,
+              newChildPair);
+
+          updateMatchedPairSubtrees(
+              DIFF_BREADCRUMB(
+                  "Update Matched Pair Subtrees (2): " +
+                  std::to_string(oldChildPair.shadowView.tag)),
+              scope,
+              mutationContainer,
+              newRemainingPairs,
+              oldChildPairs,
+              newChildPairs,
+              parentShadowView,
+              oldChildPair,
+              newChildPair);
 
           newInsertedPairs.erase(insertedIt);
           oldIndex++;
@@ -1270,26 +1381,61 @@ static void calculateShadowViewMutationsV2(
         // generate remove+delete for this node and its subtree.
         auto const newIt = newRemainingPairs.find(oldTag);
         if (newIt == newRemainingPairs.end()) {
+          oldIndex++;
+
+          if (!oldChildPair.isConcreteView) {
+            continue;
+          }
+
+          // From here, we know the oldChildPair is concrete.
+          // We *probably* need to generate a REMOVE mutation (see edge-case
+          // notes below).
+
           DEBUG_LOGS({
             LOG(ERROR)
                 << "Differ Branch 9: Removing tag that was not reinserted: "
                 << oldIndex << ": [" << oldChildPair.shadowView.tag << "]"
                 << (oldChildPair.flattened ? " (flattened)" : "")
                 << (oldChildPair.isConcreteView ? " (concrete)" : "")
-                << " with parent: [" << parentShadowView.tag << "]";
+                << " with parent: [" << parentShadowView.tag << "] "
+                << "node is in other tree? "
+                << (oldChildPair.inOtherTree() ? "yes" : "no");
           });
 
-          if (oldChildPair.isConcreteView) {
-            removeMutations.push_back(ShadowViewMutation::RemoveMutation(
-                parentShadowView,
-                oldChildPair.shadowView,
-                oldChildPair.mountIndex));
-
-            deletionCandidatePairs.insert(
-                {oldChildPair.shadowView.tag, &oldChildPair});
+          // Edge case: node is not found in `newRemainingPairs`, due to
+          // complex (un)flattening cases, but exists in other tree *and* is
+          // concrete.
+          if (oldChildPair.inOtherTree() &&
+              oldChildPair.otherTreePair->isConcreteView) {
+            ShadowView const &otherTreeView =
+                oldChildPair.otherTreePair->shadowView;
+
+            // Remove, but remove using the *new* node, since we know
+            // an UPDATE mutation from old -> new has been generated.
+            // Practically this shouldn't matter for most mounting layer
+            // implementations, but helps adhere to the invariant that
+            // for all mutation instructions, "oldViewShadowNode" == "current
+            // node on mounting layer / stubView".
+            // Here we do *not" need to generate a potential DELETE mutation
+            // because we know the view is concrete, and still in the new
+            // hierarchy.
+            mutationContainer.removeMutations.push_back(
+                ShadowViewMutation::RemoveMutation(
+                    parentShadowView,
+                    otherTreeView,
+                    static_cast<int>(oldChildPair.mountIndex)));
+            continue;
           }
 
-          oldIndex++;
+          mutationContainer.removeMutations.push_back(
+              ShadowViewMutation::RemoveMutation(
+                  parentShadowView,
+                  oldChildPair.shadowView,
+                  static_cast<int>(oldChildPair.mountIndex)));
+
+          deletionCandidatePairs.insert(
+              {oldChildPair.shadowView.tag, &oldChildPair});
+
           continue;
         }
       }
@@ -1297,7 +1443,7 @@ static void calculateShadowViewMutationsV2(
       // At this point, oldTag is -1 or is in the new list, and hasn't been
       // inserted or matched yet. We're not sure yet if the new node is in the
       // old list - generate an insert instruction for the new node.
-      auto &newChildPair = newChildPairs[newIndex];
+      auto &newChildPair = *newChildPairs[newIndex];
       DEBUG_LOGS({
         LOG(ERROR)
             << "Differ Branch 10: Inserting tag/tree that was not (yet?) removed from hierarchy: "
@@ -1308,21 +1454,29 @@ static void calculateShadowViewMutationsV2(
             << " with parent: [" << parentShadowView.tag << "]";
       });
       if (newChildPair.isConcreteView) {
-        insertMutations.push_back(ShadowViewMutation::InsertMutation(
-            parentShadowView,
-            newChildPair.shadowView,
-            newChildPair.mountIndex));
+        mutationContainer.insertMutations.push_back(
+            ShadowViewMutation::InsertMutation(
+                parentShadowView,
+                newChildPair.shadowView,
+                static_cast<int>(newChildPair.mountIndex)));
       }
-      if (!newChildPair.inOtherTree) {
+
+      // `inOtherTree` is only set to true during flattening/unflattening of
+      // parent. If the parent isn't (un)flattened, this will always be
+      // `false`, even if the node is in the other (old) tree. In this case,
+      // we expect the node to be removed from `newInsertedPairs` when we
+      // later encounter it in this loop.
+      if (!newChildPair.inOtherTree()) {
         newInsertedPairs.insert({newChildPair.shadowView.tag, &newChildPair});
       }
+
       newIndex++;
     }
 
     // Penultimate step: generate Delete instructions for entirely deleted
     // subtrees/nodes. We do this here because we need to traverse the entire
-    // list to make sure that a node was not reparented into an unflattened node
-    // that occurs *after* it in the hierarchy, due to zIndex ordering.
+    // list to make sure that a node was not reparented into an unflattened
+    // node that occurs *after* it in the hierarchy, due to zIndex ordering.
     for (auto it = deletionCandidatePairs.begin();
          it != deletionCandidatePairs.end();
          it++) {
@@ -1338,27 +1492,34 @@ static void calculateShadowViewMutationsV2(
             << "[" << oldChildPair.shadowView.tag << "]"
             << (oldChildPair.flattened ? "(flattened)" : "")
             << (oldChildPair.isConcreteView ? "(concrete)" : "")
-            << (oldChildPair.inOtherTree ? "(in other tree)" : "")
-            << " with parent: [" << parentShadowView.tag << "]";
+            << (oldChildPair.inOtherTree() ? "(in other tree)" : "")
+            << " with parent: [" << parentShadowView.tag << "] ##"
+            << std::hash<ShadowView>{}(oldChildPair.shadowView);
       });
 
       // This can happen when the parent is unflattened
-      if (!oldChildPair.inOtherTree) {
-        deleteMutations.push_back(
+      if (!oldChildPair.inOtherTree() && oldChildPair.isConcreteView) {
+        mutationContainer.deleteMutations.push_back(
             ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
 
         // We also have to call the algorithm recursively to clean up the
         // entire subtree starting from the removed view.
+        ViewNodePairScope innerScope{};
         calculateShadowViewMutationsV2(
-            destructiveDownwardMutations,
+            DIFF_BREADCRUMB(
+                "Non-trivial delete " +
+                std::to_string(oldChildPair.shadowView.tag)),
+            innerScope,
+            mutationContainer.destructiveDownwardMutations,
             oldChildPair.shadowView,
-            sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode),
+            sliceChildShadowNodeViewPairsFromViewNodePair(
+                oldChildPair, innerScope),
             {});
       }
     }
 
-    // Final step: generate Create instructions for entirely new subtrees/nodes
-    // that are not the result of flattening or unflattening.
+    // Final step: generate Create instructions for entirely new
+    // subtrees/nodes that are not the result of flattening or unflattening.
     for (auto it = newInsertedPairs.begin(); it != newInsertedPairs.end();
          it++) {
       // Erased elements of a TinyMap will have a Tag/key of 0 - skip those
@@ -1377,56 +1538,62 @@ static void calculateShadowViewMutationsV2(
             << "[" << newChildPair.shadowView.tag << "]"
             << (newChildPair.flattened ? "(flattened)" : "")
             << (newChildPair.isConcreteView ? "(concrete)" : "")
-            << (newChildPair.inOtherTree ? "(in other tree)" : "")
+            << (newChildPair.inOtherTree() ? "(in other tree)" : "")
             << " with parent: [" << parentShadowView.tag << "]";
       });
 
       if (!newChildPair.isConcreteView) {
         continue;
       }
-      if (newChildPair.inOtherTree) {
+      if (newChildPair.inOtherTree()) {
         continue;
       }
 
-      createMutations.push_back(
+      mutationContainer.createMutations.push_back(
           ShadowViewMutation::CreateMutation(newChildPair.shadowView));
 
+      ViewNodePairScope innerScope{};
       calculateShadowViewMutationsV2(
-          downwardMutations,
+          DIFF_BREADCRUMB(
+              "Non-trivial create " +
+              std::to_string(newChildPair.shadowView.tag)),
+          innerScope,
+          mutationContainer.downwardMutations,
           newChildPair.shadowView,
           {},
-          sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode));
+          sliceChildShadowNodeViewPairsFromViewNodePair(
+              newChildPair, innerScope));
     }
   }
 
   // All mutations in an optimal order:
   std::move(
-      destructiveDownwardMutations.begin(),
-      destructiveDownwardMutations.end(),
+      mutationContainer.destructiveDownwardMutations.begin(),
+      mutationContainer.destructiveDownwardMutations.end(),
       std::back_inserter(mutations));
   std::move(
-      updateMutations.begin(),
-      updateMutations.end(),
+      mutationContainer.updateMutations.begin(),
+      mutationContainer.updateMutations.end(),
       std::back_inserter(mutations));
   std::move(
-      removeMutations.rbegin(),
-      removeMutations.rend(),
+      mutationContainer.removeMutations.rbegin(),
+      mutationContainer.removeMutations.rend(),
       std::back_inserter(mutations));
   std::move(
-      deleteMutations.begin(),
-      deleteMutations.end(),
+      mutationContainer.deleteMutations.begin(),
+      mutationContainer.deleteMutations.end(),
       std::back_inserter(mutations));
   std::move(
-      createMutations.begin(),
-      createMutations.end(),
+      mutationContainer.createMutations.begin(),
+      mutationContainer.createMutations.end(),
       std::back_inserter(mutations));
   std::move(
-      downwardMutations.begin(),
-      downwardMutations.end(),
+      mutationContainer.downwardMutations.begin(),
+      mutationContainer.downwardMutations.end(),
       std::back_inserter(mutations));
   std::move(
-      insertMutations.begin(),
-      insertMutations.end(),
+      mutationContainer.insertMutations.begin(),
+      mutationContainer.insertMutations.end(),
       std::back_inserter(mutations));
 }
 
@@ -1434,7 +1601,7 @@ static void calculateShadowViewMutationsV2(
  * Only used by unit tests currently.
  */
 static void sliceChildShadowNodeViewPairsRecursivelyLegacy(
-    ShadowViewNodePair::List &pairList,
+    ShadowViewNodePair::OwningList &pairList,
     Point layoutOffset,
     ShadowNode const &shadowNode) {
   for (auto const &sharedChildShadowNode : shadowNode.getChildren()) {
@@ -1473,9 +1640,9 @@ static void sliceChildShadowNodeViewPairsRecursivelyLegacy(
 /**
  * Only used by unit tests currently.
  */
-ShadowViewNodePair::List sliceChildShadowNodeViewPairsLegacy(
+ShadowViewNodePair::OwningList sliceChildShadowNodeViewPairsLegacy(
     ShadowNode const &shadowNode) {
-  auto pairList = ShadowViewNodePair::List{};
+  auto pairList = ShadowViewNodePair::OwningList{};
 
   if (!shadowNode.getTraits().check(
           ShadowNodeTraits::Trait::FormsStackingContext) &&
@@ -1494,7 +1661,12 @@ ShadowViewMutation::List calculateShadowViewMutations(
   SystraceSection s("calculateShadowViewMutations");
 
   // Root shadow nodes must be belong the same family.
-  assert(ShadowNode::sameFamily(oldRootShadowNode, newRootShadowNode));
+  react_native_assert(
+      ShadowNode::sameFamily(oldRootShadowNode, newRootShadowNode));
+
+  // See explanation of scope in Differentiator.h.
+  ViewNodePairScope viewNodePairScope{};
+  ViewNodePairScope innerViewNodePairScope{};
 
   auto mutations = ShadowViewMutation::List{};
   mutations.reserve(256);
@@ -1508,10 +1680,12 @@ ShadowViewMutation::List calculateShadowViewMutations(
   }
 
   calculateShadowViewMutationsV2(
+      CREATE_DIFF_BREADCRUMB(oldRootShadowView.tag),
+      innerViewNodePairScope,
       mutations,
       ShadowView(oldRootShadowNode),
-      sliceChildShadowNodeViewPairsV2(oldRootShadowNode),
-      sliceChildShadowNodeViewPairsV2(newRootShadowNode));
+      sliceChildShadowNodeViewPairsV2(oldRootShadowNode, viewNodePairScope),
+      sliceChildShadowNodeViewPairsV2(newRootShadowNode, viewNodePairScope));
 
   return mutations;
 }