Carry a length as a rule beside a widget, not a widget around it

`.width()` built a `SetSize` whose whole job was to answer `size_hint`, so
every declared length cost a widget, an `ActiveData` and a link of chain to
say one number. It is now a `SizeRule` per axis on `WidgetData`, beside
`region_node`, resolved by `Painter` where the widget is drawn. `SetSize`
and `MaxSize` are gone; `MaxSize` had no caller but its own builders.

That settles which of two answers is the size. A rule wins on the axis it
names and the `Size` returned by `draw` answers the rest, applied once in
`draw_inner` rather than by each widget that could carry one -- so the
widget under a rule never learns of it. `Painter::size_hint` reads the rule
first for the same reason: a rule that beats what a widget would draw has
to beat what it says about itself.

`declared_lens` still falls back to a non-leftover `size_hint`, which is
how an image or a gap gets its own pixel size rather than the whole offer.
That is the offer's business rather than a declaration's, and it falls away
when a widget occupies its reported size inside the box it was offered.

`known` and `declared` are separate because a share is a length to whoever
divides one and not to whoever composes a box: `.width(leftover(3))` is
known without drawing but cannot narrow anything.

Checked: fmt, clippy, 85 tests, and 100 generated seeds agreeing warm
against cold in 67.6 s. `minimal`, `text` and `view` render byte-identical
at 1920x1200; `tabs` differs only in the widget count it prints about
itself, which is two wrapper types smaller.

core/src/widget/data.rs

@@ -1,9 +1,10 @@
-use crate::Widget;
+use crate::{SizeRules, Widget};
 
 pub struct WidgetData {
     pub widget: Box<dyn Widget>,
     pub label: String,
     pub(super) region_node: bool,
+    pub(super) size: SizeRules,
     /// dynamic borrow checking
     pub borrowed: bool,
 }
@@ -18,6 +19,7 @@ impl WidgetData {
             widget: Box::new(widget),
             label,
             region_node: false,
+            size: SizeRules::default(),
             borrowed: false,
         }
     }

core/src/widget/mod.rs

@@ -4,6 +4,7 @@ use std::any::Any;
 mod data;
 mod handle;
 mod like;
+mod size_rule;
 mod tag;
 mod view;
 mod widgets;
@@ -11,6 +12,7 @@ mod widgets;
 pub use data::*;
 pub use handle::*;
 pub use like::*;
+pub use size_rule::*;
 pub use tag::*;
 pub use view::*;
 pub use widgets::*;

core/src/widget/size_rule.rs

@@ -0,0 +1,86 @@
+use crate::{Axis, Len};
+
+/// What a widget's length on one axis is, as a rule its parent applies where
+/// it draws it rather than an answer the widget gives about itself.
+///
+/// A rule and a drawn size are not two opinions to reconcile: a rule wins on
+/// the axis it names, and the `Size` returned by `draw` answers only the axes
+/// with no rule. That is what lets a span divide its space around a length
+/// nobody has drawn yet, and it is why a rule lives beside the widget rather
+/// than inside it -- the widget under the rule never has to know about it.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum SizeRule {
+    /// Whatever the widget reports from drawing.
+    #[default]
+    Free,
+    /// This length, whatever the widget reports.
+    Exact(Len),
+}
+
+impl SizeRule {
+    /// The length this rule gives without the widget being drawn, if it can
+    /// give one. `leftover` is never among them: a share is a length only to
+    /// whoever divides one, so it passes up in the reported size instead and
+    /// is resolved there.
+    pub fn declared(&self) -> Option<Len> {
+        match self {
+            Self::Exact(len) if len.leftover == 0.0 => Some(*len),
+            _ => None,
+        }
+    }
+
+    /// The length this rule fixes, whether or not it can narrow a box. A
+    /// share is a length the widget's parent still has to divide, so it is
+    /// known here and resolved there -- unlike `declared`, which is only the
+    /// ones that give a box directly.
+    pub fn known(&self) -> Option<Len> {
+        match self {
+            Self::Free => None,
+            Self::Exact(len) => Some(*len),
+        }
+    }
+
+    /// The length a widget reporting `reported` ends up with.
+    pub fn apply(&self, reported: Len) -> Len {
+        match self {
+            Self::Free => reported,
+            Self::Exact(len) => *len,
+        }
+    }
+}
+
+impl From<Len> for SizeRule {
+    fn from(len: Len) -> Self {
+        Self::Exact(len)
+    }
+}
+
+impl From<Option<Len>> for SizeRule {
+    fn from(len: Option<Len>) -> Self {
+        len.map_or(Self::Free, Self::Exact)
+    }
+}
+
+/// One rule per axis, which is how a widget carries a length on one axis and
+/// leaves the other to whatever it draws.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct SizeRules {
+    pub x: SizeRule,
+    pub y: SizeRule,
+}
+
+impl SizeRules {
+    pub fn axis(&self, axis: Axis) -> SizeRule {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut SizeRule {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}

core/src/widget/widgets.rs

@@ -1,7 +1,7 @@
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 use crate::{
-    IdLike, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
+    Axis, IdLike, SizeRule, SizeRules, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -118,6 +118,36 @@ impl Widgets {
         self.needs_redraw.insert(id);
     }
 
+    /// The length rules whoever draws this widget applies to its box.
+    pub fn size_rules(&self, id: impl IdLike) -> SizeRules {
+        self.data(id).unwrap().size
+    }
+
+    /// Sets one axis's rule. The widget is marked rather than its parent
+    /// because the parent is not known here; `redraw` escalates a changed
+    /// declared length to whoever resolves it.
+    pub fn set_size_rule(&mut self, id: impl IdLike, axis: Axis, rule: SizeRule) {
+        let id = id.id();
+        let data = self.data_mut(id).unwrap();
+        if *data.size.axis_mut(axis) == rule {
+            return;
+        }
+        *data.size.axis_mut(axis) = rule;
+        self.needs_redraw.insert(id);
+    }
+
+    /// Both axes at once, for a caller holding a pair.
+    pub fn set_size_rules(
+        &mut self,
+        id: impl IdLike,
+        x: impl Into<SizeRule>,
+        y: impl Into<SizeRule>,
+    ) {
+        let id = id.id();
+        self.set_size_rule(id, Axis::X, x.into());
+        self.set_size_rule(id, Axis::Y, y.into());
+    }
+
     pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> {
         self.vec.get_mut(id.id())
     }