Stop configuring the max width and height in YogaUIView (#2757)

* Stop configuring the max width and height in YogaUIView

These attributes only cause us pain.

In particular they aren't necessary to pass any of
our layout tests, and by removing them I can fix a
layout bug.

Note that on Android we do not use these attributes,
so this brings the two platforms closer together.

Closes: #2753

* Start using systemLayoutSizeFittingSize

This way we can tell the view whether a measurement is
exactly (which it should honor unconditionally), or not
(which it might honor if its constraint is Fill).

* DS_Store

Author: squarejesse

CHANGELOG.md

@@ -14,6 +14,7 @@ Fixed:
 - Don't measure the height of `RedwoodUIView` as zero when measured with `sizeThatFits()` or `intrinsicContentSize()`. We had been using `UIStackView` which doesn't support these functions.
 - Correctly signal `RedwoodUIView` size changes of to callers who measure it with `intrinsicContentSize()`.
 - The Redwood Gradle plugin is now compatible with Gradle 9.1.
+- Don't incorrectly size items to 0 when using the `Flex()` modifier on a `Wrap` container.
 
 
 ## [0.18.0] - 2025-08-01

redwood-layout-composeui/src/test/snapshots/images/app.cash.redwood.layout.composeui_ComposeUiFlexContainerTest_RTL_testFlexOnChildOfWrappingColumn.png

@@ -1089,6 +1089,43 @@ abstract class AbstractFlexContainerTest<T : Any> {
 
     snapshotter(row.value).snapshot()
   }
+
+  /**
+   * We had a bug where putting `flex(1.0)` on a child of a column with `height(Constraint.Wrap)`
+   * would cause that child to get a height of 0.
+   *
+   * https://github.com/cashapp/redwood/issues/2753
+   */
+  @Test
+  fun testFlexOnChildOfWrappingColumn() {
+    val root = row().apply {
+      width(Constraint.Fill)
+      height(Constraint.Fill)
+    }
+
+    val fixedSize = row().apply {
+      width(Constraint.Fill)
+      height(Constraint.Fill)
+      modifier = SizeImpl(width = 300.dp, height = 500.dp)
+    }.also {
+      root.children.insert(0, it)
+    }
+
+    val column = column().apply {
+      width(Constraint.Fill)
+    }.also {
+      fixedSize.children.insert(0, it)
+    }
+
+    widgetFactory.text("hello").apply {
+      modifier = FlexImpl(1.0)
+      bgColor(Blue)
+    }.also {
+      column.children.insert(0, it)
+    }
+
+    snapshotter(root.value).snapshot()
+  }
 }
 
 interface TestFlexContainer<T : Any> :

redwood-layout-composeui/src/test/snapshots/images/app.cash.redwood.layout.composeui_ComposeUiFlexContainerTest_testFlexOnChildOfWrappingColumn.png

@@ -23,6 +23,8 @@ import kotlinx.cinterop.CValue
 import kotlinx.cinterop.useContents
 import platform.CoreGraphics.CGSize
 import platform.CoreGraphics.CGSizeMake
+import platform.UIKit.UILayoutPriorityDefaultLow
+import platform.UIKit.UILayoutPriorityRequired
 import platform.UIKit.UIView
 import platform.UIKit.UIViewNoIntrinsicMetric
 
@@ -44,15 +46,18 @@ internal object UIViewMeasureCallback : MeasureCallback {
       else -> height.toDouble()
     }
 
-    // The default implementation of sizeThatFits: returns the existing size of
-    // the view. That means that if we want to layout an empty UIView, which
-    // already has a frame set, its measured size should be CGSizeZero, but
-    // UIKit returns the existing size. See https://github.com/facebook/yoga/issues/606
-    // for more information.
+    // The default implementation of sizeThatFits: returns the existing size of the view. That means
+    // that if we want to layout an empty UIView, which already has a frame set, its measured size
+    // should be CGSizeZero, but UIKit returns the existing size. For more information, see
+    // https://github.com/facebook/yoga/issues/606
     val sizeThatFits = if (view.isMemberOfClass(UIView.`class`()) && view.typedSubviews.isEmpty()) {
       Size(0f, 0f)
     } else {
-      view.sizeThatFits(CGSizeMake(constrainedWidth, constrainedHeight)).toSize()
+      view.systemLayoutSizeFittingSize(
+        targetSize = CGSizeMake(constrainedWidth, constrainedHeight),
+        withHorizontalFittingPriority = widthMode.toFittingPriority(),
+        verticalFittingPriority = heightMode.toFittingPriority(),
+      ).toSize()
     }
 
     return Size(
@@ -65,3 +70,8 @@ internal object UIViewMeasureCallback : MeasureCallback {
 private fun CValue<CGSize>.toSize() = useContents {
   Size(width.toFloat(), height.toFloat())
 }
+
+private fun MeasureMode.toFittingPriority() = when (this) {
+  MeasureMode.Exactly -> UILayoutPriorityRequired
+  else -> UILayoutPriorityDefaultLow
+}

redwood-layout-shared-test/src/commonMain/kotlin/app/cash/redwood/layout/AbstractFlexContainerTest.kt

@@ -21,6 +21,8 @@ import platform.CoreGraphics.CGRectMake
 import platform.CoreGraphics.CGRectZero
 import platform.CoreGraphics.CGSize
 import platform.CoreGraphics.CGSizeMake
+import platform.UIKit.UILayoutPriority
+import platform.UIKit.UILayoutPriorityRequired
 import platform.UIKit.UIScrollView
 import platform.UIKit.UIScrollViewContentInsetAdjustmentBehavior.UIScrollViewContentInsetAdjustmentNever
 import platform.UIKit.UIScrollViewDelegateProtocol
@@ -94,19 +96,36 @@ internal class YogaUIView : UIScrollView(cValue { CGRectZero }), UIScrollViewDel
   override fun intrinsicContentSize(): CValue<CGSize> {
     return calculateLayout(
       width = fillWidth.toYogaWithWidthConstraint(),
-      maxWidth = fillWidth.toYoga(),
       height = fillHeight.toYogaWithWidthConstraint(),
-      maxHeight = fillHeight.toYoga(),
     )
   }
 
   override fun sizeThatFits(size: CValue<CGSize>): CValue<CGSize> {
     return size.useContents<CGSize, CValue<CGSize>> {
       calculateLayout(
         width = width.toYogaWithWidthConstraint(),
-        maxWidth = width.toYoga(),
         height = height.toYogaWithHeightConstraint(),
-        maxHeight = height.toYoga(),
+      )
+    }
+  }
+
+  override fun systemLayoutSizeFittingSize(
+    targetSize: CValue<CGSize>,
+    withHorizontalFittingPriority: UILayoutPriority,
+    verticalFittingPriority: UILayoutPriority,
+  ): CValue<CGSize> {
+    return targetSize.useContents<CGSize, CValue<CGSize>> {
+      calculateLayout(
+        width = when {
+          withHorizontalFittingPriority == UILayoutPriorityRequired -> width.toYoga()
+          widthConstraint == Constraint.Fill -> width.toYoga()
+          else -> Size.UNDEFINED
+        },
+        height = when {
+          verticalFittingPriority == UILayoutPriorityRequired -> height.toYoga()
+          heightConstraint == Constraint.Fill -> height.toYoga()
+          else -> Size.UNDEFINED
+        },
       )
     }
   }
@@ -160,14 +179,12 @@ internal class YogaUIView : UIScrollView(cValue { CGRectZero }), UIScrollViewDel
 
   private fun calculateLayout(
     width: Float = Size.UNDEFINED,
-    maxWidth: Float = Size.UNDEFINED,
     height: Float = Size.UNDEFINED,
-    maxHeight: Float = Size.UNDEFINED,
   ): CValue<CGSize> {
     rootNode.requestedWidth = width
-    rootNode.requestedMaxWidth = maxWidth
+    rootNode.requestedMaxWidth = Size.UNDEFINED
     rootNode.requestedHeight = height
-    rootNode.requestedMaxHeight = maxHeight
+    rootNode.requestedMaxHeight = Size.UNDEFINED
 
     rootNode.measureOnly(Size.UNDEFINED, Size.UNDEFINED)