Experiment: say the room from the cursor as an inset, and read the row's length only where a slot depends on it

Measured identical to its parent at every phase of the cost rig; kept as
evidence, not proposed for landing.

core/src/ui/holds.rs

@@ -73,6 +73,21 @@ impl Holds {
         }
     }
 
+    /// What a box has to be for a part of it, this many pixels shorter, to
+    /// stay in this range: the range moved by that much, an end that was
+    /// unbounded staying so.
+    pub const fn longer_by(self, px: Px) -> Self {
+        let lo = match self.lo.raw() == Px::MIN.raw() {
+            true => self.lo,
+            false => self.lo.add(px),
+        };
+        let hi = match self.hi.raw() == Px::MAX.raw() {
+            true => self.hi,
+            false => self.hi.add(px),
+        };
+        Self { lo, hi }
+    }
+
     const fn raws(lo: i64, hi: i64) -> Self {
         Self {
             lo: Px::from_raw(narrow(lo)),

core/src/ui/painter.rs

@@ -259,17 +259,24 @@ impl<'a> Painter<'a> {
         declared_lens(self.rsc.widgets(), id.id())
     }
 
-    /// What a child says its length is without being drawn, if it can say.
+    /// What a child says its length is without being drawn, if it can say,
-    /// Asking counts as reading its size.
+    /// as the length its draw would report: a fraction in it is resolved
+    /// against this widget's frame, which is the frame a child asked with
+    /// nothing narrowed gets. Asking counts as reading its size.
     pub fn size_hint<W: ?Sized>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Option<LayoutLen> {
         let widgets = self.rsc.widgets();
         // A rule is the answer where there is one: it wins over whatever the
         // widget would draw, so it has to win over what the widget says too.
-        let hint = widgets.size_rules(id.id()).axis(axis).exact().or_else(|| {
+        let hint = widgets
-            widgets
+            .size_rules(id.id())
-                .get_dyn(id.id())
+            .axis(axis)
-                .and_then(|widget| widget.size_hint(axis))
+            .exact()
-        });
+            .or_else(|| {
+                widgets
+                    .get_dyn(id.id())
+                    .and_then(|widget| widget.size_hint(axis))
+            })
+            .map(|hint| hint.within_len(self.frame.axis(axis)));
         #[cfg(feature = "layout-diagnostics")]
         diag::hint_read(id.id(), self.id, axis, hint);
         match hint {
@@ -277,6 +284,11 @@ impl<'a> Painter<'a> {
                 #[cfg(feature = "layout-diagnostics")]
                 diag::bump(Counter::HintHits);
                 self.depend_on(id);
+                // A fraction was just resolved against this frame, so what
+                // this draw does with it is a function of the frame's length.
+                if hint.rel != Rel::ZERO {
+                    self.frame_own_len[axis as usize] = Some(self.frame.axis(axis));
+                }
                 Some(hint)
             }
             None => {
@@ -581,20 +593,29 @@ impl Painter<'_> {
                     result.extent[n] = holds.extent[n];
                     result.extent_len[n] = holds.extent_len[n];
                 }
-                // Its box is a part of this widget's own box, in that box's
+                // Its box is this widget's own less the inset. Where that is
-                // own lengths, so what it holds for maps back through that
+                // pixels, its box is exactly that many shorter in any window,
-                // part into a range on this widget's box. A length it pinned
+                // so what it holds for is a range on this widget's box moved
-                // is this widget's length less the part's pixels where the
+                // by them, and a length it pinned is this widget's length
-                // part is the whole of the box less pixels, which is the one
+                // less them. An inset with a fraction in it is a different
-                // shape that inverts exactly; any other part pins this
+                // number of pixels in each window, and taking it off a length
-                // widget's own length.
+                // rounds once more than taking it off pixels does: there the
-                (Part::Of(span), false) => {
+                // child's box is a fixed expression of this one, so this
-                    let part_len = span.len();
+                // widget's length is pinned and the range goes on the window
-                    result.extent[n] = holds.extent[n].through(part_len);
+                // through the child's box, the way a slot's does.
-                    result.extent_len[n] = holds.extent_len[n].map(|pinned| match part_len.rel {
+                (Part::Inset { lead, trail }, false) => {
-                        Rel::ONE => pinned - Len::from_parts(Rel::ZERO, part_len.px),
+                    let inset = lead + trail;
-                        _ => self.extent.axis(axis).len(),
+                    match inset.rel == Rel::ZERO {
-                    });
+                        true => {
+                            result.extent[n] = holds.extent[n].longer_by(inset.px);
+                            result.extent_len[n] = holds.extent_len[n].map(|pinned| pinned + inset);
+                        }
+                        false => {
+                            result.window[n] = result.window[n]
+                                .and(holds.extent[n].through(extent.axis(axis).len()));
+                            result.extent_len[n] = Some(self.extent.axis(axis).len());
+                        }
+                    }
                 }
                 // Its box is a length this widget decided, from its own
                 // frame or from a sibling's answer: no length of this

core/src/ui/place.rs

@@ -12,12 +12,13 @@ pub enum Part {
     /// here is a fraction of the window and not of the box -- the whole of a
     /// box is [`Self::All`], not a `rel(1.0)` span.
     From(UiSpan),
-    /// A part of the box in its own coordinates, which is what a container
+    /// The box less a window length at each end, which is what a container
-    /// that insets one speaks: taking eleven pixels off the end needs no
+    /// that insets one speaks -- padding, or a row asking a child in the
-    /// length, where saying the same thing in window lengths would make the
+    /// room left from its cursor. Neither end names the box's length, so a
-    /// container read its own box -- and a box chosen from its own answer
+    /// container can say "from here to my end" without reading how long it
-    /// then feeds back into the answer.
+    /// is, and a box chosen from its own answer does not feed back into the
-    Of(UiSpan),
+    /// answer.
+    Inset { lead: Len, trail: Len },
     /// A box of this length, wherever in the parent's box the child's own
     /// alignment puts it, and that same length as its frame. Unlike `From`,
     /// it is a length decided from above rather than a place along a
@@ -32,7 +33,7 @@ impl Part {
         match self {
             Self::All => extent,
             Self::From(span) => UiSpan::new(extent.start + span.start, extent.start + span.end),
-            Self::Of(span) => span.within(&extent),
+            Self::Inset { lead, trail } => UiSpan::new(extent.start + lead, extent.end - trail),
             Self::Sized(len) => {
                 let start = extent.start + (extent.len() - len).scale(align.rel());
                 UiSpan::new(start, start + len)

src/random.rs

@@ -142,6 +142,10 @@ impl Widget for Branch {
         };
         Size::LEFTOVER
     }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
 }
 
 pub struct Spanned {

src/widget/mask.rs

@@ -15,4 +15,8 @@ impl Widget for Masked {
         // draw, and the framework would place the drawing it clipped away.
         Size::LEFTOVER
     }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
 }

src/widget/position/pad.rs

@@ -20,10 +20,10 @@ impl Widget for Pad {
         // The two stay distinct -- the box can be narrower still, where a row
         // asked this widget in the room left, and a text wraps at that.
         let inset = |lead: Px, trail: Px| {
-            Place::Within(Part::Of(UiSpan::new(
+            Place::Within(Part::Inset {
-                Len::from_parts(Rel::ZERO, lead),
+                lead: Len::from_parts(Rel::ZERO, lead),
-                Len::from_parts(Rel::ONE, -trail),
+                trail: Len::from_parts(Rel::ZERO, trail),
-            )))
+            })
         };
         let place = [
             inset(self.padding.left, self.padding.right),

src/widget/position/scroll.rs

@@ -72,6 +72,10 @@ impl Widget for Scroll {
         // is.
         Size::LEFTOVER
     }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
 }
 
 impl Scroll {

src/widget/position/span.rs

@@ -10,38 +10,55 @@ pub struct Span {
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let axis = self.dir.axis;
-        // The row: this span's own box, as a length of the frame its children
+        // The room left from the cursor to the row's end, said without the
-        // are laid out against. Its start is nothing's business -- a slot is
+        // row's length: a child measured in it does not make this drawing
-        // a length from it -- so what this reads is the length alone.
+        // depend on how long the row is.
-        let far = painter.extent_len(axis);
+        let room_from = |cursor: Len| match self.dir.sign {
-        let along = |from: Len, to: Len| match self.dir.sign {
+            Sign::Pos => Part::Inset {
-            Sign::Pos => UiSpan::new(from, to),
+                lead: cursor,
-            Sign::Neg => UiSpan::new(far - to, far - from),
+                trail: Len::ZERO,
+            },
+            Sign::Neg => Part::Inset {
+                lead: Len::ZERO,
+                trail: cursor,
+            },
         };
         // Across itself the child sits where its own alignment says, in the
         // whole of the row: a span is what contains its children there, and
         // nothing divides that axis.
         let across = Place::Within(Part::All);
-        // A length for every child before their final slots are chosen. The
+        // A length for every child before their final slots are chosen: from
-        // frame passes through unchanged, so `rel(0.5)` is half the area this
+        // a hint where one says, and from drawing otherwise. The frame passes
-        // span was given whatever else is in it and wherever this child sits
+        // through unchanged, so `rel(0.5)` is half the area this span was
-        // among them; what it is asked in is the room left from the cursor,
+        // given whatever else is in it and wherever this child sits among
-        // because a text has to wrap at the width actually there. This is
+        // them; what a drawn child is asked in is the room left from the
-        // the one ask a fixed child gets: its slot is its answer, and the
+        // cursor, because a text has to wrap at the width actually there.
-        // drawing is moved there once the shares are known.
+        // This is the one ask a drawn fixed child gets: its slot is its
+        // answer, and the drawing is moved there once the shares are known.
+        // A hinted child is asked once, in its slot.
         let mut cursor = Len::rel_min();
-        let mut sizes = Vec::with_capacity(self.children.len());
+        let mut lens = Vec::with_capacity(self.children.len());
+        let mut measured = Vec::with_capacity(self.children.len());
         for child in &self.children {
-            let room = Place::Within(Part::From(along(cursor, far)));
+            let size = match painter.size_hint(child, axis) {
-            let size = painter
+                Some(len) => {
-                .widget_at(child, [None; 2], axis.pair(room, across))
+                    measured.push(None);
-                .size();
+                    len
-            let len = size.axis(axis);
+                }
+                None => {
+                    let room = Place::Within(room_from(cursor));
+                    let size = painter
+                        .widget_at(child, [None; 2], axis.pair(room, across))
+                        .size();
+                    measured.push(Some(size));
+                    size.axis(axis)
+                }
+            };
+            let len = size;
             cursor.px += len.px + self.gap;
             cursor.rel += len.rel;
-            sizes.push(size);
+            lens.push(len);
         }
-        let lens: Vec<LayoutLen> = sizes.iter().map(|size| size.axis(axis)).collect();
 
         let gaps = self
             .gap
@@ -54,9 +71,25 @@ impl Widget for Span {
             |sum, len| sum + *len,
         );
 
+        // The row: this span's own box as a length of the window, read only
+        // where a slot depends on it -- shares divide what is left of it,
+        // and a negative row counts from its end. Reading it pins the
+        // drawing to this length; a positive row of fixed children is not
+        // pinned and holds for any length its children do. Its start is
+        // nothing's business: a slot is a length from it.
+        let far = (total.leftover > Weight::ZERO || self.dir.sign == Sign::Neg)
+            .then(|| painter.extent_len(axis));
+        let along = |from: Len, to: Len| match self.dir.sign {
+            Sign::Pos => UiSpan::new(from, to),
+            Sign::Neg => {
+                let far = far.expect("a negative row reads its length");
+                UiSpan::new(far - to, far - from)
+            }
+        };
         // What is left for the shares to divide: the row less everything
         // fixed, as a length of the frame rather than a number of pixels.
-        let room = far - Len::from_parts(total.rel, total.px);
+        // Nothing where there are no shares, and nothing reads it there.
+        let room = far.map_or(Len::ZERO, |far| far - Len::from_parts(total.rel, total.px));
         // Whether anything is left over is a question in pixels: `rel(0.5)`
         // beside 300 px is full at 600 and overfull at 400. Asked of `room`
         // itself, and answered back through the same expression, so the
@@ -92,8 +125,8 @@ impl Widget for Span {
         let mut taken = Weight::ZERO;
         let mut start = Len::rel_min();
         let mut ortho = LayoutLen::ZERO;
-        for (child, size) in self.children.iter().zip(&sizes) {
+        for ((child, len), measured) in self.children.iter().zip(&lens).zip(&measured) {
-            let len = size.axis(axis);
+            let len = *len;
             // A child asking for nothing but a part of what is left over,
             // when nothing is, is not drawn at all. One that also asked for
             // pixels or a fraction keeps those and overflows.
@@ -115,20 +148,20 @@ impl Widget for Span {
             // answer inside again. A share is decided here and nowhere
             // else: its slot narrows its frame, and the child is asked in
             // it, since a text wraps at the width it is actually given. A
-            // fixed child's slot is its own answer, so its drawing is put
+            // fixed child's slot is its own answer, so a drawing made in the
-            // there as it is.
+            // room is put there as it is, and one not made yet is made here.
             let slot = along(from, start);
             let place = axis.pair(Place::Fill(Part::From(slot)), across);
-            let used = match len.leftover > Weight::ZERO && shares {
+            let mut narrow = [None; 2];
-                true => {
+            if len.leftover > Weight::ZERO && shares {
-                    let mut narrow = [None; 2];
+                narrow[axis as usize] = Some(slot.len());
-                    narrow[axis as usize] = Some(slot.len());
+            }
-                    painter.widget_at(child, narrow, place).len(!axis)
+            let used = match (measured, narrow[axis as usize]) {
-                }
+                (Some(size), None) => {
-                false => {
                     painter.place_at(child, place);
                     size.axis(!axis)
                 }
+                _ => painter.widget_at(child, narrow, place).len(!axis),
             };
             if shrinks {
                 // Choosing between a fixed and a relative length from the

src/widget/position/stack.rs

@@ -49,6 +49,15 @@ impl Widget for Stack {
         }
         size
     }
+
+    /// Without a sizing child a stack is whatever box it is given, which it
+    /// can say without drawing anything.
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        match self.size {
+            StackSize::Default => Some(LayoutLen::LEFTOVER),
+            StackSize::Child(_) => None,
+        }
+    }
 }
 
 #[derive(Default, Debug)]

tests/layout_dump.rs

@@ -0,0 +1,42 @@
+//! Prints where a cold layout puts every widget of many grown trees, so two
+//! commits can be compared on cold layout alone. The warm/cold oracle cannot
+//! see a change that moves cold layout, since both of its sides move; this
+//! can, by diffing its output across the change:
+//!
+//!     IRIS_DUMP_SEEDS=400 IRIS_DUMP_DEPTH=5 cargo test --release \
+//!       --test layout_dump -- --ignored --nocapture > /tmp/before.txt
+//!
+//! then the same after, and `diff` the two. A line is one widget: the seed,
+//! its index in creation order, and its box in window pixels, or `-` where
+//! it is not drawn.
+
+use iris::harness::Harness;
+use iris::random::{Edits, grow};
+
+fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
+    std::env::var(name)
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(fallback)
+}
+
+#[test]
+#[ignore = "a dump to diff across commits, not a check"]
+fn every_cold_layout_is_printed() {
+    let seeds = env("IRIS_DUMP_SEEDS", 400_u64);
+    let depth = env("IRIS_DUMP_DEPTH", 5_usize);
+    let mut out = String::new();
+    for seed in 1..=seeds {
+        let mut harness = Harness::new((1920.0, 1200.0));
+        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+        harness.state.root = Some(root);
+        harness.frame();
+        for (index, id) in tree.ids.iter().enumerate() {
+            match harness.region(id) {
+                Some(region) => out.push_str(&format!("{seed} {index} {region:?}\n")),
+                None => out.push_str(&format!("{seed} {index} -\n")),
+            }
+        }
+    }
+    print!("{out}");
+}