New block spacing model

5 files changed, 155 insertions, 119 deletions

diff --git a/library/src/layout/container.rs b/library/src/layout/container.rs
index d65b78b6..22a9e02e 100644
--- a/library/src/layout/container.rs
+++ b/library/src/layout/container.rs
@@ -1,3 +1,4 @@
+use super::VNode;
 use crate::prelude::*;
 
 /// An inline-level container that sizes content.
@@ -63,9 +64,22 @@ pub struct BlockNode(pub Content);
 
 #[node(LayoutBlock)]
 impl BlockNode {
+    /// The spacing between the previous and this block.
+    #[property(skip)]
+    pub const ABOVE: VNode = VNode::weak(Em::new(1.2).into());
+    /// The spacing between this and the following block.
+    #[property(skip)]
+    pub const BELOW: VNode = VNode::weak(Em::new(1.2).into());
+
     fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.eat()?.unwrap_or_default()).pack())
     }
+
+    fn set(...) {
+        let spacing = args.named("spacing")?.map(VNode::weak);
+        styles.set_opt(Self::ABOVE, args.named("above")?.map(VNode::strong).or(spacing));
+        styles.set_opt(Self::BELOW, args.named("below")?.map(VNode::strong).or(spacing));
+    }
 }
 
 impl LayoutBlock for BlockNode {
diff --git a/library/src/layout/flow.rs b/library/src/layout/flow.rs
index 347c1dd8..cc5dcd50 100644
--- a/library/src/layout/flow.rs
+++ b/library/src/layout/flow.rs
@@ -1,6 +1,7 @@
 use std::cmp::Ordering;
 
-use super::{AlignNode, PlaceNode, Spacing};
+use super::{AlignNode, PlaceNode, Spacing, VNode};
+use crate::layout::BlockNode;
 use crate::prelude::*;
 use crate::text::ParNode;
 
@@ -15,7 +16,7 @@ pub struct FlowNode(pub StyleVec<FlowChild>);
 #[derive(Hash, PartialEq)]
 pub enum FlowChild {
     /// Vertical spacing between other children.
-    Spacing(Spacing),
+    Spacing(VNode),
     /// Arbitrary block-level content.
     Block(Content),
     /// A column / region break.
@@ -32,13 +33,13 @@ impl LayoutBlock for FlowNode {
         regions: &Regions,
         styles: StyleChain,
     ) -> SourceResult<Vec<Frame>> {
-        let mut layouter = FlowLayouter::new(regions);
+        let mut layouter = FlowLayouter::new(regions, styles);
 
         for (child, map) in self.0.iter() {
             let styles = map.chain(&styles);
             match child {
-                FlowChild::Spacing(kind) => {
-                    layouter.layout_spacing(*kind, styles);
+                FlowChild::Spacing(node) => {
+                    layouter.layout_spacing(node, styles);
                 }
                 FlowChild::Block(block) => {
                     layouter.layout_block(world, block, styles)?;
@@ -80,9 +81,11 @@ impl PartialOrd for FlowChild {
 }
 
 /// Performs flow layout.
-struct FlowLayouter {
+struct FlowLayouter<'a> {
     /// The regions to layout children into.
     regions: Regions,
+    /// The shared styles.
+    shared: StyleChain<'a>,
     /// Whether the flow should expand to fill the region.
     expand: Axes<bool>,
     /// The full size of `regions.size` that was available before we started
@@ -92,6 +95,8 @@ struct FlowLayouter {
     used: Size,
     /// The sum of fractions in the current region.
     fr: Fr,
+    /// The spacing below the last block.
+    below: Option<VNode>,
     /// Spacing and layouted blocks.
     items: Vec<FlowItem>,
     /// Finished frames for previous regions.
@@ -110,9 +115,9 @@ enum FlowItem {
     Placed(Frame),
 }
 
-impl FlowLayouter {
+impl<'a> FlowLayouter<'a> {
     /// Create a new flow layouter.
-    fn new(regions: &Regions) -> Self {
+    fn new(regions: &Regions, shared: StyleChain<'a>) -> Self {
         let expand = regions.expand;
         let full = regions.first;
 
@@ -122,18 +127,20 @@ impl FlowLayouter {
 
         Self {
             regions,
+            shared,
             expand,
             full,
             used: Size::zero(),
             fr: Fr::zero(),
+            below: None,
             items: vec![],
             finished: vec![],
         }
     }
 
     /// Layout spacing.
-    fn layout_spacing(&mut self, spacing: Spacing, styles: StyleChain) {
-        match spacing {
+    fn layout_spacing(&mut self, node: &VNode, styles: StyleChain) {
+        match node.amount {
             Spacing::Relative(v) => {
                 // Resolve the spacing and limit it to the remaining space.
                 let resolved = v.resolve(styles).relative_to(self.full.y);
@@ -147,6 +154,10 @@ impl FlowLayouter {
                 self.fr += v;
             }
         }
+
+        if node.weak || node.amount.is_fractional() {
+            self.below = None;
+        }
     }
 
     /// Layout a block.
@@ -161,9 +172,19 @@ impl FlowLayouter {
             self.finish_region();
         }
 
+        // Add spacing between the last block and this one.
+        if let Some(below) = self.below.take() {
+            let above = styles.get(BlockNode::ABOVE);
+            let pick_below = (above.weak && !below.weak) || (below.amount > above.amount);
+            let spacing = if pick_below { below } else { above };
+            self.layout_spacing(&spacing, self.shared);
+        }
+
         // Placed nodes that are out of flow produce placed items which aren't
         // aligned later.
+        let mut is_placed = false;
         if let Some(placed) = block.downcast::<PlaceNode>() {
+            is_placed = true;
             if placed.out_of_flow() {
                 let frame = block.layout_block(world, &self.regions, styles)?.remove(0);
                 self.items.push(FlowItem::Placed(frame));
@@ -202,6 +223,10 @@ impl FlowLayouter {
             }
         }
 
+        if !is_placed {
+            self.below = Some(styles.get(BlockNode::BELOW));
+        }
+
         Ok(())
     }
 
@@ -250,6 +275,7 @@ impl FlowLayouter {
         self.full = self.regions.first;
         self.used = Size::zero();
         self.fr = Fr::zero();
+        self.below = None;
         self.finished.push(output);
     }
 
diff --git a/library/src/layout/grid.rs b/library/src/layout/grid.rs
index 8e1cb7a2..8af69b9a 100644
--- a/library/src/layout/grid.rs
+++ b/library/src/layout/grid.rs
@@ -1,5 +1,7 @@
 use crate::prelude::*;
 
+use super::Spacing;
+
 /// Arrange content in a grid.
 #[derive(Debug, Hash)]
 pub struct GridNode {
@@ -66,6 +68,15 @@ pub enum TrackSizing {
     Fractional(Fr),
 }
 
+impl From<Spacing> for TrackSizing {
+    fn from(spacing: Spacing) -> Self {
+        match spacing {
+            Spacing::Relative(rel) => Self::Relative(rel),
+            Spacing::Fractional(fr) => Self::Fractional(fr),
+        }
+    }
+}
+
 /// Track sizing definitions.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
 pub struct TrackSizings(pub Vec<TrackSizing>);
diff --git a/library/src/layout/mod.rs b/library/src/layout/mod.rs
index 1032ba54..e0eb431c 100644
--- a/library/src/layout/mod.rs
+++ b/library/src/layout/mod.rs
@@ -32,8 +32,8 @@ use typst::diag::SourceResult;
 use typst::frame::Frame;
 use typst::geom::*;
 use typst::model::{
-    capability, Barrier, Content, Node, SequenceNode, Show, StyleChain, StyleEntry,
-    StyleVec, StyleVecBuilder, StyledNode, Target,
+    capability, Content, Node, SequenceNode, Show, StyleChain, StyleEntry, StyleVec,
+    StyleVecBuilder, StyledNode, Target,
 };
 use typst::World;
 
@@ -85,10 +85,12 @@ impl LayoutBlock for Content {
         regions: &Regions,
         styles: StyleChain,
     ) -> SourceResult<Vec<Frame>> {
-        if let Some(node) = self.to::<dyn LayoutBlock>() {
-            let barrier = StyleEntry::Barrier(Barrier::new(self.id()));
-            let styles = barrier.chain(&styles);
-            return node.layout_block(world, regions, styles);
+        if !self.has::<dyn Show>() || !styles.applicable(self) {
+            if let Some(node) = self.to::<dyn LayoutBlock>() {
+                let barrier = StyleEntry::Barrier(self.id());
+                let styles = barrier.chain(&styles);
+                return node.layout_block(world, regions, styles);
+            }
         }
 
         let scratch = Scratch::default();
@@ -119,16 +121,18 @@ impl LayoutInline for Content {
         regions: &Regions,
         styles: StyleChain,
     ) -> SourceResult<Vec<Frame>> {
-        if let Some(node) = self.to::<dyn LayoutInline>() {
-            let barrier = StyleEntry::Barrier(Barrier::new(self.id()));
-            let styles = barrier.chain(&styles);
-            return node.layout_inline(world, regions, styles);
-        }
+        if !self.has::<dyn Show>() || !styles.applicable(self) {
+            if let Some(node) = self.to::<dyn LayoutInline>() {
+                let barrier = StyleEntry::Barrier(self.id());
+                let styles = barrier.chain(&styles);
+                return node.layout_inline(world, regions, styles);
+            }
 
-        if let Some(node) = self.to::<dyn LayoutBlock>() {
-            let barrier = StyleEntry::Barrier(Barrier::new(self.id()));
-            let styles = barrier.chain(&styles);
-            return node.layout_block(world, regions, styles);
+            if let Some(node) = self.to::<dyn LayoutBlock>() {
+                let barrier = StyleEntry::Barrier(self.id());
+                let styles = barrier.chain(&styles);
+                return node.layout_block(world, regions, styles);
+            }
         }
 
         let scratch = Scratch::default();
@@ -253,8 +257,6 @@ struct Builder<'a> {
 struct Scratch<'a> {
     /// An arena where intermediate style chains are stored.
     styles: Arena<StyleChain<'a>>,
-    /// An arena for individual intermediate style entries.
-    entries: Arena<StyleEntry>,
     /// An arena where intermediate content resulting from show rules is stored.
     content: Arena<Content>,
 }
@@ -354,18 +356,7 @@ impl<'a> Builder<'a> {
         Ok(())
     }
 
-    fn show(
-        &mut self,
-        content: &'a Content,
-        styles: StyleChain<'a>,
-    ) -> SourceResult<bool> {
-        let barrier = StyleEntry::Barrier(Barrier::new(content.id()));
-        let styles = self
-            .scratch
-            .entries
-            .alloc(barrier)
-            .chain(self.scratch.styles.alloc(styles));
-
+    fn show(&mut self, content: &Content, styles: StyleChain<'a>) -> SourceResult<bool> {
         let Some(realized) = styles.apply(self.world, Target::Node(content))? else {
             return Ok(false);
         };
@@ -457,7 +448,7 @@ struct DocBuilder<'a> {
 }
 
 impl<'a> DocBuilder<'a> {
-    fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) {
+    fn accept(&mut self, content: &Content, styles: StyleChain<'a>) {
         if let Some(pagebreak) = content.downcast::<PagebreakNode>() {
             self.keep_next = !pagebreak.weak;
         }
@@ -477,10 +468,10 @@ impl Default for DocBuilder<'_> {
 
 /// Accepts flow content.
 #[derive(Default)]
-struct FlowBuilder<'a>(CollapsingBuilder<'a, FlowChild>);
+struct FlowBuilder<'a>(CollapsingBuilder<'a, FlowChild>, bool);
 
 impl<'a> FlowBuilder<'a> {
-    fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
+    fn accept(&mut self, content: &Content, styles: StyleChain<'a>) -> bool {
         // Weak flow elements:
         // Weakness | Element
         //    0     | weak colbreak
@@ -490,8 +481,11 @@ impl<'a> FlowBuilder<'a> {
         //    4     | generated weak fractional spacing
         //    5     | par spacing
 
+        let last_was_parbreak = self.1;
+        self.1 = false;
+
         if content.is::<ParbreakNode>() {
-            /* Nothing to do */
+            self.1 = true;
         } else if let Some(colbreak) = content.downcast::<ColbreakNode>() {
             if colbreak.weak {
                 self.0.weak(FlowChild::Colbreak, styles, 0);
@@ -499,10 +493,10 @@ impl<'a> FlowBuilder<'a> {
                 self.0.destructive(FlowChild::Colbreak, styles);
             }
         } else if let Some(vertical) = content.downcast::<VNode>() {
-            let child = FlowChild::Spacing(vertical.amount);
+            let child = FlowChild::Spacing(*vertical);
             let frac = vertical.amount.is_fractional();
             if vertical.weak {
-                let weakness = 1 + u8::from(frac) + 2 * u8::from(vertical.generated);
+                let weakness = 1 + u8::from(frac);
                 self.0.weak(child, styles, weakness);
             } else if frac {
                 self.0.destructive(child, styles);
@@ -510,6 +504,24 @@ impl<'a> FlowBuilder<'a> {
                 self.0.ignorant(child, styles);
             }
         } else if content.has::<dyn LayoutBlock>() {
+            if !last_was_parbreak {
+                let tight = if let Some(node) = content.downcast::<ListNode>() {
+                    node.tight
+                } else if let Some(node) = content.downcast::<EnumNode>() {
+                    node.tight
+                } else if let Some(node) = content.downcast::<DescNode>() {
+                    node.tight
+                } else {
+                    false
+                };
+
+                if tight {
+                    let leading = styles.get(ParNode::LEADING);
+                    let spacing = VNode::weak(leading.into());
+                    self.0.weak(FlowChild::Spacing(spacing), styles, 1);
+                }
+            }
+
             let child = FlowChild::Block(content.clone());
             if content.is::<PlaceNode>() {
                 self.0.ignorant(child, styles);
@@ -523,18 +535,6 @@ impl<'a> FlowBuilder<'a> {
         true
     }
 
-    fn par(&mut self, par: ParNode, styles: StyleChain<'a>, indent: bool) {
-        let amount = if indent && !styles.get(ParNode::SPACING_AND_INDENT) {
-            styles.get(ParNode::LEADING).into()
-        } else {
-            styles.get(ParNode::SPACING).into()
-        };
-
-        self.0.weak(FlowChild::Spacing(amount), styles, 5);
-        self.0.supportive(FlowChild::Block(par.pack()), styles);
-        self.0.weak(FlowChild::Spacing(amount), styles, 5);
-    }
-
     fn finish(self, doc: &mut DocBuilder<'a>, styles: StyleChain<'a>) {
         let (flow, shared) = self.0.finish();
         let styles = if flow.is_empty() { styles } else { shared };
@@ -552,7 +552,7 @@ impl<'a> FlowBuilder<'a> {
 struct ParBuilder<'a>(CollapsingBuilder<'a, ParChild>);
 
 impl<'a> ParBuilder<'a> {
-    fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
+    fn accept(&mut self, content: &Content, styles: StyleChain<'a>) -> bool {
         // Weak par elements:
         // Weakness | Element
         //    0     | weak fractional spacing
@@ -621,7 +621,7 @@ impl<'a> ParBuilder<'a> {
             children.push_front(ParChild::Spacing(indent.into()));
         }
 
-        parent.flow.par(ParNode(children), shared, !indent.is_zero());
+        parent.flow.accept(&ParNode(children).pack(), shared);
     }
 
     fn is_empty(&self) -> bool {
@@ -635,63 +635,54 @@ struct ListBuilder<'a> {
     items: StyleVecBuilder<'a, ListItem>,
     /// Whether the list contains no paragraph breaks.
     tight: bool,
-    /// Whether the list can be attached.
-    attachable: bool,
     /// Trailing content for which it is unclear whether it is part of the list.
     staged: Vec<(&'a Content, StyleChain<'a>)>,
 }
 
 impl<'a> ListBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
-        if self.items.is_empty() {
-            if content.is::<ParbreakNode>() {
-                self.attachable = false;
-            } else if !content.is::<SpaceNode>() && !content.is::<ListItem>() {
-                self.attachable = true;
-            }
-        }
-
-        if let Some(item) = content.downcast::<ListItem>() {
+        if !self.items.is_empty()
+            && (content.is::<SpaceNode>() || content.is::<ParbreakNode>())
+        {
+            self.staged.push((content, styles));
+        } else if let Some(item) = content.downcast::<ListItem>() {
             if self
                 .items
                 .items()
                 .next()
-                .map_or(true, |first| item.kind() == first.kind())
+                .map_or(false, |first| item.kind() != first.kind())
             {
-                self.items.push(item.clone(), styles);
-                self.tight &= self.staged.drain(..).all(|(t, _)| !t.is::<ParbreakNode>());
-                return true;
+                return false;
             }
-        } else if !self.items.is_empty()
-            && (content.is::<SpaceNode>() || content.is::<ParbreakNode>())
-        {
-            self.staged.push((content, styles));
-            return true;
+
+            self.items.push(item.clone(), styles);
+            self.tight &= self.staged.drain(..).all(|(t, _)| !t.is::<ParbreakNode>());
+        } else {
+            return false;
         }
 
-        false
+        true
     }
 
     fn finish(self, parent: &mut Builder<'a>) -> SourceResult<()> {
         let (items, shared) = self.items.finish();
+        if let Some(item) = items.items().next() {
+            let tight = self.tight;
+            let content = match item.kind() {
+                LIST => ListNode::<LIST> { tight, items }.pack(),
+                ENUM => ListNode::<ENUM> { tight, items }.pack(),
+                DESC | _ => ListNode::<DESC> { tight, items }.pack(),
+            };
 
-        let Some(item) = items.items().next() else { return Ok(()) };
-        let tight = self.tight;
-        let attached = tight && self.attachable;
-        let content = match item.kind() {
-            LIST => ListNode::<LIST> { tight, attached, items }.pack(),
-            ENUM => ListNode::<ENUM> { tight, attached, items }.pack(),
-            DESC | _ => ListNode::<DESC> { tight, attached, items }.pack(),
-        };
-
-        let stored = parent.scratch.content.alloc(content);
-        parent.accept(stored, shared)?;
+            let stored = parent.scratch.content.alloc(content);
+            parent.accept(stored, shared)?;
+        }
 
         for (content, styles) in self.staged {
             parent.accept(content, styles)?;
         }
 
-        parent.list.attachable = true;
+        parent.list.tight = true;
 
         Ok(())
     }
@@ -706,7 +697,6 @@ impl Default for ListBuilder<'_> {
         Self {
             items: StyleVecBuilder::default(),
             tight: true,
-            attachable: true,
             staged: vec![],
         }
     }
diff --git a/library/src/layout/spacing.rs b/library/src/layout/spacing.rs
index 67fff5db..66d71ed1 100644
--- a/library/src/layout/spacing.rs
+++ b/library/src/layout/spacing.rs
@@ -1,10 +1,9 @@
 use std::cmp::Ordering;
 
 use crate::prelude::*;
-use crate::text::ParNode;
 
 /// Horizontal spacing.
-#[derive(Debug, Clone, Hash)]
+#[derive(Debug, Copy, Clone, Hash)]
 pub struct HNode {
     pub amount: Spacing,
     pub weak: bool,
@@ -20,11 +19,22 @@ impl HNode {
 }
 
 /// Vertical spacing.
-#[derive(Debug, Clone, Hash)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd)]
 pub struct VNode {
     pub amount: Spacing,
     pub weak: bool,
-    pub generated: bool,
+}
+
+impl VNode {
+    /// Create weak vertical spacing.
+    pub fn weak(amount: Spacing) -> Self {
+        Self { amount, weak: true }
+    }
+
+    /// Create strong vertical spacing.
+    pub fn strong(amount: Spacing) -> Self {
+        Self { amount, weak: false }
+    }
 }
 
 #[node]
@@ -32,7 +42,7 @@ impl VNode {
     fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
         let amount = args.expect("spacing")?;
         let weak = args.named("weak")?.unwrap_or(false);
-        Ok(Self { amount, weak, generated: false }.pack())
+        Ok(Self { amount, weak }.pack())
     }
 }
 
@@ -59,6 +69,12 @@ impl From<Abs> for Spacing {
     }
 }
 
+impl From<Em> for Spacing {
+    fn from(em: Em) -> Self {
+        Self::Relative(Rel::new(Ratio::zero(), em.into()))
+    }
+}
+
 impl PartialOrd for Spacing {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         match (self, other) {
@@ -77,24 +93,3 @@ castable! {
     Value::Relative(v) => Self::Relative(v),
     Value::Fraction(v) => Self::Fractional(v),
 }
-
-/// Spacing around and between blocks, relative to paragraph spacing.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct BlockSpacing(Rel<Length>);
-
-castable!(BlockSpacing: Rel<Length>);
-
-impl Resolve for BlockSpacing {
-    type Output = Abs;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        let whole = styles.get(ParNode::SPACING);
-        self.0.resolve(styles).relative_to(whole)
-    }
-}
-
-impl From<Ratio> for BlockSpacing {
-    fn from(ratio: Ratio) -> Self {
-        Self(ratio.into())
-    }
-}