Remove NumericBitfield (#1463)

Summary:
X-link: https://github.com/facebook/react-native/pull/41394

Pull Request resolved: https://github.com/facebook/yoga/pull/1463

Now that are enums are unsigned, and we don't have BitfieldRef, we can convert the last remaining user of NumericBitfield to a plain old bitfield,  for better readability (e.g. the default values), debugability, and less complexity. We also break a cycle which lets us properly group public vs private members.

Reviewed By: joevilches

Differential Revision: D51159415

fbshipit-source-id: 7842a8330eed6061b863de3f175c761dcf4aa2be

enums.py

@@ -131,10 +131,7 @@ with open(root + "/yoga/YGEnums.h", "w") as f:
     f.write("YG_EXTERN_C_BEGIN\n\n")
     items = sorted(ENUMS.items())
     for name, values in items:
-        if isinstance(values[0], tuple):
+        f.write("YG_ENUM_DECL(\n")
-            f.write("YG_ENUM_DECL(\n")
-        else:
-            f.write("YG_ENUM_SEQ_DECL(\n")
 
         f.write("    YG%s,\n" % name)
         for value in values:

tests/NumericBitfieldTest.cpp

@@ -1,205 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <gtest/gtest.h>
-
-#include <yoga/bits/NumericBitfield.h>
-#include <cstdint>
-
-namespace facebook::yoga {
-
-TEST(NumericBitfield, one_boolean_defaults_to_false) {
-  constexpr uint32_t flags = 0;
-
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  static_assert(
-      getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-}
-
-TEST(NumericBitfield, one_boolean_can_be_initialized_to_true) {
-  constexpr uint32_t flags = 1;
-
-  ASSERT_EQ(getBooleanData(flags, 0), true);
-  static_assert(
-      getBooleanData(flags, 0) == true,
-      "first boolean member must be initialized to true");
-}
-
-TEST(NumericBitfield, one_boolean_can_be_set_to_true) {
-  uint32_t flags = 0;
-
-  setBooleanData(flags, 0, true);
-  ASSERT_EQ(getBooleanData(flags, 0), true);
-}
-
-TEST(NumericBitfield, second_boolean_defaults_to_false) {
-  constexpr uint32_t flags = 0;
-
-  ASSERT_EQ(getBooleanData(flags, 1), false);
-  static_assert(
-      getBooleanData(flags, 1) == false,
-      "second boolean member must default to false");
-}
-
-TEST(NumericBitfield, second_boolean_can_be_initialized_to_true) {
-  constexpr uint32_t flags = 2;
-
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  ASSERT_EQ(getBooleanData(flags, 1), true);
-  static_assert(
-      getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-  static_assert(
-      getBooleanData(flags, 1) == true,
-      "second boolean member must be initialized to true");
-}
-
-TEST(NumericBitfield, second_boolean_can_be_set_to_true) {
-  uint32_t flags = 0;
-
-  setBooleanData(flags, 1, true);
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  ASSERT_EQ(getBooleanData(flags, 1), true);
-}
-
-TEST(NumericBitfield, third_boolean_defaults_to_false) {
-  constexpr uint32_t flags = 0;
-
-  ASSERT_EQ(getBooleanData(flags, 2), false);
-  static_assert(
-      getBooleanData(flags, 2) == false,
-      "second boolean member must default to false");
-}
-
-TEST(NumericBitfield, third_boolean_can_be_initialized_to_true) {
-  constexpr uint32_t flags = 4;
-
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  ASSERT_EQ(getBooleanData(flags, 1), false);
-  ASSERT_EQ(getBooleanData(flags, 2), true);
-  static_assert(
-      getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-  static_assert(
-      getBooleanData(flags, 1) == false,
-      "second boolean member must default to false");
-  static_assert(
-      getBooleanData(flags, 2) == true,
-      "second boolean member must be initialized to true");
-}
-
-TEST(NumericBitfield, third_boolean_can_be_set_to_true) {
-  uint32_t flags = 0;
-
-  setBooleanData(flags, 2, true);
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  ASSERT_EQ(getBooleanData(flags, 1), false);
-  ASSERT_EQ(getBooleanData(flags, 2), true);
-}
-
-TEST(NumericBitfield, setting_boolean_values_does_not_spill_over) {
-  uint32_t flags = 0;
-
-  setBooleanData(flags, 1, (bool)7);
-
-  ASSERT_EQ(getBooleanData(flags, 0), false);
-  ASSERT_EQ(getBooleanData(flags, 1), true);
-  ASSERT_EQ(getBooleanData(flags, 2), false);
-}
-
-TEST(NumericBitfield, first_enum_defaults_to_0) {
-  constexpr uint32_t flags = 0;
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, 0), YGAlignAuto);
-  static_assert(
-      getEnumData<YGAlign>(flags, 0) == YGAlignAuto,
-      "first enum member must default to 0");
-}
-
-TEST(NumericBitfield, first_enum_can_be_set) {
-  uint32_t flags = 0;
-
-  setEnumData<YGAlign>(flags, 0, YGAlignSpaceBetween);
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, 0), YGAlignSpaceBetween);
-}
-
-TEST(NumericBitfield, second_enum_defaults_to_0) {
-  constexpr uint32_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgeOffset = 3;
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(getEnumData<YGEdge>(flags, edgeOffset), YGEdgeLeft);
-  static_assert(
-      getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
-      "first enum member must default to 0");
-  static_assert(
-      getEnumData<YGEdge>(flags, edgeOffset) == YGEdgeLeft,
-      "second enum member must default to 0");
-}
-
-TEST(NumericBitfield, second_enum_can_be_set) {
-  uint32_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgeOffset = 3;
-
-  setEnumData<YGEdge>(flags, edgeOffset, YGEdgeAll);
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(getEnumData<YGEdge>(flags, edgeOffset), YGEdgeAll);
-}
-
-TEST(NumericBitfield, third_enum_defaults_to_0) {
-  constexpr uint32_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t boolOffset = 3;
-  static constexpr size_t edgesOffset = 4;
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), YGEdgeLeft);
-  static_assert(
-      getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
-      "first enum member must default to 0");
-  static_assert(
-      getBooleanData(flags, boolOffset) == false,
-      "middle boolean member must default to false");
-  static_assert(
-      getEnumData<YGEdge>(flags, edgesOffset) == YGEdgeLeft,
-      "last enum member must default to 0");
-}
-
-TEST(NumericBitfield, third_enum_can_be_set) {
-  uint32_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t boolOffset = 3;
-  static constexpr size_t edgesOffset = 4;
-
-  setEnumData<YGEdge>(flags, edgesOffset, YGEdgeVertical);
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), YGEdgeVertical);
-}
-
-TEST(NumericBitfield, setting_values_does_not_spill_over) {
-  uint32_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgesOffset = 4;
-  static constexpr size_t boolOffset = 8;
-
-  uint32_t edge = 0xffffff;
-  setEnumData<YGEdge>(flags, edgesOffset, (YGEdge)edge);
-
-  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), 0);
-  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), 0xf);
-}
-
-} // namespace facebook::yoga

yoga/YGEnums.h

@@ -12,7 +12,7 @@
 
 YG_EXTERN_C_BEGIN
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGAlign,
     YGAlignAuto,
     YGAlignFlexStart,
@@ -24,23 +24,23 @@ YG_ENUM_SEQ_DECL(
     YGAlignSpaceAround,
     YGAlignSpaceEvenly)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGDimension,
     YGDimensionWidth,
     YGDimensionHeight)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGDirection,
     YGDirectionInherit,
     YGDirectionLTR,
     YGDirectionRTL)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGDisplay,
     YGDisplayFlex,
     YGDisplayNone)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGEdge,
     YGEdgeLeft,
     YGEdgeTop,
@@ -62,25 +62,25 @@ YG_ENUM_DECL(
     YGErrataClassic = 2147483646)
 YG_DEFINE_ENUM_FLAG_OPERATORS(YGErrata)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGExperimentalFeature,
     YGExperimentalFeatureWebFlexBasis,
     YGExperimentalFeatureAbsolutePercentageAgainstPaddingEdge)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGFlexDirection,
     YGFlexDirectionColumn,
     YGFlexDirectionColumnReverse,
     YGFlexDirectionRow,
     YGFlexDirectionRowReverse)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGGutter,
     YGGutterColumn,
     YGGutterRow,
     YGGutterAll)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGJustify,
     YGJustifyFlexStart,
     YGJustifyCenter,
@@ -89,7 +89,7 @@ YG_ENUM_SEQ_DECL(
     YGJustifySpaceAround,
     YGJustifySpaceEvenly)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGLogLevel,
     YGLogLevelError,
     YGLogLevelWarn,
@@ -98,24 +98,24 @@ YG_ENUM_SEQ_DECL(
     YGLogLevelVerbose,
     YGLogLevelFatal)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGMeasureMode,
     YGMeasureModeUndefined,
     YGMeasureModeExactly,
     YGMeasureModeAtMost)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGNodeType,
     YGNodeTypeDefault,
     YGNodeTypeText)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGOverflow,
     YGOverflowVisible,
     YGOverflowHidden,
     YGOverflowScroll)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGPositionType,
     YGPositionTypeStatic,
     YGPositionTypeRelative,
@@ -128,14 +128,14 @@ YG_ENUM_DECL(
     YGPrintOptionsChildren = 4)
 YG_DEFINE_ENUM_FLAG_OPERATORS(YGPrintOptions)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGUnit,
     YGUnitUndefined,
     YGUnitPoint,
     YGUnitPercent,
     YGUnitAuto)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_DECL(
     YGWrap,
     YGWrapNoWrap,
     YGWrapWrap,

yoga/YGMacros.h

@@ -88,40 +88,6 @@
 #define YG_DEFINE_ENUM_FLAG_OPERATORS(name)
 #endif
 
-#ifdef __cplusplus
-
-namespace facebook::yoga {
-
-template <typename T>
-constexpr int
-ordinalCount(); // can't use `= delete` due to a defect in clang < 3.9
-
-namespace detail {
-template <int... xs>
-constexpr int n() {
-  return sizeof...(xs);
-}
-} // namespace detail
-
-} // namespace facebook::yoga
-#endif
-
 #define YG_ENUM_DECL(NAME, ...)                               \
   typedef YG_ENUM_BEGIN(NAME){__VA_ARGS__} YG_ENUM_END(NAME); \
   YG_EXPORT const char* NAME##ToString(NAME);
-
-#ifdef __cplusplus
-#define YG_ENUM_SEQ_DECL(NAME, ...)    \
-  YG_ENUM_DECL(NAME, __VA_ARGS__)      \
-  YG_EXTERN_C_END                      \
-                                       \
-  namespace facebook::yoga {           \
-  template <>                          \
-  constexpr int ordinalCount<NAME>() { \
-    return detail::n<__VA_ARGS__>();   \
-  }                                    \
-  }                                    \
-  YG_EXTERN_C_BEGIN
-#else
-#define YG_ENUM_SEQ_DECL YG_ENUM_DECL
-#endif

yoga/bits/NumericBitfield.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <bitset>
-#include <cstdint>
-#include <cstdio>
-#include <type_traits>
-
-#include <yoga/YGEnums.h>
-#include <yoga/enums/YogaEnums.h>
-
-namespace facebook::yoga::details {
-
-constexpr uint8_t log2ceilFn(uint8_t n) {
-  return n < 1 ? 0 : (1 + log2ceilFn(n / 2));
-}
-
-constexpr uint32_t mask(uint8_t bitWidth, uint8_t index) {
-  return ((1u << bitWidth) - 1u) << index;
-}
-
-} // namespace facebook::yoga::details
-
-namespace facebook::yoga {
-
-// The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL
-template <
-    typename Enum,
-    std::enable_if_t<(ordinalCount<Enum>() > 0), bool> = true>
-constexpr uint8_t minimumBitCount() {
-  return details::log2ceilFn(static_cast<uint8_t>(ordinalCount<Enum>() - 1));
-}
-
-template <typename Enum>
-constexpr Enum getEnumData(uint32_t flags, uint8_t index) {
-  return static_cast<Enum>(
-      (flags & details::mask(minimumBitCount<Enum>(), index)) >> index);
-}
-
-template <typename Enum, typename Value>
-void setEnumData(uint32_t& flags, uint8_t index, Value newValue) {
-  flags =
-      (flags &
-       ~static_cast<uint32_t>(details::mask(minimumBitCount<Enum>(), index))) |
-      ((static_cast<uint32_t>(newValue) << index) &
-       (details::mask(minimumBitCount<Enum>(), index)));
-}
-
-constexpr bool getBooleanData(uint32_t flags, uint8_t index) {
-  return (flags >> index) & 1;
-}
-
-inline void setBooleanData(uint32_t& flags, uint8_t index, bool value) {
-  if (value) {
-    flags |= 1 << index;
-  } else {
-    flags &= ~(1 << index);
-  }
-}
-
-} // namespace facebook::yoga

yoga/node/LayoutResults.h

@@ -9,7 +9,6 @@
 
 #include <array>
 
-#include <yoga/bits/NumericBitfield.h>
 #include <yoga/debug/AssertFatal.h>
 #include <yoga/enums/Dimension.h>
 #include <yoga/enums/Direction.h>

yoga/style/Style.h

@@ -14,7 +14,6 @@
 
 #include <yoga/Yoga.h>
 
-#include <yoga/bits/NumericBitfield.h>
 #include <yoga/enums/Align.h>
 #include <yoga/enums/Dimension.h>
 #include <yoga/enums/Direction.h>
@@ -55,123 +54,74 @@ class YG_EXPORT Style {
   static constexpr float DefaultFlexShrink = 0.0f;
   static constexpr float WebDefaultFlexShrink = 1.0f;
 
-  Style() {
-    setAlignContent(Align::FlexStart);
-    setAlignItems(Align::Stretch);
-  }
-  ~Style() = default;
-
- private:
-  using Dimensions = std::array<Style::Length, ordinalCount<Dimension>()>;
-  using Edges = std::array<Style::Length, ordinalCount<Edge>()>;
-  using Gutters = std::array<Style::Length, ordinalCount<Gutter>()>;
-
-  static constexpr uint8_t directionOffset = 0;
-  static constexpr uint8_t flexdirectionOffset =
-      directionOffset + minimumBitCount<Direction>();
-  static constexpr uint8_t justifyContentOffset =
-      flexdirectionOffset + minimumBitCount<FlexDirection>();
-  static constexpr uint8_t alignContentOffset =
-      justifyContentOffset + minimumBitCount<Justify>();
-  static constexpr uint8_t alignItemsOffset =
-      alignContentOffset + minimumBitCount<Align>();
-  static constexpr uint8_t alignSelfOffset =
-      alignItemsOffset + minimumBitCount<Align>();
-  static constexpr uint8_t positionTypeOffset =
-      alignSelfOffset + minimumBitCount<Align>();
-  static constexpr uint8_t flexWrapOffset =
-      positionTypeOffset + minimumBitCount<PositionType>();
-  static constexpr uint8_t overflowOffset =
-      flexWrapOffset + minimumBitCount<Wrap>();
-  static constexpr uint8_t displayOffset =
-      overflowOffset + minimumBitCount<Overflow>();
-
-  uint32_t flags_ = 0;
-
-  FloatOptional flex_ = {};
-  FloatOptional flexGrow_ = {};
-  FloatOptional flexShrink_ = {};
-  Style::Length flexBasis_ = value::ofAuto();
-  Edges margin_ = {};
-  Edges position_ = {};
-  Edges padding_ = {};
-  Edges border_ = {};
-  Gutters gap_ = {};
-  Dimensions dimensions_{value::ofAuto(), value::ofAuto()};
-  Dimensions minDimensions_ = {};
-  Dimensions maxDimensions_ = {};
-  // Yoga specific properties, not compatible with flexbox specification
-  FloatOptional aspectRatio_ = {};
-
- public:
   Direction direction() const {
-    return getEnumData<Direction>(flags_, directionOffset);
+    return direction_;
   }
   void setDirection(Direction value) {
-    setEnumData<Direction>(flags_, directionOffset, value);
+    direction_ = value;
   }
 
   FlexDirection flexDirection() const {
-    return getEnumData<FlexDirection>(flags_, flexdirectionOffset);
+    return flexDirection_;
   }
   void setFlexDirection(FlexDirection value) {
-    setEnumData<FlexDirection>(flags_, flexdirectionOffset, value);
+    flexDirection_ = value;
   }
 
   Justify justifyContent() const {
-    return getEnumData<Justify>(flags_, justifyContentOffset);
+    return justifyContent_;
   }
   void setJustifyContent(Justify value) {
-    setEnumData<Justify>(flags_, justifyContentOffset, value);
+    justifyContent_ = value;
   }
 
   Align alignContent() const {
-    return getEnumData<Align>(flags_, alignContentOffset);
+    return alignContent_;
   }
   void setAlignContent(Align value) {
-    setEnumData<Align>(flags_, alignContentOffset, value);
+    alignContent_ = value;
   }
 
   Align alignItems() const {
-    return getEnumData<Align>(flags_, alignItemsOffset);
+    return alignItems_;
   }
   void setAlignItems(Align value) {
-    setEnumData<Align>(flags_, alignItemsOffset, value);
+    alignItems_ = value;
   }
 
   Align alignSelf() const {
-    return getEnumData<Align>(flags_, alignSelfOffset);
+    return alignSelf_;
   }
   void setAlignSelf(Align value) {
-    setEnumData<Align>(flags_, alignSelfOffset, value);
+    alignSelf_ = value;
   }
 
   PositionType positionType() const {
-    return getEnumData<PositionType>(flags_, positionTypeOffset);
+    return positionType_;
   }
   void setPositionType(PositionType value) {
-    setEnumData<PositionType>(flags_, positionTypeOffset, value);
+    positionType_ = value;
   }
 
   Wrap flexWrap() const {
-    return getEnumData<Wrap>(flags_, flexWrapOffset);
+    return flexWrap_;
   }
   void setFlexWrap(Wrap value) {
-    setEnumData<Wrap>(flags_, flexWrapOffset, value);
+    flexWrap_ = value;
   }
 
   Overflow overflow() const {
-    return getEnumData<Overflow>(flags_, overflowOffset);
+    return overflow_;
   }
   void setOverflow(Overflow value) {
-    setEnumData<Overflow>(flags_, overflowOffset, value);
+    overflow_ = value;
   }
 
   Display display() const {
-    return getEnumData<Display>(flags_, displayOffset);
+    return display_;
   }
   void setDisplay(Display value) {
-    setEnumData<Display>(flags_, displayOffset, value);
+    display_ = value;
   }
 
   FloatOptional flex() const {
@@ -282,7 +232,14 @@ class YG_EXPORT Style {
   }
 
   bool operator==(const Style& other) const {
-    return flags_ == other.flags_ && inexactEquals(flex_, other.flex_) &&
+    return direction_ == other.direction_ &&
+        flexDirection_ == other.flexDirection_ &&
+        justifyContent_ == other.justifyContent_ &&
+        alignContent_ == other.alignContent_ &&
+        alignItems_ == other.alignItems_ && alignSelf_ == other.alignSelf_ &&
+        positionType_ == other.positionType_ && flexWrap_ == other.flexWrap_ &&
+        overflow_ == other.overflow_ && display_ == other.display_ &&
+        inexactEquals(flex_, other.flex_) &&
         inexactEquals(flexGrow_, other.flexGrow_) &&
         inexactEquals(flexShrink_, other.flexShrink_) &&
         inexactEquals(flexBasis_, other.flexBasis_) &&
@@ -300,6 +257,37 @@ class YG_EXPORT Style {
   bool operator!=(const Style& other) const {
     return !(*this == other);
   }
+
+ private:
+  using Dimensions = std::array<Style::Length, ordinalCount<Dimension>()>;
+  using Edges = std::array<Style::Length, ordinalCount<Edge>()>;
+  using Gutters = std::array<Style::Length, ordinalCount<Gutter>()>;
+
+  Direction direction_ : bitCount<Direction>() = Direction::Inherit;
+  FlexDirection flexDirection_
+      : bitCount<FlexDirection>() = FlexDirection::Column;
+  Justify justifyContent_ : bitCount<Justify>() = Justify::FlexStart;
+  Align alignContent_ : bitCount<Align>() = Align::FlexStart;
+  Align alignItems_ : bitCount<Align>() = Align::Stretch;
+  Align alignSelf_ : bitCount<Align>() = Align::Auto;
+  PositionType positionType_ : bitCount<PositionType>() = PositionType::Static;
+  Wrap flexWrap_ : bitCount<Wrap>() = Wrap::NoWrap;
+  Overflow overflow_ : bitCount<Overflow>() = Overflow::Visible;
+  Display display_ : bitCount<Display>() = Display::Flex;
+
+  FloatOptional flex_{};
+  FloatOptional flexGrow_{};
+  FloatOptional flexShrink_{};
+  Style::Length flexBasis_{value::ofAuto()};
+  Edges margin_{};
+  Edges position_{};
+  Edges padding_{};
+  Edges border_{};
+  Gutters gap_{};
+  Dimensions dimensions_{value::ofAuto(), value::ofAuto()};
+  Dimensions minDimensions_{};
+  Dimensions maxDimensions_{};
+  FloatOptional aspectRatio_{};
 };
 
 } // namespace facebook::yoga