Bug 1958914: Treat AnchorResolved-using types as instantiations, not subtypes. r=layout-reviewers,emilio

Differential Revision: https://phabricator.services.mozilla.com/D244658

layout/base/nsLayoutUtils.cpp

@@ -4687,12 +4687,12 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
                            : stylePos->GetMinHeight(positionProperty);
   auto styleISize = [&]() {
     if (aFlags & MIN_INTRINSIC_ISIZE) {
-      return AnchorResolvedSize::Overridden(*styleMinISize);
+      return AnchorResolvedSizeHelper::Overridden(*styleMinISize);
     }
     const Maybe<StyleSize>& styleISizeOverride =
         isInlineAxis ? aSizeOverrides.mStyleISize : aSizeOverrides.mStyleBSize;
     return styleISizeOverride
-               ? AnchorResolvedSize::Overridden(*styleISizeOverride)
+               ? AnchorResolvedSizeHelper::Overridden(*styleISizeOverride)
                : (horizontalAxis ? stylePos->GetWidth(positionProperty)
                                  : stylePos->GetHeight(positionProperty));
   }();
@@ -4707,13 +4707,13 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
                             AnchorResolvedSize& aMinSize,
                             AnchorResolvedMaxSize& aMaxSize) {
     if (!aSize->IsLengthPercentage()) {
-      aSize = AnchorResolvedSize::Auto();
+      aSize = AnchorResolvedSizeHelper::Auto();
     }
     if (!aMinSize->IsLengthPercentage()) {
-      aMinSize = AnchorResolvedSize::Auto();
+      aMinSize = AnchorResolvedSizeHelper::Auto();
     }
     if (!aMaxSize->IsLengthPercentage()) {
-      aMaxSize = AnchorResolvedMaxSize::None();
+      aMaxSize = AnchorResolvedMaxSizeHelper::None();
     }
   };
   // According to the spec, max-content and min-content should behave as the
@@ -4758,7 +4758,7 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
       isInlineAxis ? aSizeOverrides.mStyleBSize : aSizeOverrides.mStyleISize;
   auto styleBSize =
       styleBSizeOverride
-          ? AnchorResolvedSize::Overridden(*styleBSizeOverride)
+          ? AnchorResolvedSizeHelper::Overridden(*styleBSizeOverride)
           : (horizontalAxis ? stylePos->GetHeight(positionProperty)
                             : stylePos->GetWidth(positionProperty));
   auto styleMinBSize = horizontalAxis ? stylePos->GetMinHeight(positionProperty)
@@ -5071,10 +5071,10 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis(
   // if needed.
   if (aAxis != ourInlineAxis) {
     if (size->BehavesLikeInitialValueOnBlockAxis()) {
-      size = AnchorResolvedSize::Auto();
+      size = AnchorResolvedSizeHelper::Auto();
     }
     if (maxSize->BehavesLikeInitialValueOnBlockAxis()) {
-      maxSize = AnchorResolvedMaxSize::None();
+      maxSize = AnchorResolvedMaxSizeHelper::None();
     }
   }
 
@@ -5092,7 +5092,7 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis(
       // values in block axis.
       if (aAxis != ourInlineAxis &&
           size->BehavesLikeInitialValueOnBlockAxis()) {
-        size = AnchorResolvedSize::Auto();
+        size = AnchorResolvedSizeHelper::Auto();
       }
 
       fixedMinSize = GetAbsoluteSize(*size);

layout/generic/WritingModes.h

@@ -2131,11 +2131,6 @@ inline bool StyleMaxSize::BehavesLikeInitialValue(LogicalAxis aAxis) const {
 
 // Definitions of inline methods for nsStylePosition, declared in
 // nsStyleStruct.h but not defined there because they need WritingMode.
-inline AnchorResolvedInset::AnchorResolvedInset(
-  const mozilla::StyleInset& aValue, mozilla::LogicalAxis aAxis,
-  mozilla::WritingMode aWM, mozilla::StylePositionProperty aPosition)
-  : AnchorResolved<mozilla::StyleInset>{FromUnresolved(
-        aValue, ToStylePhysicalAxis(aWM.PhysicalAxis(aAxis)), aPosition)} {}
 
 inline AnchorResolvedInset nsStylePosition::GetAnchorResolvedInset(
     mozilla::LogicalSide aSide, WritingMode aWM,

layout/generic/nsContainerFrame.cpp

@@ -2207,14 +2207,14 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
   const auto positionProperty = StyleDisplay()->mPosition;
   const auto styleISize =
       aSizeOverrides.mStyleISize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
           : stylePos->ISize(aWM, positionProperty);
 
   // TODO(dholbert): if styleBSize is 'stretch' here, we should probably
   // resolve it like we do in nsIFrame::ComputeSize. See bug 1937275.
   const auto styleBSize =
       aSizeOverrides.mStyleBSize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
           : stylePos->BSize(aWM, positionProperty);
   const auto& aspectRatio =
       aSizeOverrides.mAspectRatio ? *aSizeOverrides.mAspectRatio : aAspectRatio;

layout/generic/nsGridContainerFrame.cpp

@@ -338,7 +338,7 @@ struct RepeatTrackSizingInput {
     // When computing the intrinsic inline size, disregard the explicit
     // inline-size property as it should not affect the final result.
     const auto styleSize = aAxis == LogicalAxis::Inline
-                               ? AnchorResolvedSize::Auto()
+                               ? AnchorResolvedSizeHelper::Auto()
                                : pos->BSize(aWM, positionProperty);
     if (styleSize->ConvertsToLength()) {
       size = std::clamp(adjustForBoxSizing(styleSize->ToLength()), min, max);

layout/generic/nsIFrame.cpp

@@ -6473,7 +6473,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
                                 : GetAspectRatio();
   const auto styleISize =
       aSizeOverrides.mStyleISize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
           : stylePos->ISize(aWM, positionProperty);
   // For bsize, we consider overrides *and then* we resolve 'stretch' to a
   // nscoord value, for convenience (so that we can assume that either
@@ -6481,7 +6481,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
   const auto styleBSize = [&] {
     auto styleBSizeConsideringOverrides =
         (aSizeOverrides.mStyleBSize)
-            ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize)
+            ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
             : stylePos->BSize(aWM, positionProperty);
     if (styleBSizeConsideringOverrides->BehavesLikeStretchOnBlockAxis() &&
         aCBSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
@@ -6489,7 +6489,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
       nscoord stretchBSize = nsLayoutUtils::ComputeStretchBSize(
           aCBSize.BSize(aWM), aMargin.BSize(aWM), aBorderPadding.BSize(aWM),
           stylePos->mBoxSizing);
-      return AnchorResolvedSize::LengthPercentage(
+      return AnchorResolvedSizeHelper::LengthPercentage(
           LengthPercentage::FromAppUnits(stretchBSize));
     }
     return styleBSizeConsideringOverrides;
@@ -6928,7 +6928,7 @@ LogicalSize nsIFrame::ComputeAutoSize(
   // don't bother setting it if the result won't be used
   const auto styleISize =
       aSizeOverrides.mStyleISize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
           : StylePosition()->ISize(aWM, positionProperty);
   if (styleISize->IsAuto()) {
     nscoord availBased = nsLayoutUtils::ComputeStretchContentBoxISize(
@@ -6936,7 +6936,7 @@ LogicalSize nsIFrame::ComputeAutoSize(
     const auto* stylePos = StylePosition();
     const auto styleBSize =
         aSizeOverrides.mStyleBSize
-            ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize)
+            ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
             : stylePos->BSize(aWM, positionProperty);
     const LogicalSize contentEdgeToBoxSizing =
         stylePos->mBoxSizing == StyleBoxSizing::Border ? aBorderPadding
@@ -6981,11 +6981,11 @@ LogicalSize nsIFrame::ComputeAbsolutePosAutoSize(
   const auto positionProperty = StyleDisplay()->mPosition;
   const auto& styleISize =
       aSizeOverrides.mStyleISize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
           : stylePos->ISize(aWM, positionProperty);
   const auto& styleBSize =
       aSizeOverrides.mStyleBSize
-          ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize)
+          ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
           : stylePos->BSize(aWM, positionProperty);
   const auto iStartOffsetIsAuto =
       stylePos

layout/style/nsComputedDOMStyle.cpp

@@ -1844,7 +1844,7 @@ already_AddRefed<CSSValue> nsComputedDOMStyle::DoGetMinHeight() {
 
   if (minHeight->IsAuto() &&
       !ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Vertical)) {
-    minHeight = AnchorResolvedSize::Zero();
+    minHeight = AnchorResolvedSizeHelper::Zero();
   }
 
   SetValueToSize(val, minHeight);
@@ -1858,7 +1858,7 @@ already_AddRefed<CSSValue> nsComputedDOMStyle::DoGetMinWidth() {
 
   if (minWidth->IsAuto() &&
       !ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Horizontal)) {
-    minWidth = AnchorResolvedSize::Zero();
+    minWidth = AnchorResolvedSizeHelper::Zero();
   }
 
   SetValueToSize(val, minWidth);

layout/style/nsStyleStruct.cpp

@@ -286,9 +286,8 @@ static StyleRect<T> StyleRectWithAllSides(const T& aSide) {
   return {aSide, aSide, aSide, aSide};
 }
 
-AnchorResolved<mozilla::StyleMargin> AnchorResolvedMargin::ResolveAnchor(
+AnchorResolvedMargin AnchorResolvedMarginHelper::ResolveAnchor(
-    const mozilla::StyleMargin& aValue,
+    const StyleMargin& aValue, StylePositionProperty aPosition) {
-    mozilla::StylePositionProperty aPosition) {
   MOZ_ASSERT(aValue.HasAnchorPositioningFunction(),
              "Calling anchor resolution without using it?");
   if (aValue.IsAnchorSizeFunction()) {
@@ -296,12 +295,15 @@ AnchorResolved<mozilla::StyleMargin> AnchorResolvedMargin::ResolveAnchor(
     Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition,
                                     &resolved);
     if (resolved.IsInvalid()) {
-      return Invalid();
+      return AnchorResolvedMargin::Evaluated(
+          StyleMargin::LengthPercentage(StyleLengthPercentage::Zero()));
     }
     if (resolved.IsResolvedReference()) {
-      return Evaluated(*resolved.AsResolvedReference());
+      return AnchorResolvedMargin::Evaluated(
+          StyleMargin::LengthPercentage(*resolved.AsResolvedReference()));
     }
-    return Evaluated(resolved.AsResolved());
+    return AnchorResolvedMargin::Evaluated(
+        StyleMargin::LengthPercentage(resolved.AsResolved()));
   }
 
   const auto& lp = aValue.AsAnchorContainingCalcFunction();
@@ -309,9 +311,11 @@ AnchorResolved<mozilla::StyleMargin> AnchorResolvedMargin::ResolveAnchor(
   auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid();
   Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result);
   if (result.IsInvalid()) {
-    return Invalid();
+    return AnchorResolvedMargin::Evaluated(
+        StyleMargin::LengthPercentage(StyleLengthPercentage::Zero()));
   }
-  return Evaluated(result.AsValid());
+  return AnchorResolvedMargin::Evaluated(
+      StyleMargin::LengthPercentage(result.AsValid()));
 }
 
 nsStyleMargin::nsStyleMargin()
@@ -1363,10 +1367,9 @@ StyleJustifySelf nsStylePosition::UsedJustifySelf(
   return {StyleAlignFlags::NORMAL};
 }
 
-AnchorResolved<mozilla::StyleInset> AnchorResolvedInset::ResolveAnchor(
+AnchorResolvedInset AnchorResolvedInsetHelper::ResolveAnchor(
     const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis,
     mozilla::StylePositionProperty aPosition) {
-  // TODO(dshin): Maybe worth pref-gating here.
   static_assert(static_cast<uint8_t>(mozilla::PhysicalAxis::Vertical) ==
                     static_cast<uint8_t>(StylePhysicalAxis::Vertical),
                 "Vertical axis doesn't match");
@@ -1383,41 +1386,46 @@ AnchorResolved<mozilla::StyleInset> AnchorResolvedInset::ResolveAnchor(
       Servo_ResolveAnchorFunctionsInCalcPercentage(&c, &aAxis, aPosition,
                                                    &result);
       if (result.IsInvalid()) {
-        return Invalid();
+        return AnchorResolvedInset::Evaluated(StyleInset::Auto());
       }
-      return Evaluated(result.AsValid());
+      return AnchorResolvedInset::Evaluated(
+          StyleInset::LengthPercentage(result.AsValid()));
     }
     case StyleInset::Tag::AnchorFunction: {
       auto resolved = StyleAnchorPositioningFunctionResolution::Invalid();
       Servo_ResolveAnchorFunction(&*aValue.AsAnchorFunction(), aAxis, aPosition,
                                   &resolved);
       if (resolved.IsInvalid()) {
-        return Invalid();
+        return AnchorResolvedInset::Evaluated(StyleInset::Auto());
       }
       if (resolved.IsResolvedReference()) {
-        return Evaluated(*resolved.AsResolvedReference());
+        return AnchorResolvedInset::Evaluated(
+            StyleInset::LengthPercentage(*resolved.AsResolvedReference()));
       }
-      return Evaluated(resolved.AsResolved());
+      return AnchorResolvedInset::Evaluated(
+          StyleInset::LengthPercentage(resolved.AsResolved()));
     }
     case StyleInset::Tag::AnchorSizeFunction: {
       auto resolved = StyleAnchorPositioningFunctionResolution::Invalid();
       Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(),
                                       aPosition, &resolved);
       if (resolved.IsInvalid()) {
-        return Invalid();
+        return AnchorResolvedInset::Evaluated(StyleInset::Auto());
       }
       if (resolved.IsResolvedReference()) {
-        return Evaluated(*resolved.AsResolvedReference());
+        return AnchorResolvedInset::Evaluated(
+            StyleInset::LengthPercentage(*resolved.AsResolvedReference()));
       }
-      return Evaluated(resolved.AsResolved());
+      return AnchorResolvedInset::Evaluated(
+          StyleInset::LengthPercentage(resolved.AsResolved()));
     }
     default:
       MOZ_ASSERT_UNREACHABLE("Unhandled inset type");
-      return Invalid();
+      return AnchorResolvedInset::Evaluated(StyleInset::Auto());
   }
 }
 
-AnchorResolved<mozilla::StyleSize> AnchorResolvedSize::ResolveAnchor(
+AnchorResolvedSize AnchorResolvedSizeHelper::ResolveAnchor(
     const mozilla::StyleSize& aValue,
     mozilla::StylePositionProperty aPosition) {
   MOZ_ASSERT(aValue.HasAnchorPositioningFunction(),
@@ -1427,12 +1435,14 @@ AnchorResolved<mozilla::StyleSize> AnchorResolvedSize::ResolveAnchor(
     Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition,
                                     &resolved);
     if (resolved.IsInvalid()) {
-      return Invalid();
+      return AnchorResolvedSize::Evaluated(StyleSize::Auto());
     }
     if (resolved.IsResolvedReference()) {
-      return Evaluated(*resolved.AsResolvedReference());
+      return AnchorResolvedSize::Evaluated(
+          StyleSize::LengthPercentage(*resolved.AsResolvedReference()));
     }
-    return Evaluated(resolved.AsResolved());
+    return AnchorResolvedSize::Evaluated(
+        StyleSize::LengthPercentage(resolved.AsResolved()));
   }
 
   const auto& lp = aValue.AsAnchorContainingCalcFunction();
@@ -1441,12 +1451,13 @@ AnchorResolved<mozilla::StyleSize> AnchorResolvedSize::ResolveAnchor(
   auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid();
   Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result);
   if (result.IsInvalid()) {
-    return Invalid();
+    return AnchorResolvedSize::Evaluated(StyleSize::Auto());
   }
-  return Evaluated(result.AsValid());
+  return AnchorResolvedSize::Evaluated(
+      StyleSize::LengthPercentage(result.AsValid()));
 }
 
-AnchorResolved<mozilla::StyleMaxSize> AnchorResolvedMaxSize::ResolveAnchor(
+AnchorResolvedMaxSize AnchorResolvedMaxSizeHelper::ResolveAnchor(
     const mozilla::StyleMaxSize& aValue,
     mozilla::StylePositionProperty aPosition) {
   MOZ_ASSERT(aValue.HasAnchorPositioningFunction(),
@@ -1456,12 +1467,14 @@ AnchorResolved<mozilla::StyleMaxSize> AnchorResolvedMaxSize::ResolveAnchor(
     Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition,
                                     &resolved);
     if (resolved.IsInvalid()) {
-      return Invalid();
+      return AnchorResolvedMaxSize::Evaluated(StyleMaxSize::None());
     }
     if (resolved.IsResolvedReference()) {
-      return Evaluated(*resolved.AsResolvedReference());
+      return AnchorResolvedMaxSize::Evaluated(
+          StyleMaxSize::LengthPercentage(*resolved.AsResolvedReference()));
     }
-    return Evaluated(resolved.AsResolved());
+    return AnchorResolvedMaxSize::Evaluated(
+        StyleMaxSize::LengthPercentage(resolved.AsResolved()));
   }
 
   const auto& lp = aValue.AsAnchorContainingCalcFunction();
@@ -1470,9 +1483,10 @@ AnchorResolved<mozilla::StyleMaxSize> AnchorResolvedMaxSize::ResolveAnchor(
   auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid();
   Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result);
   if (result.IsInvalid()) {
-    return Invalid();
+    return AnchorResolvedMaxSize::Evaluated(StyleMaxSize::None());
   }
-  return Evaluated(result.AsValid());
+  return AnchorResolvedMaxSize::Evaluated(
+      StyleMaxSize::LengthPercentage(result.AsValid()));
 }
 
 // --------------------

layout/style/nsStyleStruct.h

@@ -428,7 +428,6 @@ class AnchorResolved {
   AnchorResolved(const AnchorResolved& aOther) = delete;
   AnchorResolved& operator=(const AnchorResolved& aOther) = delete;
 
- protected:
   static AnchorResolved Evaluated(T&& aValue) {
     AnchorResolved result;
     result.mIsValue = true;
@@ -457,38 +456,22 @@ class AnchorResolved {
   };
 };
 
-class AnchorResolvedMargin final : public AnchorResolved<mozilla::StyleMargin> {
+using AnchorResolvedMargin = AnchorResolved<mozilla::StyleMargin>;
- public:
-  AnchorResolvedMargin(const mozilla::StyleMargin& aValue,
-                       mozilla::StylePositionProperty aPosition)
-      : AnchorResolved{FromUnresolved(aValue, aPosition)} {}
 
- private:
+struct AnchorResolvedMarginHelper {
-  static AnchorResolved<mozilla::StyleMargin> FromUnresolved(
+  static AnchorResolvedMargin FromUnresolved(
       const mozilla::StyleMargin& aValue,
       mozilla::StylePositionProperty aPosition) {
     if (!aValue.HasAnchorPositioningFunction()) {
-      return Unchanged(aValue);
+      return AnchorResolvedMargin::Unchanged(aValue);
     }
     return ResolveAnchor(aValue, aPosition);
   }
-  static AnchorResolved<mozilla::StyleMargin> ResolveAnchor(
+
+ private:
+  static AnchorResolvedMargin ResolveAnchor(
       const mozilla::StyleMargin& aValue,
       mozilla::StylePositionProperty aPosition);
-  static AnchorResolved<mozilla::StyleMargin> Invalid() {
-    return AnchorResolved::Evaluated(mozilla::StyleMargin::LengthPercentage(
-        mozilla::StyleLengthPercentage::Zero()));
-  }
-  static AnchorResolved<mozilla::StyleMargin> Evaluated(
-      mozilla::StyleLengthPercentage&& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleMargin::LengthPercentage(aLP));
-  }
-  static AnchorResolved<mozilla::StyleMargin> Evaluated(
-      const mozilla::StyleLengthPercentage& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleMargin::LengthPercentage(aLP));
-  }
 };
 
 struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleMargin {
@@ -533,7 +516,8 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleMargin {
   // a later point.
   AnchorResolvedMargin GetMargin(
       mozilla::Side aSide, mozilla::StylePositionProperty aPosition) const {
-    return {mMargin.Get(aSide), aPosition};
+    return AnchorResolvedMarginHelper::FromUnresolved(mMargin.Get(aSide),
+                                                      aPosition);
   }
 
   bool MarginEquals(const nsStyleMargin& aOther) const {
@@ -825,155 +809,89 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePage {
   StylePageOrientation mPageOrientation = StylePageOrientation::Upright;
 };
 
-class AnchorResolvedInset final : public AnchorResolved<mozilla::StyleInset> {
+using AnchorResolvedInset = AnchorResolved<mozilla::StyleInset>;
- public:
-  AnchorResolvedInset(const mozilla::StyleInset& aValue,
-                      mozilla::StylePhysicalAxis aAxis,
-                      mozilla::StylePositionProperty aPosition)
-      : AnchorResolved<mozilla::StyleInset>{
-            FromUnresolved(aValue, aAxis, aPosition)} {}
-  inline AnchorResolvedInset(const mozilla::StyleInset& aValue,
-                             mozilla::LogicalAxis aAxis,
-                             mozilla::WritingMode aWM,
-                             mozilla::StylePositionProperty aPosition);
 
- private:
+struct AnchorResolvedInsetHelper {
-  static AnchorResolved<mozilla::StyleInset> FromUnresolved(
+  static AnchorResolvedInset FromUnresolved(
       const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis,
       mozilla::StylePositionProperty aPosition) {
     if (!aValue.HasAnchorPositioningFunction()) {
-      return AnchorResolved::Unchanged(aValue);
+      return AnchorResolvedInset::Unchanged(aValue);
     }
     return ResolveAnchor(aValue, aAxis, aPosition);
   }
-  static AnchorResolved<mozilla::StyleInset> ResolveAnchor(
+
+ private:
+  static AnchorResolvedInset ResolveAnchor(
       const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis,
       mozilla::StylePositionProperty aPosition);
-  static AnchorResolved<mozilla::StyleInset> Invalid() {
-    return AnchorResolved::Evaluated(mozilla::StyleInset::Auto());
-  }
-  static AnchorResolved<mozilla::StyleInset> Evaluated(
-      mozilla::StyleLengthPercentage&& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleInset::LengthPercentage(aLP));
-  }
-  static AnchorResolved<mozilla::StyleInset> Evaluated(
-      const mozilla::StyleLengthPercentage& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleInset::LengthPercentage(aLP));
-  }
 };
 
-class AnchorResolvedSize final : public AnchorResolved<mozilla::StyleSize> {
+using AnchorResolvedSize = AnchorResolved<mozilla::StyleSize>;
- public:
+
-  AnchorResolvedSize(const mozilla::StyleSize& aValue,
+struct AnchorResolvedSizeHelper {
-                     mozilla::StylePositionProperty aPosition)
+  static AnchorResolvedSize FromUnresolved(
-      : AnchorResolved<mozilla::StyleSize>{FromUnresolved(aValue, aPosition)} {}
+      const mozilla::StyleSize& aValue,
+      mozilla::StylePositionProperty aPosition) {
+    if (!aValue.HasAnchorPositioningFunction()) {
+      return AnchorResolvedSize::Unchanged(aValue);
+    }
+    return ResolveAnchor(aValue, aPosition);
+  }
 
-  AnchorResolvedSize(AnchorResolvedSize&& aOther) = default;
-  AnchorResolvedSize& operator=(AnchorResolvedSize&& aOther) = default;
   static AnchorResolvedSize Overridden(const mozilla::StyleSize& aSize) {
-    return AnchorResolvedSize{aSize};
+    return AnchorResolvedSize::Unchanged(aSize);
   }
 
   static AnchorResolvedSize Zero() {
-    return AnchorResolvedSize{mozilla::StyleSize::LengthPercentage(
+    return AnchorResolvedSize::Evaluated(mozilla::StyleSize::LengthPercentage(
-        mozilla::StyleLengthPercentage::Zero())};
+        mozilla::StyleLengthPercentage::Zero()));
   }
 
   static AnchorResolvedSize MinContent() {
-    return AnchorResolvedSize{mozilla::StyleSize::MinContent()};
+    return AnchorResolvedSize::Evaluated(mozilla::StyleSize::MinContent());
   }
 
   static AnchorResolvedSize Auto() {
-    return AnchorResolvedSize{mozilla::StyleSize::Auto()};
+    return AnchorResolvedSize::Evaluated(mozilla::StyleSize::Auto());
   }
 
   static AnchorResolvedSize LengthPercentage(
       const mozilla::StyleLengthPercentage& aLP) {
-    return AnchorResolvedSize{mozilla::StyleSize::LengthPercentage(aLP)};
+    return AnchorResolvedSize::Evaluated(
+        mozilla::StyleSize::LengthPercentage(aLP));
   }
 
  private:
-  explicit AnchorResolvedSize(mozilla::StyleSize&& aSize)
-      : AnchorResolved<mozilla::StyleSize>{
-            AnchorResolved::Evaluated(std::move(aSize))} {}
-  explicit AnchorResolvedSize(const mozilla::StyleSize& aSize)
-      : AnchorResolved<mozilla::StyleSize>{AnchorResolved::Unchanged(aSize)} {}
-
-  static AnchorResolved<mozilla::StyleSize> FromUnresolved(
-      const mozilla::StyleSize& aValue,
-      mozilla::StylePositionProperty aPosition) {
-    if (!aValue.HasAnchorPositioningFunction()) {
-      return AnchorResolved::Unchanged(aValue);
-    }
-    return ResolveAnchor(aValue, aPosition);
-  }
-
   static AnchorResolved<mozilla::StyleSize> ResolveAnchor(
       const mozilla::StyleSize& aValue,
       mozilla::StylePositionProperty aPosition);
-
-  static AnchorResolved<mozilla::StyleSize> Invalid() {
-    return AnchorResolved::Evaluated(mozilla::StyleSize::Auto());
-  }
-
-  static AnchorResolved<mozilla::StyleSize> Evaluated(
-      mozilla::StyleLengthPercentage&& aLP) {
-    return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP));
-  }
-
-  static AnchorResolved<mozilla::StyleSize> Evaluated(
-      const mozilla::StyleLengthPercentage& aLP) {
-    return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP));
-  }
 };
 
-class AnchorResolvedMaxSize final
+using AnchorResolvedMaxSize = AnchorResolved<mozilla::StyleMaxSize>;
-    : public AnchorResolved<mozilla::StyleMaxSize> {
- public:
-  AnchorResolvedMaxSize(const mozilla::StyleMaxSize& aValue,
-                        mozilla::StylePositionProperty aPosition)
-      : AnchorResolved<mozilla::StyleMaxSize>{
-            FromUnresolved(aValue, aPosition)} {}
 
-  static AnchorResolvedMaxSize MaxContent() {
+struct AnchorResolvedMaxSizeHelper {
-    return AnchorResolvedMaxSize{mozilla::StyleMaxSize::MaxContent()};
+  static AnchorResolvedMaxSize FromUnresolved(
-  }
-
-  static AnchorResolvedMaxSize None() {
-    return AnchorResolvedMaxSize{mozilla::StyleMaxSize::None()};
-  }
-
- private:
-  explicit AnchorResolvedMaxSize(mozilla::StyleMaxSize&& aSize)
-      : AnchorResolved<mozilla::StyleMaxSize>{
-            AnchorResolved::Evaluated(std::move(aSize))} {}
-
-  static AnchorResolved<mozilla::StyleMaxSize> FromUnresolved(
       const mozilla::StyleMaxSize& aValue,
       mozilla::StylePositionProperty aPosition) {
     if (!aValue.HasAnchorPositioningFunction()) {
-      return AnchorResolved::Unchanged(aValue);
+      return AnchorResolvedMaxSize::Unchanged(aValue);
     }
     return ResolveAnchor(aValue, aPosition);
   }
-  static AnchorResolved<mozilla::StyleMaxSize> ResolveAnchor(
+  static AnchorResolvedMaxSize MaxContent() {
+    return AnchorResolvedMaxSize::Evaluated(
+        mozilla::StyleMaxSize::MaxContent());
+  }
+
+  static AnchorResolvedMaxSize None() {
+    return AnchorResolvedMaxSize::Evaluated(mozilla::StyleMaxSize::None());
+  }
+
+ private:
+  static AnchorResolvedMaxSize ResolveAnchor(
       const mozilla::StyleMaxSize& aValue,
       mozilla::StylePositionProperty aPosition);
-  static AnchorResolved<mozilla::StyleMaxSize> Invalid() {
-    return AnchorResolved::Evaluated(mozilla::StyleMaxSize::None());
-  }
-  static AnchorResolved<mozilla::StyleMaxSize> Evaluated(
-      mozilla::StyleLengthPercentage&& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleMaxSize::LengthPercentage(aLP));
-  }
-  static AnchorResolved<mozilla::StyleMaxSize> Evaluated(
-      const mozilla::StyleLengthPercentage& aLP) {
-    return AnchorResolved::Evaluated(
-        mozilla::StyleMaxSize::LengthPercentage(aLP));
-  }
 };
 
 struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition {
@@ -1131,36 +1049,37 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition {
   // interleaving computation is implemented.
   AnchorResolvedInset GetAnchorResolvedInset(
       mozilla::Side aSide, mozilla::StylePositionProperty aPosition) const {
-    return {mOffset.Get(aSide), GetStylePhysicalAxis(aSide), aPosition};
+    return AnchorResolvedInsetHelper::FromUnresolved(
+        mOffset.Get(aSide), GetStylePhysicalAxis(aSide), aPosition);
   }
   inline AnchorResolvedInset GetAnchorResolvedInset(
       mozilla::LogicalSide aSide, WritingMode aWM,
       mozilla::StylePositionProperty aPosition) const;
 
   AnchorResolvedSize GetWidth(mozilla::StylePositionProperty aProp) const {
-    return {mWidth, aProp};
+    return AnchorResolvedSizeHelper::FromUnresolved(mWidth, aProp);
   }
 
   AnchorResolvedSize GetHeight(mozilla::StylePositionProperty aProp) const {
-    return {mHeight, aProp};
+    return AnchorResolvedSizeHelper::FromUnresolved(mHeight, aProp);
   }
 
   AnchorResolvedSize GetMinWidth(mozilla::StylePositionProperty aProp) const {
-    return {mMinWidth, aProp};
+    return AnchorResolvedSizeHelper::FromUnresolved(mMinWidth, aProp);
   }
 
   AnchorResolvedSize GetMinHeight(mozilla::StylePositionProperty aProp) const {
-    return {mMinHeight, aProp};
+    return AnchorResolvedSizeHelper::FromUnresolved(mMinHeight, aProp);
   }
 
   AnchorResolvedMaxSize GetMaxWidth(
       mozilla::StylePositionProperty aProp) const {
-    return {mMaxWidth, aProp};
+    return AnchorResolvedMaxSizeHelper::FromUnresolved(mMaxWidth, aProp);
   }
 
   AnchorResolvedMaxSize GetMaxHeight(
       mozilla::StylePositionProperty aProp) const {
-    return {mMaxHeight, aProp};
+    return AnchorResolvedMaxSizeHelper::FromUnresolved(mMaxHeight, aProp);
   }
 
  private:

layout/tables/BasicTableLayoutStrategy.cpp

@@ -183,11 +183,11 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
   auto maxISize = stylePos->MaxISize(aWM, positionProperty);
   if (nsIFrame::ToExtremumLength(*maxISize)) {
     if (!aIsCell || maxISize->BehavesLikeStretchOnInlineAxis()) {
-      maxISize = AnchorResolvedMaxSize::None();
+      maxISize = AnchorResolvedMaxSizeHelper::None();
     } else if (maxISize->IsFitContent() || maxISize->IsFitContentFunction()) {
       // TODO: Bug 1708310: Make sure fit-content() work properly in table.
       // for 'max-inline-size', '-moz-fit-content' is like 'max-content'
-      maxISize = AnchorResolvedMaxSize::MaxContent();
+      maxISize = AnchorResolvedMaxSizeHelper::MaxContent();
     }
   }
   // XXX To really implement 'max-inline-size' well, we'd need to store
@@ -212,11 +212,11 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
   auto minISize = stylePos->MinISize(aWM, positionProperty);
   if (nsIFrame::ToExtremumLength(*maxISize)) {
     if (!aIsCell || minISize->BehavesLikeStretchOnInlineAxis()) {
-      minISize = AnchorResolvedSize::Zero();
+      minISize = AnchorResolvedSizeHelper::Zero();
     } else if (minISize->IsFitContent() || minISize->IsFitContentFunction()) {
       // TODO: Bug 1708310: Make sure fit-content() work properly in table.
       // for 'min-inline-size', '-moz-fit-content' is like 'min-content'
-      minISize = AnchorResolvedSize::MinContent();
+      minISize = AnchorResolvedSizeHelper::MinContent();
     }
   }