Fix compute intrinsic size for wrap (#55469)

AUTHORS

@@ -54,3 +54,4 @@ Cédric Wyss <cedi.wyss@gmail.com>
 Michel Feinstein <michel@feinstein.com.br>
 Michael Lee <ckmichael8@gmail.com>
 Katarina Sheremet <katarina@sheremet.ch>
+Mikhail Zotyev <mbixjkee1392@gmail.com>

packages/flutter/lib/src/rendering/wrap.dart

@@ -383,7 +383,6 @@ class RenderWrap extends RenderBox with ContainerRenderObjectMixin<RenderBox, Wr
 
   double _computeIntrinsicHeightForWidth(double width) {
     assert(direction == Axis.horizontal);
-    int runCount = 0;
     double height = 0.0;
     double runWidth = 0.0;
     double runHeight = 0.0;
@@ -392,11 +391,9 @@ class RenderWrap extends RenderBox with ContainerRenderObjectMixin<RenderBox, Wr
     while (child != null) {
       final double childWidth = child.getMaxIntrinsicWidth(double.infinity);
       final double childHeight = child.getMaxIntrinsicHeight(childWidth);
-      if (runWidth + childWidth > width) {
+      // There must be at least one child before we move on to the next run.
-        height += runHeight;
+      if (childCount > 0 && runWidth + childWidth + spacing > width) {
-        if (runCount > 0)
+        height += runHeight + runSpacing;
-          height += runSpacing;
-        runCount += 1;
         runWidth = 0.0;
         runHeight = 0.0;
         childCount = 0;
@@ -408,14 +405,12 @@ class RenderWrap extends RenderBox with ContainerRenderObjectMixin<RenderBox, Wr
       childCount += 1;
       child = childAfter(child);
     }
-    if (childCount > 0)
+    height += runHeight;
-      height += runHeight + runSpacing;
     return height;
   }
 
   double _computeIntrinsicWidthForHeight(double height) {
     assert(direction == Axis.vertical);
-    int runCount = 0;
     double width = 0.0;
     double runHeight = 0.0;
     double runWidth = 0.0;
@@ -424,11 +419,9 @@ class RenderWrap extends RenderBox with ContainerRenderObjectMixin<RenderBox, Wr
     while (child != null) {
       final double childHeight = child.getMaxIntrinsicHeight(double.infinity);
       final double childWidth = child.getMaxIntrinsicWidth(childHeight);
-      if (runHeight + childHeight > height) {
+      // There must be at least one child before we move on to the next run.
-        width += runWidth;
+      if (childCount > 0 && runHeight + childHeight + spacing > height) {
-        if (runCount > 0)
+        width += runWidth + runSpacing;
-          width += runSpacing;
-        runCount += 1;
         runHeight = 0.0;
         runWidth = 0.0;
         childCount = 0;
@@ -440,8 +433,7 @@ class RenderWrap extends RenderBox with ContainerRenderObjectMixin<RenderBox, Wr
       childCount += 1;
       child = childAfter(child);
     }
-    if (childCount > 0)
+    width += runWidth;
-      width += runWidth + runSpacing;
     return width;
   }
 

packages/flutter/test/rendering/wrap_test.dart

@@ -25,4 +25,130 @@ void main() {
       ),
     );
   });
+
+  test('Compute intrinsic height test', () {
+    final List<RenderBox> children = <RenderBox>[
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+    ];
+
+    final RenderWrap renderWrap = RenderWrap();
+
+    children.forEach(renderWrap.add);
+
+    renderWrap.spacing = 5;
+    renderWrap.runSpacing = 5;
+    renderWrap.direction = Axis.horizontal;
+
+    expect(renderWrap.computeMaxIntrinsicHeight(245), 165);
+    expect(renderWrap.computeMaxIntrinsicHeight(250), 80);
+    expect(renderWrap.computeMaxIntrinsicHeight(80), 250);
+    expect(renderWrap.computeMaxIntrinsicHeight(79), 250);
+    expect(renderWrap.computeMinIntrinsicHeight(245), 165);
+    expect(renderWrap.computeMinIntrinsicHeight(250), 80);
+    expect(renderWrap.computeMinIntrinsicHeight(80), 250);
+    expect(renderWrap.computeMinIntrinsicHeight(79), 250);
+  });
+
+  test('Compute intrinsic width test', () {
+    final List<RenderBox> children = <RenderBox>[
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+      RenderConstrainedBox(
+        additionalConstraints: const BoxConstraints(
+          minWidth: 80,
+          minHeight: 80,
+        ),
+      ),
+    ];
+
+    final RenderWrap renderWrap = RenderWrap();
+
+    children.forEach(renderWrap.add);
+
+    renderWrap.spacing = 5;
+    renderWrap.runSpacing = 5;
+    renderWrap.direction = Axis.vertical;
+
+    expect(renderWrap.computeMaxIntrinsicWidth(245), 165);
+    expect(renderWrap.computeMaxIntrinsicWidth(250), 80);
+    expect(renderWrap.computeMaxIntrinsicWidth(80), 250);
+    expect(renderWrap.computeMaxIntrinsicWidth(79), 250);
+    expect(renderWrap.computeMinIntrinsicWidth(245), 165);
+    expect(renderWrap.computeMinIntrinsicWidth(250), 80);
+    expect(renderWrap.computeMinIntrinsicWidth(80), 250);
+    expect(renderWrap.computeMinIntrinsicWidth(79), 250);
+  });
+
+  test('Compute intrinsic height for only one run', () {
+    final RenderBox child = RenderConstrainedBox(
+      additionalConstraints: const BoxConstraints(
+        minWidth: 80,
+        minHeight: 80,
+      ),
+    );
+
+    final RenderWrap renderWrap = RenderWrap();
+    renderWrap.add(child);
+
+    renderWrap.spacing = 5;
+    renderWrap.runSpacing = 5;
+    renderWrap.direction = Axis.horizontal;
+
+    expect(renderWrap.computeMaxIntrinsicHeight(100), 80);
+    expect(renderWrap.computeMaxIntrinsicHeight(79), 80);
+    expect(renderWrap.computeMaxIntrinsicHeight(80), 80);
+    expect(renderWrap.computeMinIntrinsicHeight(100), 80);
+    expect(renderWrap.computeMinIntrinsicHeight(79), 80);
+    expect(renderWrap.computeMinIntrinsicHeight(80), 80);
+  });
+
+  test('Compute intrinsic width for only one run', () {
+    final RenderBox child = RenderConstrainedBox(
+      additionalConstraints: const BoxConstraints(
+        minWidth: 80,
+        minHeight: 80,
+      ),
+    );
+
+    final RenderWrap renderWrap = RenderWrap();
+    renderWrap.add(child);
+
+    renderWrap.spacing = 5;
+    renderWrap.runSpacing = 5;
+    renderWrap.direction = Axis.vertical;
+
+    expect(renderWrap.computeMaxIntrinsicWidth(100), 80);
+    expect(renderWrap.computeMaxIntrinsicWidth(79), 80);
+    expect(renderWrap.computeMaxIntrinsicWidth(80), 80);
+    expect(renderWrap.computeMinIntrinsicWidth(100), 80);
+    expect(renderWrap.computeMinIntrinsicWidth(79), 80);
+    expect(renderWrap.computeMinIntrinsicWidth(80), 80);
+  });
 }