diff --git a/core/src/ui/painter.rs b/core/src/ui/painter.rs
index d4d7518..535d826 100644
--- a/core/src/ui/painter.rs
+++ b/core/src/ui/painter.rs
@@ -222,7 +222,7 @@ impl<'a> Painter<'a> {
         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).known().or_else(|| {
+        let hint = widgets.size_rules(id.id()).axis(axis).exact().or_else(|| {
             widgets
                 .get_dyn(id.id())
                 .and_then(|widget| widget.size_hint(axis))
@@ -360,17 +360,21 @@ impl<'a> Painter<'a> {
         self.rsc.widgets().alignment(self.id)
     }
 
-    /// Whether a rule beside this widget settles its length on `axis`, which
-    /// makes whatever it reports for that axis moot. The widget under a rule
-    /// does not otherwise learn of it -- this is for a container deciding
-    /// whether reading its children across an axis is worth anything, since
-    /// reading one is also what makes its own size depend on it.
-    pub fn ruled(&self, axis: Axis) -> bool {
+    /// Whether a rule beside this widget gives its length on `axis` outright,
+    /// which makes whatever it reports for that axis moot. A rule that only
+    /// bounds the length is not one of these: the answer is still the
+    /// widget's to give, and something still has to work it out.
+    ///
+    /// The widget under a rule does not otherwise learn of it -- this is for
+    /// a container deciding whether reading its children across an axis is
+    /// worth anything, since reading one is also what makes its own size
+    /// depend on it.
+    pub fn has_exact_size(&self, axis: Axis) -> bool {
         self.rsc
             .widgets()
             .size_rules(self.id)
             .axis(axis)
-            .known()
+            .exact()
             .is_some()
     }
 
diff --git a/core/src/widget/size_rule.rs b/core/src/widget/size_rule.rs
index 6001cd1..d046ed4 100644
--- a/core/src/widget/size_rule.rs
+++ b/core/src/widget/size_rule.rs
@@ -29,11 +29,12 @@ impl SizeRule {
         }
     }
 
-    /// 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<LayoutLen> {
+    /// The length this rule gives outright, whatever the widget reports --
+    /// which makes the widget's answer on that axis moot. A share counts: it
+    /// is a length the widget's parent still has to divide, so it is exact
+    /// here and resolved there, unlike `declared`, which is only the ones
+    /// that give a box directly.
+    pub fn exact(&self) -> Option<LayoutLen> {
         match self {
             Self::Free => None,
             Self::Exact(len) => Some(*len),
diff --git a/src/widget/position/span.rs b/src/widget/position/span.rs
index 659c788..58d634a 100644
--- a/src/widget/position/span.rs
+++ b/src/widget/position/span.rs
@@ -80,9 +80,11 @@ impl Widget for Span {
         }
 
         // Across itself a span is as long as its longest child -- unless a
-        // rule beside it already says how long it is, and then reading them
-        // answers nothing and makes its size depend on theirs for it.
-        let shrinks = !painter.ruled(!axis);
+        // rule beside it gives that length outright, and then reading them
+        // answers nothing and makes its size depend on theirs for it. A rule
+        // that only bounds the length does not count: the answer is still
+        // this span's to give.
+        let shrinks = !painter.has_exact_size(!axis);
         // What the fixed parts and the gaps before here take, which is a sum
         // of lengths and exact, and how much of the leftover weight is
         // spoken for. A position is one from the other rather than a step
diff --git a/tests/generated.rs b/tests/generated.rs
index 02372e5..934f133 100644
--- a/tests/generated.rs
+++ b/tests/generated.rs
@@ -178,7 +178,7 @@ fn reshuffle(
 /// it has to be buildable from what the failure printed.
 fn describe(id: WidgetId, h: &Harness) -> String {
     let rules = h.rsc.widgets().size_rules(id);
-    let rule = |r: SizeRule| match r.known() {
+    let rule = |r: SizeRule| match r.exact() {
         Some(len) => format!("{len}"),
         None => "-".into(),
     };