review rendering code (stack.cs)

com.unity.uiwidgets/Runtime/rendering/stack.cs

 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
 using UnityEngine;
+using Debug = System.Diagnostics.Debug;
 using Rect = Unity.UIWidgets.ui.Rect;
 
 namespace Unity.UIWidgets.rendering {
         public static bool operator !=(RelativeRect a, RelativeRect b) {
             return !(a == b);
         }
+        
+        public override string ToString() {
+            return
+                $"RelativeRect.fromLTRB({left:F1}, {top :F1}, {right :F1}, {bottom :F1})";
+        }
     }
 
     public class StackParentData : ContainerParentDataMixinBoxParentData<RenderBox> {
                 left = value.left;
             }
         }
+        public override string ToString() {
+            List<string> values = new List<string>();
+                if (top != null) values.Add($"top={top:F1}");
+            if (right != null) values.Add($"right={right:F1}");
+            if (bottom != null) values.Add($"bottom=${bottom:F1}");
+            if (left != null) values.Add($"left=${left:F1}");
+            if (width != null) values.Add($"width=${width:F1}");
+            if (height != null) values.Add($"height=${height:F1}");
+            if (values.isEmpty())
+                values.Add("not positioned");
+            values.Add(base.ToString());
+            return string.Join("; ", values);
+        }
     }
 
     public enum StackFit {
         public RenderStack(
             List<RenderBox> children = null,
             AlignmentGeometry alignment =  null,
-            TextDirection? textDirection = null,
+            TextDirection textDirection = TextDirection.ltr,
             StackFit fit = StackFit.loose,
             Overflow overflow = Overflow.clip
             ) {
         public AlignmentGeometry alignment {
             get { return _alignment; }
             set {
+                D.assert(value != null);
                 if (_alignment == value) {
                     return;
                 }
             RenderBox child = firstChild;
             while (child != null) {
                 StackParentData childParentData = child.parentData as StackParentData;
+                D.assert(childParentData != null);
                 if (!childParentData.isPositioned)
                     extent = Math.Max(extent, getter(child));
                 D.assert(child.parentData == childParentData);
 
         public delegate float mainChildSizeGetter(RenderBox child);
 
-        float _getIntrinsicDimension(mainChildSizeGetter getter) {
-            float extent = 0.0f;
-            RenderBox child = firstChild;
-            while (child != null) {
-                StackParentData childParentData = (StackParentData) child.parentData;
-                if (!childParentData.isPositioned) {
-                    extent = Mathf.Max(extent, getter(child));
-                }
-
-                D.assert(child.parentData == childParentData);
-                if (childParentData != null) {
-                    child = childParentData.nextSibling;
-                }
-            }
-
-            return extent;
-        }
-
-            return _getIntrinsicDimension((RenderBox child) => child.getMinIntrinsicWidth(height));
+            return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMinIntrinsicWidth(height));
-            return _getIntrinsicDimension((RenderBox child) => child.getMaxIntrinsicWidth(height));
+            return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMaxIntrinsicWidth(height));
-            return _getIntrinsicDimension((RenderBox child) => child.getMinIntrinsicHeight(width));
+            return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMinIntrinsicHeight(width));
-            return _getIntrinsicDimension((RenderBox child) => child.getMaxIntrinsicHeight(width));
+            return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMaxIntrinsicHeight(width));
         }
 
         protected override float? computeDistanceToActualBaseline(TextBaseline baseline) {
             float height = constraints.minHeight;
 
             BoxConstraints nonPositionedConstraints = null;
-            D.assert(fit != null);
             switch (fit) {
               case StackFit.loose:
                 nonPositionedConstraints = constraints.loosen();
             RenderBox child = firstChild;
             while (child != null) {
               StackParentData childParentData = child.parentData as StackParentData;
-
+              D.assert(childParentData != null);
               if (!childParentData.isPositioned) {
                 hasNonPositionedChildren = true;
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<AlignmentGeometry>("alignment", alignment));
+            properties.add(new EnumProperty<TextDirection>("textDirection", textDirection?? TextDirection.ltr));
             properties.add(new EnumProperty<StackFit>("fit", fit));
             properties.add(new EnumProperty<Overflow>("overflow", overflow));
         }
         ) :  base(
             children: children,
             alignment: alignment ?? AlignmentDirectional.topStart,
-            textDirection: textDirection) {
+            textDirection: textDirection?? TextDirection.ltr) {
             _index = index;
         }
 
         int _index;
 
         RenderBox _childAtIndex() {
-            D.assert(index != null);
             RenderBox child = firstChild;
             int i = 0;
             while (child != null && i < index) {
             return child;
         }
 
-        protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
-            if (firstChild == null || index == null) {
+        protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
+            if (firstChild == null) {
                 return false;
             }
 
         }
 
         public override void paintStack(PaintingContext context, Offset offset) {
-            if (firstChild == null || index == null) {
+            if (firstChild == null) {
                 return;
             }