Do not expose aggregate style edges (#1477)

Summary: X-link: https://github.com/facebook/react-native/pull/41610 Pull Request resolved: https://github.com/facebook/yoga/pull/1477 A reland of the main change in D50998164, moving away from exposing compound edge arrays directly. Changelog: [Internal] Reviewed By: joevilches Differential Revision: D51512611 fbshipit-source-id: 2d4ceb89c9d76317feb9074aa271358a3abc0ee1
2023-11-22 22:43:41 -08:00
parent 0ebac779aa
commit a822f2635e
6 changed files with 119 additions and 198 deletions
--- a/yoga/YGNodeStyle.cpp
+++ b/yoga/YGNodeStyle.cpp
@@ -35,19 +35,6 @@ void updateStyle(YGNodeRef node, Ref (Style::*prop)(), T value) {
      [prop](Style& s, T x) { (s.*prop)() = x; });
 }

-template <typename Ref, typename Idx>
-void updateIndexedStyleProp(
-    YGNodeRef node,
-    Ref (Style::*prop)(),
-    Idx idx,
-    CompactValue value) {
-  updateStyle(
-      resolveRef(node),
-      value,
-      [idx, prop](Style& s, CompactValue x) { return (s.*prop)()[idx] != x; },
-      [idx, prop](Style& s, CompactValue x) { (s.*prop)()[idx] = x; });
-}
-
 template <auto GetterT, auto SetterT, typename IdxT>
 void updateIndexedStyleProp(YGNodeRef node, IdxT idx, CompactValue value) {
  updateStyle(
@@ -237,53 +224,53 @@ YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {

 void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
  auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
-  updateIndexedStyleProp<MSVC_HINT(position)>(
-      node, &Style::position, edge, value);
+  updateIndexedStyleProp<&Style::position, &Style::setPosition>(
+      node, edge, value);
 }

 void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
  auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
-  updateIndexedStyleProp<MSVC_HINT(position)>(
-      node, &Style::position, edge, value);
+  updateIndexedStyleProp<&Style::position, &Style::setPosition>(
+      node, edge, value);
 }

 YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
-  return resolveRef(node)->getStyle().position()[edge];
+  return resolveRef(node)->getStyle().position(edge);
 }

 void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
  auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
-  updateIndexedStyleProp<MSVC_HINT(margin)>(node, &Style::margin, edge, value);
+  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(node, edge, value);
 }

 void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
  auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
-  updateIndexedStyleProp<MSVC_HINT(margin)>(node, &Style::margin, edge, value);
+  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(node, edge, value);
 }

 void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
-  updateIndexedStyleProp<MSVC_HINT(margin)>(
-      node, &Style::margin, edge, CompactValue::ofAuto());
+  updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
+      node, edge, CompactValue::ofAuto());
 }

 YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
-  return resolveRef(node)->getStyle().margin()[edge];
+  return resolveRef(node)->getStyle().margin(edge);
 }

 void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
  auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
-  updateIndexedStyleProp<MSVC_HINT(padding)>(
-      node, &Style::padding, edge, value);
+  updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
+      node, edge, value);
 }

 void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
  auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
-  updateIndexedStyleProp<MSVC_HINT(padding)>(
-      node, &Style::padding, edge, value);
+  updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
+      node, edge, value);
 }

 YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
-  return resolveRef(node)->getStyle().padding()[edge];
+  return resolveRef(node)->getStyle().padding(edge);
 }

 void YGNodeStyleSetBorder(
@@ -291,11 +278,11 @@ void YGNodeStyleSetBorder(
    const YGEdge edge,
    const float border) {
  auto value = CompactValue::ofMaybe<YGUnitPoint>(border);
-  updateIndexedStyleProp<MSVC_HINT(border)>(node, &Style::border, edge, value);
+  updateIndexedStyleProp<&Style::border, &Style::setBorder>(node, edge, value);
 }

 float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) {
-  auto border = resolveRef(node)->getStyle().border()[edge];
+  auto border = resolveRef(node)->getStyle().border(edge);
  if (border.isUndefined() || border.isAuto()) {
    return YGUndefined;
  }
--- a/yoga/algorithm/FlexDirection.h
+++ b/yoga/algorithm/FlexDirection.h
@@ -11,6 +11,7 @@

 #include <yoga/debug/AssertFatal.h>
 #include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
 #include <yoga/enums/FlexDirection.h>

 namespace facebook::yoga {
--- a/yoga/debug/NodeToString.cpp
+++ b/yoga/debug/NodeToString.cpp
@@ -23,12 +23,6 @@ static void indent(std::string& base, uint32_t level) {
  }
 }

-static bool areFourValuesEqual(const Style::Edges& four) {
-  return yoga::inexactEquals(four[0], four[1]) &&
-      yoga::inexactEquals(four[0], four[2]) &&
-      yoga::inexactEquals(four[0], four[3]);
-}
-
 static void appendFormattedString(std::string& str, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
@@ -86,33 +80,15 @@ static void appendNumberIfNotZero(
  }
 }

-static void appendEdges(
-    std::string& base,
-    const std::string& key,
-    const Style::Edges& edges) {
-  if (areFourValuesEqual(edges)) {
-    auto edgeValue = yoga::Node::computeEdgeValueForColumn(edges, YGEdgeLeft);
-    appendNumberIfNotUndefined(base, key, edgeValue);
-  } else {
-    for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) {
-      std::string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge));
-      appendNumberIfNotZero(base, str, edges[static_cast<size_t>(edge)]);
-    }
+template <auto Field>
+static void
+appendEdges(std::string& base, const std::string& key, const Style& style) {
+  for (auto edge : ordinals<Edge>()) {
+    std::string str = key + "-" + toString(edge);
+    appendNumberIfNotZero(base, str, (style.*Field)(unscopedEnum(edge)));
  }
 }

-static void appendEdgeIfNotUndefined(
-    std::string& base,
-    const std::string& str,
-    const Style::Edges& edges,
-    const YGEdge edge) {
-  // TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account
-  auto value = (edge == YGEdgeLeft || edge == YGEdgeRight)
-      ? yoga::Node::computeEdgeValueForRow(edges, edge, edge)
-      : yoga::Node::computeEdgeValueForColumn(edges, edge);
-  appendNumberIfNotUndefined(base, str, value);
-}
-
 void nodeToString(
    std::string& str,
    const yoga::Node* node,
@@ -173,9 +149,9 @@ void nodeToString(
    if (style.display() != yoga::Node{}.getStyle().display()) {
      appendFormattedString(str, "display: %s; ", toString(style.display()));
    }
-    appendEdges(str, "margin", style.margin());
-    appendEdges(str, "padding", style.padding());
-    appendEdges(str, "border", style.border());
+    appendEdges<&Style::margin>(str, "margin", style);
+    appendEdges<&Style::padding>(str, "padding", style);
+    appendEdges<&Style::border>(str, "border", style);

    if (style.gap(Gutter::All).isDefined()) {
      appendNumberIfNotUndefined(str, "gap", style.gap(Gutter::All));
@@ -200,10 +176,7 @@ void nodeToString(
          str, "position: %s; ", toString(style.positionType()));
    }

-    appendEdgeIfNotUndefined(str, "left", style.position(), YGEdgeLeft);
-    appendEdgeIfNotUndefined(str, "right", style.position(), YGEdgeRight);
-    appendEdgeIfNotUndefined(str, "top", style.position(), YGEdgeTop);
-    appendEdgeIfNotUndefined(str, "bottom", style.position(), YGEdgeBottom);
+    appendEdges<&Style::position>(str, "position", style);
    appendFormattedString(str, "\" ");

    if (node->hasMeasureFunc()) {
--- a/yoga/node/Node.cpp
+++ b/yoga/node/Node.cpp
@@ -56,30 +56,29 @@ void Node::print() {
  }
 }

-CompactValue Node::computeEdgeValueForRow(
-    const Style::Edges& edges,
-    YGEdge rowEdge,
-    YGEdge edge) {
-  if (edges[rowEdge].isDefined()) {
-    return edges[rowEdge];
-  } else if (edges[edge].isDefined()) {
-    return edges[edge];
-  } else if (edges[YGEdgeHorizontal].isDefined()) {
-    return edges[YGEdgeHorizontal];
+// TODO: Edge value resolution should be moved to `yoga::Style`
+template <auto Field>
+CompactValue Node::computeEdgeValueForRow(YGEdge rowEdge, YGEdge edge) const {
+  if ((style_.*Field)(rowEdge).isDefined()) {
+    return (style_.*Field)(rowEdge);
+  } else if ((style_.*Field)(edge).isDefined()) {
+    return (style_.*Field)(edge);
+  } else if ((style_.*Field)(YGEdgeHorizontal).isDefined()) {
+    return (style_.*Field)(YGEdgeHorizontal);
  } else {
-    return edges[YGEdgeAll];
+    return (style_.*Field)(YGEdgeAll);
  }
 }

-CompactValue Node::computeEdgeValueForColumn(
-    const Style::Edges& edges,
-    YGEdge edge) {
-  if (edges[edge].isDefined()) {
-    return edges[edge];
-  } else if (edges[YGEdgeVertical].isDefined()) {
-    return edges[YGEdgeVertical];
+// TODO: Edge value resolution should be moved to `yoga::Style`
+template <auto Field>
+CompactValue Node::computeEdgeValueForColumn(YGEdge edge) const {
+  if ((style_.*Field)(edge).isDefined()) {
+    return (style_.*Field)(edge);
+  } else if ((style_.*Field)(YGEdgeVertical).isDefined()) {
+    return (style_.*Field)(YGEdgeVertical);
  } else {
-    return edges[YGEdgeAll];
+    return (style_.*Field)(YGEdgeAll);
  }
 }

@@ -102,8 +101,8 @@ YGEdge Node::getInlineEndEdgeUsingErrata(
 bool Node::isFlexStartPositionDefined(FlexDirection axis) const {
  const YGEdge startEdge = flexStartEdge(axis);
  auto leadingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.position(), startEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::position>(startEdge);

  return leadingPosition.isDefined();
 }
@@ -112,8 +111,8 @@ bool Node::isInlineStartPositionDefined(FlexDirection axis, Direction direction)
    const {
  const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
  auto leadingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.position(), startEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::position>(startEdge);

  return leadingPosition.isDefined();
 }
@@ -121,8 +120,8 @@ bool Node::isInlineStartPositionDefined(FlexDirection axis, Direction direction)
 bool Node::isFlexEndPositionDefined(FlexDirection axis) const {
  const YGEdge endEdge = flexEndEdge(axis);
  auto trailingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.position(), endEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::position>(endEdge);

  return !trailingPosition.isUndefined();
 }
@@ -131,8 +130,8 @@ bool Node::isInlineEndPositionDefined(FlexDirection axis, Direction direction)
    const {
  const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
  auto trailingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.position(), endEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::position>(endEdge);

  return trailingPosition.isDefined();
 }
@@ -140,8 +139,8 @@ bool Node::isInlineEndPositionDefined(FlexDirection axis, Direction direction)
 float Node::getFlexStartPosition(FlexDirection axis, float axisSize) const {
  const YGEdge startEdge = flexStartEdge(axis);
  auto leadingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.position(), startEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::position>(startEdge);

  return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
 }
@@ -152,8 +151,8 @@ float Node::getInlineStartPosition(
    float axisSize) const {
  const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
  auto leadingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.position(), startEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::position>(startEdge);

  return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
 }
@@ -161,8 +160,8 @@ float Node::getInlineStartPosition(
 float Node::getFlexEndPosition(FlexDirection axis, float axisSize) const {
  const YGEdge endEdge = flexEndEdge(axis);
  auto trailingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.position(), endEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::position>(endEdge);

  return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
 }
@@ -173,8 +172,8 @@ float Node::getInlineEndPosition(
    float axisSize) const {
  const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
  auto trailingPosition = isRow(axis)
-      ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.position(), endEdge);
+      ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::position>(endEdge);

  return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
 }
@@ -182,8 +181,8 @@ float Node::getInlineEndPosition(
 float Node::getFlexStartMargin(FlexDirection axis, float widthSize) const {
  const YGEdge startEdge = flexStartEdge(axis);
  auto leadingMargin = isRow(axis)
-      ? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.margin(), startEdge);
+      ? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::margin>(startEdge);

  return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
 }
@@ -194,8 +193,8 @@ float Node::getInlineStartMargin(
    float widthSize) const {
  const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
  auto leadingMargin = isRow(axis)
-      ? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.margin(), startEdge);
+      ? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::margin>(startEdge);

  return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
 }
@@ -203,8 +202,8 @@ float Node::getInlineStartMargin(
 float Node::getFlexEndMargin(FlexDirection axis, float widthSize) const {
  const YGEdge endEdge = flexEndEdge(axis);
  auto trailingMargin = isRow(axis)
-      ? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.margin(), endEdge);
+      ? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::margin>(endEdge);

  return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
 }
@@ -215,8 +214,8 @@ float Node::getInlineEndMargin(
    float widthSize) const {
  const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
  auto trailingMargin = isRow(axis)
-      ? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.margin(), endEdge);
+      ? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::margin>(endEdge);

  return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
 }
@@ -225,8 +224,8 @@ float Node::getInlineStartBorder(FlexDirection axis, Direction direction)
    const {
  const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
  YGValue leadingBorder = isRow(axis)
-      ? computeEdgeValueForRow(style_.border(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.border(), startEdge);
+      ? computeEdgeValueForRow<&Style::border>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::border>(startEdge);

  return maxOrDefined(leadingBorder.value, 0.0f);
 }
@@ -235,9 +234,9 @@ float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
  const YGEdge leadRelativeFlexItemEdge =
      flexStartRelativeEdge(axis, direction);
  YGValue leadingBorder = isRow(axis)
-      ? computeEdgeValueForRow(
-            style_.border(), leadRelativeFlexItemEdge, flexStartEdge(axis))
-      : computeEdgeValueForColumn(style_.border(), flexStartEdge(axis));
+      ? computeEdgeValueForRow<&Style::border>(
+            leadRelativeFlexItemEdge, flexStartEdge(axis))
+      : computeEdgeValueForColumn<&Style::border>(flexStartEdge(axis));

  return maxOrDefined(leadingBorder.value, 0.0f);
 }
@@ -245,8 +244,8 @@ float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
 float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const {
  const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
  YGValue trailingBorder = isRow(axis)
-      ? computeEdgeValueForRow(style_.border(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.border(), endEdge);
+      ? computeEdgeValueForRow<&Style::border>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::border>(endEdge);

  return maxOrDefined(trailingBorder.value, 0.0f);
 }
@@ -254,9 +253,9 @@ float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const {
 float Node::getFlexEndBorder(FlexDirection axis, Direction direction) const {
  const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
  YGValue trailingBorder = isRow(axis)
-      ? computeEdgeValueForRow(
-            style_.border(), trailRelativeFlexItemEdge, flexEndEdge(axis))
-      : computeEdgeValueForColumn(style_.border(), flexEndEdge(axis));
+      ? computeEdgeValueForRow<&Style::border>(
+            trailRelativeFlexItemEdge, flexEndEdge(axis))
+      : computeEdgeValueForColumn<&Style::border>(flexEndEdge(axis));

  return maxOrDefined(trailingBorder.value, 0.0f);
 }
@@ -267,8 +266,8 @@ float Node::getInlineStartPadding(
    float widthSize) const {
  const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
  auto leadingPadding = isRow(axis)
-      ? computeEdgeValueForRow(style_.padding(), YGEdgeStart, startEdge)
-      : computeEdgeValueForColumn(style_.padding(), startEdge);
+      ? computeEdgeValueForRow<&Style::padding>(YGEdgeStart, startEdge)
+      : computeEdgeValueForColumn<&Style::padding>(startEdge);

  return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
 }
@@ -280,9 +279,9 @@ float Node::getFlexStartPadding(
  const YGEdge leadRelativeFlexItemEdge =
      flexStartRelativeEdge(axis, direction);
  auto leadingPadding = isRow(axis)
-      ? computeEdgeValueForRow(
-            style_.padding(), leadRelativeFlexItemEdge, flexStartEdge(axis))
-      : computeEdgeValueForColumn(style_.padding(), flexStartEdge(axis));
+      ? computeEdgeValueForRow<&Style::padding>(
+            leadRelativeFlexItemEdge, flexStartEdge(axis))
+      : computeEdgeValueForColumn<&Style::padding>(flexStartEdge(axis));

  return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
 }
@@ -293,8 +292,8 @@ float Node::getInlineEndPadding(
    float widthSize) const {
  const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
  auto trailingPadding = isRow(axis)
-      ? computeEdgeValueForRow(style_.padding(), YGEdgeEnd, endEdge)
-      : computeEdgeValueForColumn(style_.padding(), endEdge);
+      ? computeEdgeValueForRow<&Style::padding>(YGEdgeEnd, endEdge)
+      : computeEdgeValueForColumn<&Style::padding>(endEdge);

  return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
 }
@@ -305,9 +304,9 @@ float Node::getFlexEndPadding(
    float widthSize) const {
  const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
  auto trailingPadding = isRow(axis)
-      ? computeEdgeValueForRow(
-            style_.padding(), trailRelativeFlexItemEdge, flexEndEdge(axis))
-      : computeEdgeValueForColumn(style_.padding(), flexEndEdge(axis));
+      ? computeEdgeValueForRow<&Style::padding>(
+            trailRelativeFlexItemEdge, flexEndEdge(axis))
+      : computeEdgeValueForColumn<&Style::padding>(flexEndEdge(axis));

  return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
 }
@@ -565,18 +564,18 @@ void Node::setPosition(
 }

 YGValue Node::getFlexStartMarginValue(FlexDirection axis) const {
-  if (isRow(axis) && style_.margin()[YGEdgeStart].isDefined()) {
-    return style_.margin()[YGEdgeStart];
+  if (isRow(axis) && style_.margin(YGEdgeStart).isDefined()) {
+    return style_.margin(YGEdgeStart);
  } else {
-    return style_.margin()[flexStartEdge(axis)];
+    return style_.margin(flexStartEdge(axis));
  }
 }

 YGValue Node::marginTrailingValue(FlexDirection axis) const {
-  if (isRow(axis) && style_.margin()[YGEdgeEnd].isDefined()) {
-    return style_.margin()[YGEdgeEnd];
+  if (isRow(axis) && style_.margin(YGEdgeEnd).isDefined()) {
+    return style_.margin(YGEdgeEnd);
  } else {
-    return style_.margin()[flexEndEdge(axis)];
+    return style_.margin(flexEndEdge(axis));
  }
 }

--- a/yoga/node/Node.h
+++ b/yoga/node/Node.h
@@ -65,6 +65,12 @@ class YG_EXPORT Node : public ::YGNode {
    style_.alignContent() = Align::Stretch;
  }

+  template <auto Field>
+  CompactValue computeEdgeValueForColumn(YGEdge edge) const;
+
+  template <auto Field>
+  CompactValue computeEdgeValueForRow(YGEdge rowEdge, YGEdge edge) const;
+
  // DANGER DANGER DANGER!
  // If the node assigned to has children, we'd either have to deallocate
  // them (potentially incorrect) or ignore them (danger of leaks). Only ever
@@ -189,15 +195,6 @@ class YG_EXPORT Node : public ::YGNode {
    return resolvedDimensions_[static_cast<size_t>(dimension)];
  }

-  static CompactValue computeEdgeValueForColumn(
-      const Style::Edges& edges,
-      YGEdge edge);
-
-  static CompactValue computeEdgeValueForRow(
-      const Style::Edges& edges,
-      YGEdge rowEdge,
-      YGEdge edge);
-
  // Methods related to positions, margin, padding and border
  bool isFlexStartPositionDefined(FlexDirection axis) const;
  bool isInlineStartPositionDefined(FlexDirection axis, Direction direction)
--- a/yoga/style/Style.h
+++ b/yoga/style/Style.h
@@ -35,11 +35,11 @@ class YG_EXPORT Style {
  template <typename Enum>
  using Values = std::array<CompactValue, ordinalCount<Enum>()>;

- public:
  using Dimensions = Values<Dimension>;
  using Edges = Values<YGEdge>;
  using Gutters = Values<Gutter>;

+ public:
  static constexpr float DefaultFlexGrow = 0.0f;
  static constexpr float DefaultFlexShrink = 0.0f;
  static constexpr float WebDefaultFlexShrink = 1.0f;
@@ -69,39 +69,6 @@ class YG_EXPORT Style {
    }
  };

-  template <typename Idx, Values<Idx> Style::*Prop>
-  struct IdxRef {
-    struct Ref {
-      Style& style;
-      Idx idx;
-      operator CompactValue() const {
-        return (style.*Prop)[idx];
-      }
-      operator YGValue() const {
-        return (style.*Prop)[idx];
-      }
-      Ref& operator=(CompactValue value) {
-        (style.*Prop)[idx] = value;
-        return *this;
-      }
-    };
-
-    Style& style;
-    IdxRef<Idx, Prop>& operator=(const Values<Idx>& values) {
-      style.*Prop = values;
-      return *this;
-    }
-    operator const Values<Idx>&() const {
-      return style.*Prop;
-    }
-    Ref operator[](Idx idx) {
-      return {style, idx};
-    }
-    CompactValue operator[](Idx idx) const {
-      return (style.*Prop)[idx];
-    }
-  };
-
  Style() {
    alignContent() = Align::FlexStart;
    alignItems() = Align::Stretch;
@@ -147,9 +114,6 @@ class YG_EXPORT Style {
  FloatOptional aspectRatio_ = {};

 public:
-  // for library users needing a type
-  using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;
-
  Direction direction() const {
    return getEnumData<Direction>(flags, directionOffset);
  }
@@ -248,32 +212,32 @@ class YG_EXPORT Style {
    return {*this};
  }

-  const Edges& margin() const {
-    return margin_;
+  CompactValue margin(YGEdge edge) const {
+    return margin_[edge];
  }
-  IdxRef<YGEdge, &Style::margin_> margin() {
-    return {*this};
+  void setMargin(YGEdge edge, CompactValue value) {
+    margin_[edge] = value;
  }

-  const Edges& position() const {
-    return position_;
+  CompactValue position(YGEdge edge) const {
+    return position_[edge];
  }
-  IdxRef<YGEdge, &Style::position_> position() {
-    return {*this};
+  void setPosition(YGEdge edge, CompactValue value) {
+    position_[edge] = value;
  }

-  const Edges& padding() const {
-    return padding_;
+  CompactValue padding(YGEdge edge) const {
+    return padding_[edge];
  }
-  IdxRef<YGEdge, &Style::padding_> padding() {
-    return {*this};
+  void setPadding(YGEdge edge, CompactValue value) {
+    padding_[edge] = value;
  }

-  const Edges& border() const {
-    return border_;
+  CompactValue border(YGEdge edge) const {
+    return border_[edge];
  }
-  IdxRef<YGEdge, &Style::border_> border() {
-    return {*this};
+  void setBorder(YGEdge edge, CompactValue value) {
+    border_[edge] = value;
  }

  CompactValue gap(Gutter gutter) const {