Say the environment once, and stop a hint read going uncounted

The eleventh sweep, over the built-in bounds work in 2ac0843.

`Painter::size_hint` refused to answer for a bounded widget by returning
above the diagnostics, so that read was neither a hint hit nor a miss and
`hint_read` recorded nothing. It is a miss now, with the reason on it.

The two `for axis in Axis::BOTH` loops that `draw_widget` grew, both
writing `own_holds`, are one loop, and the comment about combining the
ask's holds no longer sits between a comment and the code it describes.

`Declared::from_axes` lost its only caller with `Widgets::declared_lens`;
`Bounds::from_axes` and `SizeRule::declared` never had one.

The scenario shrinker printed a rule with derived `Debug`, which is 130
characters an axis in a line that carries every ancestor, in the one
function whose job is output a tree can be rebuilt from. It prints its
parts again.

`bounds_cost` invented three environment-reading spellings where four
copies of one `env` helper already existed; there is now one, in
`tests/rig`, and the four copies are gone. It also verified 128 regions
inside its measured loop, which the other rigs deliberately do before
theirs; that measured 0.65% of the total, and none of it is layout.

The 250-window row with a 300 cap was built by two tests, and the one
that still explained itself tested less; they are one. The half of
`a_cap_attribute_narrows_the_widgets_box` that the wrapper's removal left
without its deciding assertion is the allocator's path instead, which
nothing at the root covered.

Format, workspace clippy under -D warnings with and without
layout-diagnostics, 206 ordinary and 210 diagnostic tests, 400 depth-5
trees warm against cold in 64.19s, and the cold dump byte-identical to
2ac0843 across all 34,986 boxes.

core/src/ui/painter.rs

@@ -439,10 +439,14 @@ impl<'a> Painter<'a> {
     /// against this widget's rel base, which is the rel base 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> {
-        if self.rsc.widgets().size_rules(id.id())[axis].bound != Bound::ANY {
-            return None;
-        }
-        let hint = self.rsc.widgets().exact_len(id.id(), axis);
+        // A bound is composed into a request rather than applied to a hint,
+        // so a bounded widget cannot say its length without being asked: what
+        // it comes to is a comparison only the ask or the allocator makes.
+        // A miss rather than no read at all, so the counters see it.
+        let bounded = self.rsc.widgets().size_rules(id.id())[axis].bound != Bound::ANY;
+        let hint = (!bounded)
+            .then(|| self.rsc.widgets().exact_len(id.id(), axis))
+            .flatten();
         let rel_base = self.rel_base[axis];
         let resolved = hint.map(|hint| hint.within_len(rel_base));
         #[cfg(feature = "layout-diagnostics")]

core/src/ui/render_state.rs

@@ -452,23 +452,34 @@ impl UiRenderState {
             x: ruled(Axis::X, size.x),
             y: ruled(Axis::Y, size.y),
         };
-        // A bound is a promise about the length as well as about the box: a
-        // widget that drew past the box it was given -- a text too tall for
-        // it, an image at its own size under a cap -- is still held to what
-        // its rule allows.
-        //
-        // Held here rather than taken from the box, even where the bound
-        // decided that box. What a widget answers is its own, and a bound
-        // that replaced the answer would make a share into a fixed length
-        // the moment a box was long enough -- which is a length the span
-        // dividing that box decided from this answer, so the two would
-        // choose each other. A share is left alone here for the same reason:
-        // it is a length only to whoever divides one, and the box that
-        // divider gives is a box this widget is asked in, where the bound is
-        // applied to it.
-        // Widgets may widen their own read ranges, but not the ask's constraints.
+        // What the drawing read is combined with what the ask decided rather
+        // than replacing it: a widget may widen its own ranges, and cannot
+        // widen the ask's.
         let mut own_holds = own.and(info.ask_holds);
         for axis in Axis::BOTH {
+            // A rule that is a fraction of the rel base is answered with the
+            // rel base's own length, so the answer is that rel base's and not
+            // just that many pixels of this window -- the same pin a widget
+            // that read its rel base took for its drawing. A bound counts:
+            // which side of it the box fell was decided against this rel
+            // base, and the same box of a different one can fall on the other.
+            if rules[axis].has_fraction() {
+                own_holds[axis].rel_base = Some(info.rel_base[axis]);
+            }
+            // A bound is a promise about the length as well as about the box:
+            // a widget that drew past the box it was given -- a text too tall
+            // for it, an image at its own size under a cap -- is still held to
+            // what its rule allows.
+            //
+            // Held here rather than taken from the box, even where the bound
+            // decided that box. What a widget answers is its own, and a bound
+            // that replaced the answer would make a share into a fixed length
+            // the moment a box was long enough -- which is a length the span
+            // dividing that box decided from this answer, so the two would
+            // choose each other. A share is left alone here for the same
+            // reason: it is a length only to whoever divides one, and the box
+            // that divider gives is a box this widget is asked in, where the
+            // bound is applied to it.
             let answer = size[axis];
             if answer.leftover != Weight::ZERO {
                 continue;
@@ -479,17 +490,6 @@ impl UiRenderState {
                 size[axis] = held.into();
             }
         }
-        // A rule that is a fraction of the rel base is answered with the
-        // rel base's own length, so the answer is that rel base's and not just
-        // that many pixels of this window -- the same pin a widget that read
-        // its rel base took for its drawing. A bound counts: which side of it
-        // the box fell was decided against this rel base, and the same box of
-        // a different one can fall on the other.
-        for axis in Axis::BOTH {
-            if rules[axis].has_fraction() {
-                own_holds[axis].rel_base = Some(info.rel_base[axis]);
-            }
-        }
         // A widget that clipped its contents to its box drew nothing outside
         // it, so reporting more than the box asks to be placed at a length it
         // does not occupy -- and its parent would place the part it cut off.

core/src/widget/request.rs

@@ -169,6 +169,7 @@ impl RequestArena {
         let b = self.import(&pair.1, base);
         self.combine(op, a, b)
     }
+
     pub(crate) fn bounded(&mut self, request: RequestedLen, bound: Bound) -> RequestedLen {
         let request = match bound.min {
             Some(min) => self.combine(Op::Max, request, min.into()),

core/src/widget/size_rule.rs

@@ -1,5 +1,5 @@
 use crate::util::impl_axis_index;
-use crate::{Axis, LayoutLen, Len, Rel, SizeRequest};
+use crate::{LayoutLen, Len, Rel, SizeRequest, Weight};
 
 /// A preferred length and independent bounds on one axis. Without a
 /// request, the widget's drawing supplies the preferred length.
@@ -45,10 +45,6 @@ impl SizeRule {
         rule
     }
 
-    pub fn declared(&self) -> Option<Len> {
-        self.exact().and_then(|len| len.declared())
-    }
-
     /// A linear preferred length, before applying the independent bounds.
     pub fn exact(&self) -> Option<LayoutLen> {
         match self.request {
@@ -63,7 +59,7 @@ impl SizeRule {
         let request = self.request.as_ref()?;
         match request {
             SizeRequest::Linear(len)
-                if len.leftover == crate::Weight::ZERO || self.bound == Bound::ANY =>
+                if len.leftover == Weight::ZERO || self.bound == Bound::ANY =>
             {
                 None
             }
@@ -121,13 +117,6 @@ impl Bounds {
         x: Bound::ANY,
         y: Bound::ANY,
     };
-
-    pub fn from_axes(f: impl Fn(Axis) -> Bound) -> Self {
-        Self {
-            x: f(Axis::X),
-            y: f(Axis::Y),
-        }
-    }
 }
 
 impl_axis_index!(Bounds => Bound);
@@ -175,13 +164,6 @@ pub struct Declared {
 
 impl Declared {
     pub const NONE: Self = Self { x: None, y: None };
-
-    pub fn from_axes(f: impl Fn(Axis) -> Option<Len>) -> Self {
-        Self {
-            x: f(Axis::X),
-            y: f(Axis::Y),
-        }
-    }
 }
 
 impl_axis_index!(Declared => Option<Len>);

core/src/widget/widgets.rs

@@ -1,8 +1,8 @@
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 use crate::{
-    Axis, AxisAlign, IdLike, Len, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget,
-    Widget, WidgetData, WidgetId,
+    Axis, AxisAlign, IdLike, Len, RegionAlign, SizeRequest, SizeRule, SizeRules, StrongWidget,
+    WeakWidget, Widget, WidgetData, WidgetId,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -146,7 +146,7 @@ impl Widgets {
     }
 
     /// Changes the preferred length without changing its bounds.
-    pub fn set_len(&mut self, id: impl IdLike, axis: Axis, len: impl Into<crate::SizeRequest>) {
+    pub fn set_len(&mut self, id: impl IdLike, axis: Axis, len: impl Into<SizeRequest>) {
         let id = id.id();
         let rule = SizeRule {
             request: Some(len.into()),