Remove yoga::Style::BitfieldRef (#41393)

Summary:
Pull Request resolved: https://github.com/facebook/react-native/pull/41393

X-link: https://github.com/facebook/yoga/pull/1459

Removes the last of the non setter-style style setters.

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D51155925

fbshipit-source-id: 2921c87d95ad36495b7013e592d5169015321545

packages/react-native/React/Tests/Text/RCTParagraphComponentViewTests.mm

@@ -133,7 +133,7 @@ using namespace facebook::react;
                     auto &props = *sharedProps;
                     props.accessible = true;
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.positionType() = yoga::PositionType::Absolute;
+                    yogaStyle.setPositionType(yoga::PositionType::Absolute);
                     yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(0));
                     yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(0));
                     yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(200));
@@ -213,7 +213,7 @@ using namespace facebook::react;
                     auto &props = *sharedProps;
                     props.accessible = true;
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.positionType() = yoga::PositionType::Absolute;
+                    yogaStyle.setPositionType(yoga::PositionType::Absolute);
                     yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(0));
                     yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(30));
                     yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(200));
@@ -257,7 +257,7 @@ using namespace facebook::react;
                     auto &props = *sharedProps;
                     props.accessible = true;
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.positionType() = yoga::PositionType::Absolute;
+                    yogaStyle.setPositionType(yoga::PositionType::Absolute);
                     yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(0));
                     yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(90));
                     yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(200));
@@ -431,7 +431,7 @@ static ParagraphShadowNode::ConcreteState::Shared stateWithShadowNode(
                                props.accessible = true;
                                props.accessibilityTraits = AccessibilityTraits::Link;
                                auto &yogaStyle = props.yogaStyle;
-                               yogaStyle.positionType() = yoga::PositionType::Absolute;
+                               yogaStyle.setPositionType(yoga::PositionType::Absolute);
                                yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(0));
                                yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(90));
                                yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(200));

packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -563,7 +563,7 @@ void YogaLayoutableShadowNode::setPositionType(
   ensureUnsealed();
 
   auto style = yogaNode_.getStyle();
-  style.positionType() = yoga::scopedEnum(positionType);
+  style.setPositionType(yoga::scopedEnum(positionType));
   yogaNode_.setStyle(style);
   yogaNode_.setDirty(true);
 }

packages/react-native/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp

@@ -49,22 +49,15 @@ static inline T const getFieldValue(
   return defaultValue;
 }
 
-#define REBUILD_FIELD_SWITCH_CASE2(field, fieldName)                       \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                          \
-    yogaStyle.field() = getFieldValue(context, value, ygDefaults.field()); \
-    return;                                                                \
-  }
-
-// @lint-ignore CLANGTIDY cppcoreguidelines-macro-usage
-#define REBUILD_FIELD_SWITCH_CASE_YSP(field) \
-  REBUILD_FIELD_SWITCH_CASE2(field, #field)
-
-#define REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(field, setter)              \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(#field): {                           \
+#define REBUILD_FIELD_SWITCH_CASE2(field, setter, fieldName)             \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                        \
     yogaStyle.setter(getFieldValue(context, value, ygDefaults.field())); \
     return;                                                              \
   }
 
+#define REBUILD_FIELD_SWITCH_CASE_YSP(field, setter) \
+  REBUILD_FIELD_SWITCH_CASE2(field, setter, #field)
+
 #define REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, setter, index, fieldName) \
   case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                             \
     yogaStyle.setter(                                                         \
@@ -138,22 +131,22 @@ void YogaStylableProps::setProp(
   Props::setProp(context, hash, propName, value);
 
   switch (hash) {
-    REBUILD_FIELD_SWITCH_CASE_YSP(direction);
-    REBUILD_FIELD_SWITCH_CASE_YSP(flexDirection);
-    REBUILD_FIELD_SWITCH_CASE_YSP(justifyContent);
-    REBUILD_FIELD_SWITCH_CASE_YSP(alignContent);
-    REBUILD_FIELD_SWITCH_CASE_YSP(alignItems);
-    REBUILD_FIELD_SWITCH_CASE_YSP(alignSelf);
-    REBUILD_FIELD_SWITCH_CASE_YSP(flexWrap);
-    REBUILD_FIELD_SWITCH_CASE_YSP(overflow);
-    REBUILD_FIELD_SWITCH_CASE_YSP(display);
-    REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(flex, setFlex);
-    REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(flexGrow, setFlexGrow);
-    REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(flexShrink, setFlexShrink);
-    REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(flexBasis, setFlexBasis);
-    REBUILD_FIELD_SWITCH_CASE2(positionType, "position");
+    REBUILD_FIELD_SWITCH_CASE_YSP(direction, setDirection);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flexDirection, setFlexDirection);
+    REBUILD_FIELD_SWITCH_CASE_YSP(justifyContent, setJustifyContent);
+    REBUILD_FIELD_SWITCH_CASE_YSP(alignContent, setAlignContent);
+    REBUILD_FIELD_SWITCH_CASE_YSP(alignItems, setAlignItems);
+    REBUILD_FIELD_SWITCH_CASE_YSP(alignSelf, setAlignSelf);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flexWrap, setFlexWrap);
+    REBUILD_FIELD_SWITCH_CASE_YSP(overflow, setOverflow);
+    REBUILD_FIELD_SWITCH_CASE_YSP(display, setDisplay);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flex, setFlex);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flexGrow, setFlexGrow);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flexShrink, setFlexShrink);
+    REBUILD_FIELD_SWITCH_CASE_YSP(flexBasis, setFlexBasis);
+    REBUILD_FIELD_SWITCH_CASE2(positionType, setPositionType, "position");
     REBUILD_FIELD_YG_GUTTER(gap, setGap, "rowGap", "columnGap", "gap");
-    REBUILD_FIELD_SWITCH_CASE_YSP_SETTER(aspectRatio, setAspectRatio);
+    REBUILD_FIELD_SWITCH_CASE_YSP(aspectRatio, setAspectRatio);
     REBUILD_FIELD_YG_DIMENSION(dimension, setDimension, "width", "height");
     REBUILD_FIELD_YG_DIMENSION(
         minDimension, setMinDimension, "minWidth", "minHeight");

packages/react-native/ReactCommon/react/renderer/components/view/propsConversions.h

@@ -23,62 +23,76 @@ static inline yoga::Style convertRawProp(
     const RawProps& rawProps,
     const yoga::Style& sourceValue) {
   yoga::Style yogaStyle{};
-  yogaStyle.direction() = convertRawProp(
+
+  yogaStyle.setDirection(convertRawProp(
       context,
       rawProps,
       "direction",
       sourceValue.direction(),
-      yogaStyle.direction());
-  yogaStyle.flexDirection() = convertRawProp(
+      yogaStyle.direction()));
+
+  yogaStyle.setFlexDirection(convertRawProp(
       context,
       rawProps,
       "flexDirection",
       sourceValue.flexDirection(),
-      yogaStyle.flexDirection());
-  yogaStyle.justifyContent() = convertRawProp(
+      yogaStyle.flexDirection()));
+
+  yogaStyle.setJustifyContent(convertRawProp(
       context,
       rawProps,
       "justifyContent",
       sourceValue.justifyContent(),
-      yogaStyle.justifyContent());
-  yogaStyle.alignContent() = convertRawProp(
+      yogaStyle.justifyContent()));
+
+  yogaStyle.setAlignContent(convertRawProp(
       context,
       rawProps,
       "alignContent",
       sourceValue.alignContent(),
-      yogaStyle.alignContent());
-  yogaStyle.alignItems() = convertRawProp(
+      yogaStyle.alignContent()));
+
+  yogaStyle.setAlignItems(convertRawProp(
       context,
       rawProps,
       "alignItems",
       sourceValue.alignItems(),
-      yogaStyle.alignItems());
-  yogaStyle.alignSelf() = convertRawProp(
+      yogaStyle.alignItems()));
+
+  yogaStyle.setAlignSelf(convertRawProp(
       context,
       rawProps,
       "alignSelf",
       sourceValue.alignSelf(),
-      yogaStyle.alignSelf());
-  yogaStyle.positionType() = convertRawProp(
+      yogaStyle.alignSelf()));
+
+  yogaStyle.setPositionType(convertRawProp(
       context,
       rawProps,
       "position",
       sourceValue.positionType(),
-      yogaStyle.positionType());
-  yogaStyle.flexWrap() = convertRawProp(
+      yogaStyle.positionType()));
+
+  yogaStyle.setFlexWrap(convertRawProp(
       context,
       rawProps,
       "flexWrap",
       sourceValue.flexWrap(),
-      yogaStyle.flexWrap());
-  yogaStyle.overflow() = convertRawProp(
+      yogaStyle.flexWrap()));
+
+  yogaStyle.setOverflow(convertRawProp(
       context,
       rawProps,
       "overflow",
       sourceValue.overflow(),
-      yogaStyle.overflow());
-  yogaStyle.display() = convertRawProp(
-      context, rawProps, "display", sourceValue.display(), yogaStyle.display());
+      yogaStyle.overflow()));
+
+  yogaStyle.setDisplay(convertRawProp(
+      context,
+      rawProps,
+      "display",
+      sourceValue.display(),
+      yogaStyle.display()));
 
   yogaStyle.setFlex(convertRawProp(
       context, rawProps, "flex", sourceValue.flex(), yogaStyle.flex()));
@@ -463,6 +477,7 @@ static inline yoga::Style convertRawProp(
           "width",
           sourceValue.dimension(yoga::Dimension::Width),
           {}));
+
   yogaStyle.setDimension(
       yoga::Dimension::Height,
       convertRawProp(
@@ -480,6 +495,7 @@ static inline yoga::Style convertRawProp(
           "minWidth",
           sourceValue.minDimension(yoga::Dimension::Width),
           {}));
+
   yogaStyle.setMinDimension(
       yoga::Dimension::Height,
       convertRawProp(
@@ -497,6 +513,7 @@ static inline yoga::Style convertRawProp(
           "maxWidth",
           sourceValue.maxDimension(yoga::Dimension::Width),
           {}));
+
   yogaStyle.setMaxDimension(
       yoga::Dimension::Height,
       convertRawProp(

packages/react-native/ReactCommon/react/renderer/components/view/tests/LayoutTest.cpp

@@ -89,7 +89,7 @@ class LayoutTest : public ::testing::Test {
                 auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                 auto &props = *sharedProps;
                 auto &yogaStyle = props.yogaStyle;
-                yogaStyle.positionType() = yoga::PositionType::Absolute;
+                yogaStyle.setPositionType(yoga::PositionType::Absolute);
                 yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(50));
                 yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(50));
                 return sharedProps;
@@ -102,7 +102,7 @@ class LayoutTest : public ::testing::Test {
                     auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                     auto &props = *sharedProps;
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.positionType() = yoga::PositionType::Absolute;
+                    yogaStyle.setPositionType(yoga::PositionType::Absolute);
                     yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(10));
                     yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(10));
                     yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(30));
@@ -132,10 +132,10 @@ class LayoutTest : public ::testing::Test {
                         auto &yogaStyle = props.yogaStyle;
 
                         if (testCase == CLIPPING) {
-                          yogaStyle.overflow() = yoga::Overflow::Hidden;
+                          yogaStyle.setOverflow(yoga::Overflow::Hidden);
                         }
 
-                        yogaStyle.positionType() = yoga::PositionType::Absolute;
+                        yogaStyle.setPositionType(yoga::PositionType::Absolute);
                         yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(10));
                         yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(10));
                         yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(110));
@@ -150,7 +150,7 @@ class LayoutTest : public ::testing::Test {
                             auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                             auto &props = *sharedProps;
                             auto &yogaStyle = props.yogaStyle;
-                            yogaStyle.positionType() = yoga::PositionType::Absolute;
+                            yogaStyle.setPositionType(yoga::PositionType::Absolute);
                             yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(70));
                             yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(-50));
                             yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(30));
@@ -165,7 +165,7 @@ class LayoutTest : public ::testing::Test {
                         auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                         auto &props = *sharedProps;
                         auto &yogaStyle = props.yogaStyle;
-                        yogaStyle.positionType() = yoga::PositionType::Absolute;
+                        yogaStyle.setPositionType(yoga::PositionType::Absolute);
                         yogaStyle.setPosition(yoga::Edge::Left, yoga::value::points(-60));
                         yogaStyle.setPosition(yoga::Edge::Top, yoga::value::points(50));
                         yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(70));

packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp

@@ -52,8 +52,8 @@ class YogaDirtyFlagTest : public ::testing::Test {
                     auto &props = *mutableViewProps;
                     props.nativeId = "native Id";
                     props.opacity = 0.5;
-                    props.yogaStyle.alignContent() = yoga::Align::Baseline;
-                    props.yogaStyle.flexDirection() = yoga::FlexDirection::RowReverse;
+                    props.yogaStyle.setAlignContent(yoga::Align::Baseline);
+                    props.yogaStyle.setFlexDirection(yoga::FlexDirection::RowReverse);
                     return mutableViewProps;
                   }),
                 Element<ViewShadowNode>()
@@ -136,8 +136,8 @@ TEST_F(YogaDirtyFlagTest, changingLayoutSubPropsMustDirtyYogaNode) {
         auto viewProps = std::make_shared<ViewShadowNodeProps>();
         auto& props = *viewProps;
 
-        props.yogaStyle.alignContent() = yoga::Align::Baseline;
-        props.yogaStyle.display() = yoga::Display::None;
+        props.yogaStyle.setAlignContent(yoga::Align::Baseline);
+        props.yogaStyle.setDisplay(yoga::Display::None);
 
         return oldShadowNode.clone(ShadowNodeFragment{viewProps});
       });

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

@@ -202,7 +202,7 @@ TEST(FindNodeAtPointTest, overlappingViewsWithZIndex) {
           auto sharedProps = std::make_shared<ViewShadowNodeProps>();
           sharedProps->zIndex = 1;
           auto &yogaStyle = sharedProps->yogaStyle;
-          yogaStyle.positionType() = yoga::PositionType::Absolute;
+          yogaStyle.setPositionType(yoga::PositionType::Absolute);
           return sharedProps;
         })
         .finalize([](ViewShadowNode &shadowNode){

packages/react-native/ReactCommon/react/renderer/mounting/tests/StackingContextTest.cpp

@@ -253,7 +253,7 @@ TEST_F(StackingContextTest, mostPropsDoNotForceViewsToMaterialize) {
     auto& yogaStyle = props.yogaStyle;
     yogaStyle.setPadding(yoga::Edge::All, yoga::value::points(42));
     yogaStyle.setMargin(yoga::Edge::All, yoga::value::points(42));
-    yogaStyle.positionType() = yoga::PositionType::Absolute;
+    yogaStyle.setPositionType(yoga::PositionType::Absolute);
     props.shadowRadius = 42;
     props.shadowOffset = Size{42, 42};
     props.backgroundColor = clearColor();
@@ -269,7 +269,7 @@ TEST_F(StackingContextTest, mostPropsDoNotForceViewsToMaterialize) {
 
   mutateViewShadowNodeProps_(nodeBBA_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
 
     props.borderRadii.all = 42;
     props.borderColors.all = blackColor();
@@ -456,7 +456,7 @@ TEST_F(StackingContextTest, somePropsForceViewsToMaterialize2) {
 
   mutateViewShadowNodeProps_(nodeBBB_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 42;
   });
 
@@ -538,37 +538,37 @@ TEST_F(StackingContextTest, zIndexAndFlattenedNodes) {
 
   mutateViewShadowNodeProps_(nodeAA_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 9001;
   });
 
   mutateViewShadowNodeProps_(nodeBA_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 9000;
   });
 
   mutateViewShadowNodeProps_(nodeBBA_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 8999;
   });
 
   mutateViewShadowNodeProps_(nodeBBB_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 8998;
   });
 
   mutateViewShadowNodeProps_(nodeBC_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 8997;
   });
 
   mutateViewShadowNodeProps_(nodeBD_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 8996;
   });
 
@@ -652,7 +652,7 @@ TEST_F(StackingContextTest, zIndexAndFlattenedNodes) {
 
   mutateViewShadowNodeProps_(nodeBB_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Relative;
+    yogaStyle.setPositionType(yoga::PositionType::Relative);
     props.zIndex = 42;
   });
 
@@ -680,7 +680,7 @@ TEST_F(StackingContextTest, zIndexAndFlattenedNodes) {
 
   mutateViewShadowNodeProps_(nodeBB_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.positionType() = yoga::PositionType::Static;
+    yogaStyle.setPositionType(yoga::PositionType::Static);
     props.zIndex = {};
   });
 
@@ -764,7 +764,7 @@ TEST_F(StackingContextTest, zIndexAndFlattenedNodes) {
 
   mutateViewShadowNodeProps_(nodeBB_, [](ViewProps& props) {
     auto& yogaStyle = props.yogaStyle;
-    yogaStyle.display() = yoga::Display::None;
+    yogaStyle.setDisplay(yoga::Display::None);
   });
 
   testViewTree_([](const StubViewTree& viewTree) {

packages/react-native/ReactCommon/yoga/yoga/YGNodeStyle.cpp

@@ -14,54 +14,26 @@ using namespace facebook::yoga;
 
 namespace {
 
-template <typename T, typename NeedsUpdate, typename Update>
-void updateStyle(
-    yoga::Node* node,
-    T value,
-    NeedsUpdate&& needsUpdate,
-    Update&& update) {
-  if (needsUpdate(node->getStyle(), value)) {
-    update(node->getStyle(), value);
-    node->markDirtyAndPropagate();
+template <auto GetterT, auto SetterT, typename ValueT>
+void updateStyle(YGNodeRef node, ValueT value) {
+  auto& style = resolveRef(node)->getStyle();
+  if ((style.*GetterT)() != value) {
+    (style.*SetterT)(value);
+    resolveRef(node)->markDirtyAndPropagate();
   }
 }
 
-template <typename Ref, typename ValueT>
-void updateStyle(YGNodeRef node, Ref (Style::*prop)(), ValueT value) {
-  updateStyle(
-      resolveRef(node),
-      value,
-      [prop](Style& s, ValueT x) { return (s.*prop)() != x; },
-      [prop](Style& s, ValueT x) { (s.*prop)() = x; });
-}
-
-template <auto GetterT, auto SetterT, typename ValueT>
-void updateStyle(YGNodeRef node, ValueT value) {
-  updateStyle(
-      resolveRef(node),
-      value,
-      [](Style& s, ValueT x) { return (s.*GetterT)() != x; },
-      [](Style& s, ValueT x) { (s.*SetterT)(x); });
-}
-
 template <auto GetterT, auto SetterT, typename IdxT, typename ValueT>
-void updateIndexedStyleProp(YGNodeRef node, IdxT idx, ValueT value) {
-  updateStyle(
-      resolveRef(node),
-      value,
-      [idx](Style& s, ValueT x) { return (s.*GetterT)(idx) != x; },
-      [idx](Style& s, ValueT x) { (s.*SetterT)(idx, x); });
+void updateStyle(YGNodeRef node, IdxT idx, ValueT value) {
+  auto& style = resolveRef(node)->getStyle();
+  if ((style.*GetterT)(idx) != value) {
+    (style.*SetterT)(idx, value);
+    resolveRef(node)->markDirtyAndPropagate();
+  }
 }
 
 } // namespace
 
-// MSVC has trouble inferring the return type of pointer to member functions
-// with const and non-const overloads, instead of preferring the non-const
-// overload like clang and GCC. For the purposes of updateStyle(), we can help
-// MSVC by specifying that return type explicitly. In combination with
-// decltype, MSVC will prefer the non-const version.
-#define MSVC_HINT(PROP) decltype(Style{}.PROP())
-
 void YGNodeCopyStyle(
     const YGNodeRef dstNodeRef,
     const YGNodeConstRef srcNodeRef) {
@@ -75,7 +47,7 @@ void YGNodeCopyStyle(
 }
 
 void YGNodeStyleSetDirection(const YGNodeRef node, const YGDirection value) {
-  updateStyle<MSVC_HINT(direction)>(node, &Style::direction, scopedEnum(value));
+  updateStyle<&Style::direction, &Style::setDirection>(node, scopedEnum(value));
 }
 
 YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
@@ -85,8 +57,8 @@ YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
 void YGNodeStyleSetFlexDirection(
     const YGNodeRef node,
     const YGFlexDirection flexDirection) {
-  updateStyle<MSVC_HINT(flexDirection)>(
-      node, &Style::flexDirection, scopedEnum(flexDirection));
+  updateStyle<&Style::flexDirection, &Style::setFlexDirection>(
+      node, scopedEnum(flexDirection));
 }
 
 YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
@@ -96,8 +68,8 @@ YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
 void YGNodeStyleSetJustifyContent(
     const YGNodeRef node,
     const YGJustify justifyContent) {
-  updateStyle<MSVC_HINT(justifyContent)>(
-      node, &Style::justifyContent, scopedEnum(justifyContent));
+  updateStyle<&Style::justifyContent, &Style::setJustifyContent>(
+      node, scopedEnum(justifyContent));
 }
 
 YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
@@ -107,8 +79,8 @@ YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
 void YGNodeStyleSetAlignContent(
     const YGNodeRef node,
     const YGAlign alignContent) {
-  updateStyle<MSVC_HINT(alignContent)>(
-      node, &Style::alignContent, scopedEnum(alignContent));
+  updateStyle<&Style::alignContent, &Style::setAlignContent>(
+      node, scopedEnum(alignContent));
 }
 
 YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
@@ -116,8 +88,8 @@ YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetAlignItems(const YGNodeRef node, const YGAlign alignItems) {
-  updateStyle<MSVC_HINT(alignItems)>(
-      node, &Style::alignItems, scopedEnum(alignItems));
+  updateStyle<&Style::alignItems, &Style::setAlignItems>(
+      node, scopedEnum(alignItems));
 }
 
 YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
@@ -125,8 +97,8 @@ YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetAlignSelf(const YGNodeRef node, const YGAlign alignSelf) {
-  updateStyle<MSVC_HINT(alignSelf)>(
-      node, &Style::alignSelf, scopedEnum(alignSelf));
+  updateStyle<&Style::alignSelf, &Style::setAlignSelf>(
+      node, scopedEnum(alignSelf));
 }
 
 YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
@@ -136,8 +108,8 @@ YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
 void YGNodeStyleSetPositionType(
     const YGNodeRef node,
     const YGPositionType positionType) {
-  updateStyle<MSVC_HINT(positionType)>(
-      node, &Style::positionType, scopedEnum(positionType));
+  updateStyle<&Style::positionType, &Style::setPositionType>(
+      node, scopedEnum(positionType));
 }
 
 YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) {
@@ -145,8 +117,8 @@ YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetFlexWrap(const YGNodeRef node, const YGWrap flexWrap) {
-  updateStyle<MSVC_HINT(flexWrap)>(
-      node, &Style::flexWrap, scopedEnum(flexWrap));
+  updateStyle<&Style::flexWrap, &Style::setFlexWrap>(
+      node, scopedEnum(flexWrap));
 }
 
 YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
@@ -154,8 +126,8 @@ YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetOverflow(const YGNodeRef node, const YGOverflow overflow) {
-  updateStyle<MSVC_HINT(overflow)>(
-      node, &Style::overflow, scopedEnum(overflow));
+  updateStyle<&Style::overflow, &Style::setOverflow>(
+      node, scopedEnum(overflow));
 }
 
 YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) {
@@ -163,7 +135,7 @@ YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetDisplay(const YGNodeRef node, const YGDisplay display) {
-  updateStyle<MSVC_HINT(display)>(node, &Style::display, scopedEnum(display));
+  updateStyle<&Style::display, &Style::setDisplay>(node, scopedEnum(display));
 }
 
 YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) {
@@ -231,12 +203,12 @@ YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
-  updateIndexedStyleProp<&Style::position, &Style::setPosition>(
+  updateStyle<&Style::position, &Style::setPosition>(
       node, scopedEnum(edge), value::points(points));
 }
 
 void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
-  updateIndexedStyleProp<&Style::position, &Style::setPosition>(
+  updateStyle<&Style::position, &Style::setPosition>(
       node, scopedEnum(edge), value::percent(percent));
 }
 
@@ -245,17 +217,17 @@ YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
 }
 
 void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
-  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
+  updateStyle<&Style::margin, &Style::setMargin>(
       node, scopedEnum(edge), value::points(points));
 }
 
 void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
-  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
+  updateStyle<&Style::margin, &Style::setMargin>(
       node, scopedEnum(edge), value::percent(percent));
 }
 
 void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
-  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
+  updateStyle<&Style::margin, &Style::setMargin>(
       node, scopedEnum(edge), value::ofAuto());
 }
 
@@ -264,12 +236,12 @@ YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
 }
 
 void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
-  updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
+  updateStyle<&Style::padding, &Style::setPadding>(
       node, scopedEnum(edge), value::points(points));
 }
 
 void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
-  updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
+  updateStyle<&Style::padding, &Style::setPadding>(
       node, scopedEnum(edge), value::percent(percent));
 }
 
@@ -281,7 +253,7 @@ void YGNodeStyleSetBorder(
     const YGNodeRef node,
     const YGEdge edge,
     const float border) {
-  updateIndexedStyleProp<&Style::border, &Style::setBorder>(
+  updateStyle<&Style::border, &Style::setBorder>(
       node, scopedEnum(edge), value::points(border));
 }
 
@@ -298,7 +270,7 @@ void YGNodeStyleSetGap(
     const YGNodeRef node,
     const YGGutter gutter,
     const float gapLength) {
-  updateIndexedStyleProp<&Style::gap, &Style::setGap>(
+  updateStyle<&Style::gap, &Style::setGap>(
       node, scopedEnum(gutter), value::points(gapLength));
 }
 
@@ -322,17 +294,17 @@ float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetWidth(YGNodeRef node, float points) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Width, value::points(points));
 }
 
 void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Width, value::percent(percent));
 }
 
 void YGNodeStyleSetWidthAuto(YGNodeRef node) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Width, value::ofAuto());
 }
 
@@ -341,17 +313,17 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetHeight(YGNodeRef node, float points) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Height, value::points(points));
 }
 
 void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Height, value::percent(percent));
 }
 
 void YGNodeStyleSetHeightAuto(YGNodeRef node) {
-  updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
+  updateStyle<&Style::dimension, &Style::setDimension>(
       node, Dimension::Height, value::ofAuto());
 }
 
@@ -360,12 +332,12 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
-  updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
       node, Dimension::Width, value::points(minWidth));
 }
 
 void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
-  updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
       node, Dimension::Width, value::percent(minWidth));
 }
 
@@ -374,14 +346,14 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
-  updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
       node, Dimension::Height, value::points(minHeight));
 }
 
 void YGNodeStyleSetMinHeightPercent(
     const YGNodeRef node,
     const float minHeight) {
-  updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
       node, Dimension::Height, value::percent(minHeight));
 }
 
@@ -390,12 +362,12 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
-  updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
       node, Dimension::Width, value::points(maxWidth));
 }
 
 void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
-  updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
       node, Dimension::Width, value::percent(maxWidth));
 }
 
@@ -404,14 +376,14 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
-  updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
       node, Dimension::Height, value::points(maxHeight));
 }
 
 void YGNodeStyleSetMaxHeightPercent(
     const YGNodeRef node,
     const float maxHeight) {
-  updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
       node, Dimension::Height, value::percent(maxHeight));
 }
 

packages/react-native/ReactCommon/yoga/yoga/node/Node.h

@@ -61,8 +61,8 @@ class YG_EXPORT Node : public ::YGNode {
       Direction direction) const;
 
   void useWebDefaults() {
-    style_.flexDirection() = FlexDirection::Row;
-    style_.alignContent() = Align::Stretch;
+    style_.setFlexDirection(FlexDirection::Row);
+    style_.setAlignContent(Align::Stretch);
   }
 
   template <auto Field>

packages/react-native/ReactCommon/yoga/yoga/style/Style.h

@@ -55,22 +55,9 @@ class YG_EXPORT Style {
   static constexpr float DefaultFlexShrink = 0.0f;
   static constexpr float WebDefaultFlexShrink = 1.0f;
 
-  template <typename T>
-  struct BitfieldRef {
-    Style& style;
-    uint8_t offset;
-    operator T() const {
-      return getEnumData<T>(style.flags, offset);
-    }
-    BitfieldRef<T>& operator=(T x) {
-      setEnumData<T>(style.flags, offset, x);
-      return *this;
-    }
-  };
-
   Style() {
-    alignContent() = Align::FlexStart;
-    alignItems() = Align::Stretch;
+    setAlignContent(Align::FlexStart);
+    setAlignItems(Align::Stretch);
   }
   ~Style() = default;
 
@@ -99,7 +86,7 @@ class YG_EXPORT Style {
   static constexpr uint8_t displayOffset =
       overflowOffset + minimumBitCount<Overflow>();
 
-  uint32_t flags = 0;
+  uint32_t flags_ = 0;
 
   FloatOptional flex_ = {};
   FloatOptional flexGrow_ = {};
@@ -118,73 +105,73 @@ class YG_EXPORT Style {
 
  public:
   Direction direction() const {
-    return getEnumData<Direction>(flags, directionOffset);
+    return getEnumData<Direction>(flags_, directionOffset);
   }
-  BitfieldRef<Direction> direction() {
-    return {*this, directionOffset};
+  void setDirection(Direction value) {
+    setEnumData<Direction>(flags_, directionOffset, value);
   }
 
   FlexDirection flexDirection() const {
-    return getEnumData<FlexDirection>(flags, flexdirectionOffset);
+    return getEnumData<FlexDirection>(flags_, flexdirectionOffset);
   }
-  BitfieldRef<FlexDirection> flexDirection() {
-    return {*this, flexdirectionOffset};
+  void setFlexDirection(FlexDirection value) {
+    setEnumData<FlexDirection>(flags_, flexdirectionOffset, value);
   }
 
   Justify justifyContent() const {
-    return getEnumData<Justify>(flags, justifyContentOffset);
+    return getEnumData<Justify>(flags_, justifyContentOffset);
   }
-  BitfieldRef<Justify> justifyContent() {
-    return {*this, justifyContentOffset};
+  void setJustifyContent(Justify value) {
+    setEnumData<Justify>(flags_, justifyContentOffset, value);
   }
 
   Align alignContent() const {
-    return getEnumData<Align>(flags, alignContentOffset);
+    return getEnumData<Align>(flags_, alignContentOffset);
   }
-  BitfieldRef<Align> alignContent() {
-    return {*this, alignContentOffset};
+  void setAlignContent(Align value) {
+    setEnumData<Align>(flags_, alignContentOffset, value);
   }
 
   Align alignItems() const {
-    return getEnumData<Align>(flags, alignItemsOffset);
+    return getEnumData<Align>(flags_, alignItemsOffset);
   }
-  BitfieldRef<Align> alignItems() {
-    return {*this, alignItemsOffset};
+  void setAlignItems(Align value) {
+    setEnumData<Align>(flags_, alignItemsOffset, value);
   }
 
   Align alignSelf() const {
-    return getEnumData<Align>(flags, alignSelfOffset);
+    return getEnumData<Align>(flags_, alignSelfOffset);
   }
-  BitfieldRef<Align> alignSelf() {
-    return {*this, alignSelfOffset};
+  void setAlignSelf(Align value) {
+    setEnumData<Align>(flags_, alignSelfOffset, value);
   }
 
   PositionType positionType() const {
-    return getEnumData<PositionType>(flags, positionTypeOffset);
+    return getEnumData<PositionType>(flags_, positionTypeOffset);
   }
-  BitfieldRef<PositionType> positionType() {
-    return {*this, positionTypeOffset};
+  void setPositionType(PositionType value) {
+    setEnumData<PositionType>(flags_, positionTypeOffset, value);
   }
 
   Wrap flexWrap() const {
-    return getEnumData<Wrap>(flags, flexWrapOffset);
+    return getEnumData<Wrap>(flags_, flexWrapOffset);
   }
-  BitfieldRef<Wrap> flexWrap() {
-    return {*this, flexWrapOffset};
+  void setFlexWrap(Wrap value) {
+    setEnumData<Wrap>(flags_, flexWrapOffset, value);
   }
 
   Overflow overflow() const {
-    return getEnumData<Overflow>(flags, overflowOffset);
+    return getEnumData<Overflow>(flags_, overflowOffset);
   }
-  BitfieldRef<Overflow> overflow() {
-    return {*this, overflowOffset};
+  void setOverflow(Overflow value) {
+    setEnumData<Overflow>(flags_, overflowOffset, value);
   }
 
   Display display() const {
-    return getEnumData<Display>(flags, displayOffset);
+    return getEnumData<Display>(flags_, displayOffset);
   }
-  BitfieldRef<Display> display() {
-    return {*this, displayOffset};
+  void setDisplay(Display value) {
+    setEnumData<Display>(flags_, displayOffset, value);
   }
 
   FloatOptional flex() const {
@@ -295,7 +282,7 @@ class YG_EXPORT Style {
   }
 
   bool operator==(const Style& other) const {
-    return flags == other.flags && inexactEquals(flex_, other.flex_) &&
+    return flags_ == other.flags_ && inexactEquals(flex_, other.flex_) &&
         inexactEquals(flexGrow_, other.flexGrow_) &&
         inexactEquals(flexShrink_, other.flexShrink_) &&
         inexactEquals(flexBasis_, other.flexBasis_) &&