Rename into_block to pack

src/eval/mod.rs

@@ -35,7 +35,6 @@ use once_cell::sync::Lazy;
 use syntect::easy::HighlightLines;
 use syntect::highlighting::{FontStyle, Highlighter, Style as SynStyle, Theme, ThemeSet};
 use syntect::parsing::SyntaxSet;
-
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
@@ -255,11 +254,7 @@ impl Eval for RawNode {
 
     fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
         let code = self.highlighted();
-        Ok(if self.block {
+        Ok(if self.block { Template::Block(code.pack()) } else { code })
-            Template::Block(code.into_block())
-        } else {
-            code
-        })
     }
 }
 
@@ -352,7 +347,7 @@ impl Eval for MathNode {
     fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
         let text = Template::Text(self.formula.trim().into()).monospaced();
         Ok(if self.display {
-            Template::Block(text.into_block())
+            Template::Block(text.pack())
         } else {
             text
         })
@@ -364,7 +359,7 @@ impl Eval for HeadingNode {
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         Ok(Template::block(library::HeadingNode {
-            child: self.body().eval(ctx)?.into_block(),
+            child: self.body().eval(ctx)?.pack(),
             level: self.level(),
         }))
     }
@@ -375,7 +370,7 @@ impl Eval for ListNode {
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         Ok(Template::block(library::ListNode {
-            child: self.body().eval(ctx)?.into_block(),
+            child: self.body().eval(ctx)?.pack(),
             kind: library::Unordered,
         }))
     }
@@ -386,7 +381,7 @@ impl Eval for EnumNode {
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         Ok(Template::block(library::ListNode {
-            child: self.body().eval(ctx)?.into_block(),
+            child: self.body().eval(ctx)?.pack(),
             kind: library::Ordered(self.number()),
         }))
     }

src/eval/template.rs

@@ -27,18 +27,18 @@ use crate::util::EcoString;
 ///    represented as a `Styled(Text("Hello"), [TextNode::STRONG: true])`
 ///    template.
 ///
-/// 2. A `Sequence` template simply combines multiple templates and will be
+/// 2. A `Sequence` template combines multiple arbitrary templates and is the
-///    layouted as a [flow](FlowNode). So, when you write `[Hi] + [you]` in
+///    representation of a "flow" of content. So, when you write `[Hi] + [you]`
-///    Typst, this type's [`Add`] implementation is invoked and the two
+///    in Typst, this type's [`Add`] implementation is invoked and the two
-///    templates are combined into a single [`Sequence`](Self::Sequence)
+///    [`Text`](Self::Text) templates are combined into a single
-///    template.
+///    [`Sequence`](Self::Sequence) template.
 ///
 ///    A sequence may contain nested sequences (meaning this variant effectively
-///    allows nodes to form trees). All nested sequences can equivalently be
+///    allows templates to form trees). All nested sequences can equivalently be
 ///    represented as a single flat sequence, but allowing nesting doesn't hurt
-///    since we can just recurse into the nested sequences during packing. Also,
+///    since we can just recurse into the nested sequences. Also, in theory,
-///    in theory, this allows better complexity when adding (large) sequence
+///    this allows better complexity when adding large sequence nodes just like
-///    nodes (just like for a text rope).
+///    for something like a text rope.
 #[derive(Debug, PartialEq, Clone, Hash)]
 pub enum Template {
     /// A word space.
@@ -116,8 +116,16 @@ impl Template {
         self.styled(TextNode::MONOSPACE, true)
     }
 
-    /// Lift to a type-erased block-level template.
+    /// Repeat this template `n` times.
-    pub fn into_block(self) -> PackedNode {
+    pub fn repeat(&self, n: i64) -> StrResult<Self> {
+        let count = usize::try_from(n)
+            .map_err(|_| format!("cannot repeat this template {} times", n))?;
+
+        Ok(Self::Sequence(vec![self.clone(); count]))
+    }
+
+    /// Convert to a type-erased block-level node.
+    pub fn pack(self) -> PackedNode {
         if let Template::Block(packed) = self {
             packed
         } else {
@@ -133,14 +141,6 @@ impl Template {
         packer.walk(self, StyleMap::new());
         packer.into_root()
     }
-
-    /// Repeat this template `n` times.
-    pub fn repeat(&self, n: i64) -> StrResult<Self> {
-        let count = usize::try_from(n)
-            .map_err(|_| format!("cannot repeat this template {} times", n))?;
-
-        Ok(Self::Sequence(vec![self.clone(); count]))
-    }
 }
 
 impl Default for Template {

src/layout/mod.rs

@@ -267,6 +267,8 @@ impl Debug for PackedNode {
 
 impl PartialEq for PackedNode {
     fn eq(&self, other: &Self) -> bool {
+        // We cast to thin pointers for comparison because we don't want to
+        // compare vtables (which can be different across codegen units).
         std::ptr::eq(
             Arc::as_ptr(&self.node) as *const (),
             Arc::as_ptr(&other.node) as *const (),

src/library/list.rs

@@ -54,7 +54,7 @@ impl<L: ListKind> Layout for ListNode<L> {
             gutter: Spec::default(),
             children: vec![
                 PackedNode::default(),
-                Template::Text(self.kind.label()).into_block(),
+                Template::Text(self.kind.label()).pack(),
                 PackedNode::default(),
                 self.child.clone(),
             ],

src/library/mod.rs

@@ -228,5 +228,5 @@ castable! {
 castable! {
     PackedNode,
     Expected: "template",
-    Value::Template(template) => template.into_block(),
+    Value::Template(template) => template.pack(),
 }

src/library/stack.rs

@@ -61,7 +61,7 @@ castable! {
     Value::Relative(v) => Self::Spacing(SpacingKind::Linear(v.into())),
     Value::Linear(v) => Self::Spacing(SpacingKind::Linear(v)),
     Value::Fractional(v) => Self::Spacing(SpacingKind::Fractional(v)),
-    Value::Template(v) => Self::Node(v.into_block()),
+    Value::Template(v) => Self::Node(v.pack()),
 }
 
 /// Performs stack layout.