diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp index cca684c3382..1489a6f1368 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp +++ b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp @@ -347,6 +347,17 @@ void YogaLayoutableShadowNode::updateYogaChildrenOwnersIfNeeded() { } } +// Every clone gets its own Yoga config, and `setConfig()` re-aligns the +// layout's `configVersion` with it, so that field says nothing about whether +// two nodes carry the same layout. Everything else has to match. +static bool hasSameLayoutResults( + const yoga::Node& yogaNode, + const yoga::Node& otherYogaNode) { + auto layout = yogaNode.getLayout(); + layout.configVersion = otherYogaNode.getLayout().configVersion; + return layout == otherYogaNode.getLayout(); +} + void YogaLayoutableShadowNode::updateYogaChildren() { if (getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode)) { return; @@ -386,8 +397,11 @@ void YogaLayoutableShadowNode::updateYogaChildren() { auto& newYogaChildNode = yogaLayoutableChildren_.at(yogaChildIndex)->yogaNode_; + // A clean child styled the same can still carry another layout, e.g. a + // revision zeroed out under a `display: none` clone of this node. isClean = isClean && !newYogaChildNode.isDirty() && - (newYogaChildNode.style() == oldYogaChildNode.style()); + (newYogaChildNode.style() == oldYogaChildNode.style()) && + hasSameLayoutResults(newYogaChildNode, oldYogaChildNode); } } } diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp b/packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp index b5aa3bddb8d..1e0a06b31da 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp +++ b/packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp @@ -559,6 +559,59 @@ TEST_F(YogaCloneTest, newChildrenCloneReflectsNewList) { 100); } +// A clone that is handed its children must not keep its layout when a child, +// although clean and styled the same, carries a different computed layout. +// That is the case for a child revision zeroed out under a `display: none` +// clone of the parent, which React can hold through runtime shadow node +// reference updates while it keeps cloning from the visible parent. +TEST_F(YogaCloneTest, newChildrenWithDifferentLayoutDirtyTheClone) { + auto hiddenRoot = rootShadowNode_->cloneTree( + parentShadowNode_->getFamily(), [](const ShadowNode& oldShadowNode) { + auto hiddenProps = std::make_shared(); + auto& yogaStyle = hiddenProps->yogaStyle; + yogaStyle.setFlexDirection(yoga::FlexDirection::Row); + yogaStyle.setDimension( + yoga::Dimension::Width, yoga::StyleSizeLength::points(300)); + yogaStyle.setDimension( + yoga::Dimension::Height, yoga::StyleSizeLength::points(100)); + yogaStyle.setDisplay(yoga::Display::None); + return oldShadowNode.clone({.props = hiddenProps}); + }); + static_cast(*hiddenRoot).layoutIfNeeded(); + + auto zeroedChildA = hiddenRoot->getChildren()[0]->getChildren()[0]; + ASSERT_EQ( + yogaNodeOf(*zeroedChildA).getLayout().dimension(yoga::Dimension::Width), + 0); + ASSERT_FALSE(yogaNodeOf(*zeroedChildA).isDirty()); + + auto newChildren = + std::make_shared>>( + std::vector>{ + zeroedChildA->clone({}), + parentShadowNode_->getChildren()[1], + parentShadowNode_->getChildren()[2]}); + + auto clonedParent = parentShadowNode_->clone( + {.props = ShadowNodeFragment::propsPlaceholder(), + .children = newChildren}); + + EXPECT_FALSE( + static_cast(*clonedParent) + .getIsLayoutClean()); + + auto newRootShadowNode = rootShadowNode_->cloneTree( + parentShadowNode_->getFamily(), + [&](const ShadowNode& /*oldShadowNode*/) { return clonedParent; }); + static_cast(*newRootShadowNode).layoutIfNeeded(); + + const auto& laidOutChildA = + yogaNodeOf(*newRootShadowNode->getChildren()[0]->getChildren()[0]) + .getLayout(); + EXPECT_EQ(laidOutChildA.dimension(yoga::Dimension::Width), 100); + EXPECT_EQ(laidOutChildA.dimension(yoga::Dimension::Height), 100); +} + // Successive prop-only clones (the animation commit pattern) must each // produce a self-consistent layout. Validates that the fast path's vector // copy yields a vector the next clone can again copy from. diff --git a/packages/react-native/ReactCommon/react/renderer/core/__docs__/passChildrenWhenCloning.md b/packages/react-native/ReactCommon/react/renderer/core/__docs__/passChildrenWhenCloning.md index 194a86ce11e..5b4f33c537f 100644 --- a/packages/react-native/ReactCommon/react/renderer/core/__docs__/passChildrenWhenCloning.md +++ b/packages/react-native/ReactCommon/react/renderer/core/__docs__/passChildrenWhenCloning.md @@ -48,5 +48,17 @@ of mutation. The clone implementation of the YogaLayoutableShadowNode will compare the previous set of children with the new set. If both sets have the same size and -each node has equivalent styling, the cloned node is not being dirtied for -layout. This allows for improving the layout data re-use on subsequent renders. +each new child is clean, has equivalent styling and carries the same layout +results (computed layout and layout cache) as the child it replaces, the cloned +node is not being dirtied for layout. This allows for improving the layout data +re-use on subsequent renders. + +The layout results have to be compared as well: a child can be clean and styled +the same while carrying a layout that the parent's cached layout was not +computed with. Runtime shadow node reference updates can point the renderer at +such a revision. For example, when `` hides a subtree the renderer +commits a `display: none` clone of the subtree's host root. Laying out that +clone zeroes out clones of its children, and those clones inherit the children's +runtime references, while the renderer keeps cloning from the visible host root. +Without the layout check, the next clone of that host root would keep its cached +layout and Yoga would never revisit the zeroed children.