Style changes

cli/src/main.rs

@@ -115,10 +115,7 @@ fn parse_args() -> StrResult<Command> {
     // Don't allow excess arguments.
     let rest = args.finish();
     if !rest.is_empty() {
-        Err(format!(
+        Err(format!("unexpected argument{}", if rest.len() > 1 { "s" } else { "" }))?;
-            "unexpected argument{}",
-            if rest.len() > 1 { "s" } else { "" }
-        ))?;
     }
 
     Ok(command)

library/src/base/calc.rs

@@ -101,14 +101,12 @@ pub fn mod_(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
         (Value::Int(a), Value::Float(b)) => (a as f64, b),
         (Value::Float(a), Value::Int(b)) => (a, b as f64),
         (Value::Float(a), Value::Float(b)) => (a, b),
-        (Value::Int(_), b) | (Value::Float(_), b) => bail!(
+        (Value::Int(_), b) | (Value::Float(_), b) => {
-            span2,
+            bail!(span2, format!("expected integer or float, found {}", b.type_name()))
-            format!("expected integer or float, found {}", b.type_name())
+        }
-        ),
+        (a, _) => {
-        (a, _) => bail!(
+            bail!(span1, format!("expected integer or float, found {}", a.type_name()))
-            span1,
+        }
-            format!("expected integer or float, found {}", a.type_name())
-        ),
     };
 
     if b == 0.0 {

library/src/base/color.rs

@@ -10,8 +10,7 @@ pub fn luma(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 
 /// Create an RGB(A) color.
 pub fn rgb(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
-    Ok(Value::Color(
+    Ok(Value::Color(if let Some(string) = args.find::<Spanned<EcoString>>()? {
-        if let Some(string) = args.find::<Spanned<EcoString>>()? {
         match RgbaColor::from_str(&string.v) {
             Ok(color) => color.into(),
             Err(msg) => bail!(string.span, msg),
@@ -22,8 +21,7 @@ pub fn rgb(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
         let Component(b) = args.expect("blue component")?;
         let Component(a) = args.eat()?.unwrap_or(Component(255));
         RgbaColor::new(r, g, b, a).into()
-        },
+    }))
-    ))
 }
 
 /// Create a CMYK color.

library/src/base/data.rs

@@ -81,10 +81,7 @@ fn convert_json(value: serde_json::Value) -> Value {
 /// Format the user-facing JSON error message.
 fn format_json_error(error: serde_json::Error) -> String {
     assert!(error.is_syntax() || error.is_eof());
-    format!(
+    format!("failed to parse json file: syntax error in line {}", error.line())
-        "failed to parse json file: syntax error in line {}",
-        error.line()
-    )
 }
 
 /// Read structured data from an XML file.

library/src/base/mod.rs

@@ -5,10 +5,10 @@ mod color;
 mod data;
 mod string;
 
-pub use calc::*;
+pub use self::calc::*;
-pub use color::*;
+pub use self::color::*;
-pub use data::*;
+pub use self::data::*;
-pub use string::*;
+pub use self::string::*;
 
 use comemo::Track;
 use typst::model::{Eval, Route, Scopes, Vm};

library/src/ext.rs

@@ -55,11 +55,7 @@ impl ContentExt for Content {
         let mut seq = vec![];
         if let Some(above) = above {
             seq.push(
-                layout::VNode {
+                layout::VNode { amount: above.into(), weak: true, generated: true }
-                    amount: above.into(),
-                    weak: true,
-                    generated: true,
-                }
                     .pack(),
             );
         }
@@ -67,11 +63,7 @@ impl ContentExt for Content {
         seq.push(self);
         if let Some(below) = below {
             seq.push(
-                layout::VNode {
+                layout::VNode { amount: below.into(), weak: true, generated: true }
-                    amount: below.into(),
-                    weak: true,
-                    generated: true,
-                }
                     .pack(),
             );
         }

library/src/graphics/mod.rs

@@ -5,7 +5,7 @@ mod image;
 mod line;
 mod shape;
 
+pub use self::hide::*;
 pub use self::image::*;
-pub use hide::*;
+pub use self::line::*;
-pub use line::*;
+pub use self::shape::*;
-pub use shape::*;

library/src/layout/columns.rs

@@ -75,11 +75,7 @@ impl LayoutBlock for ColumnsNode {
             let mut cursor = Abs::zero();
 
             for _ in 0..columns {
-                let frame = match frames.next() {
+                let Some(frame) = frames.next() else { break };
-                    Some(frame) => frame,
-                    None => break,
-                };
-
                 if !regions.expand.y {
                     output.size_mut().y.set_max(frame.height());
                 }

library/src/layout/mod.rs

@@ -12,17 +12,17 @@ mod spacing;
 mod stack;
 mod transform;
 
-pub use align::*;
+pub use self::align::*;
-pub use columns::*;
+pub use self::columns::*;
-pub use container::*;
+pub use self::container::*;
-pub use flow::*;
+pub use self::flow::*;
-pub use grid::*;
+pub use self::grid::*;
-pub use pad::*;
+pub use self::pad::*;
-pub use page::*;
+pub use self::page::*;
-pub use place::*;
+pub use self::place::*;
-pub use spacing::*;
+pub use self::spacing::*;
-pub use stack::*;
+pub use self::stack::*;
-pub use transform::*;
+pub use self::transform::*;
 
 use std::mem;
 
@@ -357,7 +357,10 @@ impl<'a> Builder<'a> {
         content: &'a Content,
         styles: StyleChain<'a>,
     ) -> SourceResult<bool> {
-        if let Some(mut realized) = styles.apply(self.world, Target::Node(content))? {
+        let Some(mut realized) = styles.apply(self.world, Target::Node(content))? else {
+            return Ok(false);
+        };
+
         let mut map = StyleMap::new();
         let barrier = Barrier::new(content.id());
         map.push(StyleEntry::Barrier(barrier));
@@ -365,10 +368,8 @@ impl<'a> Builder<'a> {
         realized = realized.styled_with_map(map);
         let stored = self.scratch.templates.alloc(realized);
         self.accept(stored, styles)?;
+
         Ok(true)
-        } else {
-            Ok(false)
-        }
     }
 
     fn styled(
@@ -466,10 +467,7 @@ impl<'a> DocBuilder<'a> {
 
 impl Default for DocBuilder<'_> {
     fn default() -> Self {
-        Self {
+        Self { pages: StyleVecBuilder::new(), keep_next: true }
-            pages: StyleVecBuilder::new(),
-            keep_next: true,
-        }
     }
 }
 
@@ -658,30 +656,25 @@ impl<'a> ListBuilder<'a> {
             {
                 self.items.push(item.clone(), styles);
                 self.tight &= self.staged.drain(..).all(|(t, _)| !t.is::<ParbreakNode>());
-            } else {
+                return true;
-                return false;
             }
         } else if !self.items.is_empty()
             && (content.is::<SpaceNode>() || content.is::<ParbreakNode>())
         {
             self.staged.push((content, styles));
-        } else {
+            return true;
-            return false;
         }
 
-        true
+        false
     }
 
     fn finish(self, parent: &mut Builder<'a>) -> SourceResult<()> {
         let (items, shared) = self.items.finish();
-        let kind = match items.items().next() {
-            Some(item) => item.kind(),
-            None => return Ok(()),
-        };
 
+        let Some(item) = items.items().next() else { return Ok(()) };
         let tight = self.tight;
         let attached = tight && self.attachable;
-        let content = match kind {
+        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(),
@@ -765,18 +758,15 @@ impl<'a, T> CollapsingBuilder<'a, T> {
         }
 
         if self.last == Last::Weak {
-            if let Some(i) =
+            let weak = self.staged.iter().position(|(prev_item, _, prev_weakness)| {
-                self.staged.iter().position(|(prev_item, _, prev_weakness)| {
                 prev_weakness.map_or(false, |prev_weakness| {
                     weakness < prev_weakness
                         || (weakness == prev_weakness && item > *prev_item)
                 })
-                })
+            });
-            {
+
-                self.staged.remove(i);
+            let Some(weak) = weak else { return };
-            } else {
+            self.staged.remove(weak);
-                return;
-            }
         }
 
         self.staged.push((item, styles, Some(weakness)));

library/src/layout/page.rs

@@ -111,12 +111,7 @@ impl PageNode {
             let pw = size.x - pad.left - pad.right;
             let py = size.y - pad.bottom;
             for (role, marginal, pos, area) in [
-                (
+                (Role::Header, header, Point::with_x(pad.left), Size::new(pw, pad.top)),
-                    Role::Header,
-                    header,
-                    Point::with_x(pad.left),
-                    Size::new(pw, pad.top),
-                ),
                 (
                     Role::Footer,
                     footer,

library/src/math/mod.rs

@@ -69,12 +69,7 @@ impl LayoutInline for MathNode {
         _: &Regions,
         styles: StyleChain,
     ) -> SourceResult<Vec<Frame>> {
-        Ok(vec![layout_tex(
+        Ok(vec![layout_tex(&self.texify(), self.display, world, styles)?])
-            &self.texify(),
-            self.display,
-            world,
-            styles,
-        )?])
     }
 }
 

library/src/structure/list.rs

@@ -95,9 +95,9 @@ impl<const L: ListKind> Show for ListNode<L> {
         match name {
             "tight" => Some(Value::Bool(self.tight)),
             "attached" => Some(Value::Bool(self.attached)),
-            "items" => Some(Value::Array(
+            "items" => {
-                self.items.items().map(|item| item.encode()).collect(),
+                Some(Value::Array(self.items.items().map(|item| item.encode()).collect()))
-            )),
+            }
             _ => None,
         }
     }
@@ -139,11 +139,7 @@ impl<const L: ListKind> Show for ListNode<L> {
                 ListItem::List(body) => body.as_ref().clone(),
                 ListItem::Enum(_, body) => body.as_ref().clone(),
                 ListItem::Desc(item) => Content::sequence(vec![
-                    HNode {
+                    HNode { amount: (-body_indent).into(), weak: false }.pack(),
-                        amount: (-body_indent).into(),
-                        weak: false,
-                    }
-                    .pack(),
                     (item.term.clone() + TextNode(':'.into()).pack()).strong(),
                     SpaceNode.pack(),
                     item.body.clone(),

library/src/structure/mod.rs

@@ -6,8 +6,8 @@ mod list;
 mod reference;
 mod table;
 
-pub use doc::*;
+pub use self::doc::*;
-pub use heading::*;
+pub use self::heading::*;
-pub use list::*;
+pub use self::list::*;
-pub use reference::*;
+pub use self::reference::*;
-pub use table::*;
+pub use self::table::*;

library/src/text/deco.rs

@@ -56,13 +56,16 @@ impl<const L: DecoLine> Show for DecoNode<L> {
         _: Tracked<dyn World>,
         styles: StyleChain,
     ) -> SourceResult<Content> {
-        Ok(self.0.clone().styled(TextNode::DECO, Decoration {
+        Ok(self.0.clone().styled(
+            TextNode::DECO,
+            Decoration {
                 line: L,
                 stroke: styles.get(Self::STROKE).unwrap_or_default(),
                 offset: styles.get(Self::OFFSET),
                 extent: styles.get(Self::EXTENT),
                 evade: styles.get(Self::EVADE),
-        }))
+            },
+        ))
     }
 }
 

library/src/text/mod.rs

@@ -8,12 +8,12 @@ mod raw;
 mod shaping;
 mod shift;
 
-pub use deco::*;
+pub use self::deco::*;
-pub use link::*;
+pub use self::link::*;
-pub use par::*;
+pub use self::par::*;
-pub use raw::*;
+pub use self::raw::*;
-pub use shaping::*;
+pub use self::shaping::*;
-pub use shift::*;
+pub use self::shift::*;
 
 use std::borrow::Cow;
 

library/src/text/par.rs

@@ -500,11 +500,14 @@ fn prepare<'a>(
     regions: &Regions,
     styles: StyleChain<'a>,
 ) -> SourceResult<Preparation<'a>> {
-    let bidi = BidiInfo::new(text, match styles.get(TextNode::DIR) {
+    let bidi = BidiInfo::new(
+        text,
+        match styles.get(TextNode::DIR) {
             Dir::LTR => Some(BidiLevel::ltr()),
             Dir::RTL => Some(BidiLevel::rtl()),
             _ => None,
-    });
+        },
+    );
 
     let mut cursor = 0;
     let mut items = vec![];

library/src/text/quotes.rs

@@ -117,22 +117,38 @@ impl<'s> Quotes<'s> {
 
     /// The opening quote.
     fn open(&self, double: bool) -> &'s str {
-        if double { self.double_open } else { self.single_open }
+        if double {
+            self.double_open
+        } else {
+            self.single_open
+        }
     }
 
     /// The closing quote.
     fn close(&self, double: bool) -> &'s str {
-        if double { self.double_close } else { self.single_close }
+        if double {
+            self.double_close
+        } else {
+            self.single_close
+        }
     }
 
     /// Which character should be used as a prime.
     fn prime(&self, double: bool) -> &'static str {
-        if double { "″" } else { "′" }
+        if double {
+            "″"
+        } else {
+            "′"
+        }
     }
 
     /// Which character should be used as a fallback quote.
     fn fallback(&self, double: bool) -> &'static str {
-        if double { "\"" } else { "’" }
+        if double {
+            "\""
+        } else {
+            "’"
+        }
     }
 }
 

library/src/text/shaping.rs

@@ -98,7 +98,6 @@ impl<'a> ShapedText<'a> {
             self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
         {
             let pos = Point::new(offset, top + shift + y_offset.at(self.size));
-
             let glyphs = group
                 .iter()
                 .map(|glyph| Glyph {
@@ -115,14 +114,7 @@ impl<'a> ShapedText<'a> {
                 })
                 .collect();
 
-            let text = Text {
+            let text = Text { font, size: self.size, lang, fill, glyphs };
-                font,
-                size: self.size,
-                lang,
-                fill,
-                glyphs,
-            };
-
             let text_layer = frame.layer();
             let width = text.width();
 
@@ -274,7 +266,11 @@ impl<'a> ShapedText<'a> {
             .glyphs
             .binary_search_by(|g| {
                 let ordering = g.cluster.cmp(&text_index);
-                if ltr { ordering } else { ordering.reverse() }
+                if ltr {
+                    ordering
+                } else {
+                    ordering.reverse()
+                }
             })
             .ok()?;
 
@@ -385,9 +381,7 @@ fn shape_segment<'a>(
     }
 
     // Extract the font id or shape notdef glyphs if we couldn't find any font.
-    let font = if let Some(font) = selection {
+    let Some(font) = selection else {
-        font
-    } else {
         if let Some(font) = ctx.used.first().cloned() {
             shape_tofus(ctx, base, text, font);
         }

library/src/text/shift.rs

@@ -78,10 +78,7 @@ fn search_text(content: &Content, mode: ShiftKind) -> Option<EcoString> {
     } else if content.is::<SpaceNode>() {
         Some(' '.into())
     } else if let Some(text) = content.downcast::<TextNode>() {
-        if let Some(sup) = convert_script(&text.0, mode) {
+        convert_script(&text.0, mode)
-            return Some(sup);
-        }
-        None
     } else if let Some(seq) = content.downcast::<SequenceNode>() {
         let mut full = EcoString::new();
         for item in seq.0.iter() {

macros/src/lib.rs

@@ -18,7 +18,8 @@ pub fn capability(_: TokenStream, item: TokenStream) -> TokenStream {
     quote! {
         #item_trait
         impl ::typst::model::Capability for dyn #name {}
-    }.into()
+    }
+    .into()
 }
 
 /// Implement `Node` for a struct.
@@ -349,10 +350,7 @@ fn parse_property(item: &mut syn::ImplItemConst) -> Result<Property> {
 
     let span = property.name.span();
     if property.skip && property.shorthand.is_some() {
-        return Err(Error::new(
+        return Err(Error::new(span, "skip and shorthand are mutually exclusive"));
-            span,
-            "skip and shorthand are mutually exclusive",
-        ));
     }
 
     if property.referenced && (property.fold || property.resolve) {

rustfmt.toml

@@ -1,11 +1,6 @@
-unstable_features = true
+use_small_heuristics = "Max"
-
+max_width = 90
-overflow_delimited_expr = true
+chain_width = 70
-spaces_around_ranges = true
+struct_lit_width = 50
 use_field_init_shorthand = true
 merge_derives = false
-
-max_width = 90
-struct_lit_width = 40
-chain_width = 70
-single_line_if_else_max_width = 60

src/export/mod.rs

@@ -3,5 +3,5 @@
 mod pdf;
 mod render;
 
-pub use pdf::pdf;
+pub use self::pdf::pdf;
-pub use render::render;
+pub use self::render::render;

src/export/render.rs

@@ -312,10 +312,7 @@ fn render_shape(
 
     if let Some(Stroke { paint, thickness }) = shape.stroke {
         let paint = paint.into();
-        let stroke = sk::Stroke {
+        let stroke = sk::Stroke { width: thickness.to_f32(), ..Default::default() };
-            width: thickness.to_f32(),
-            ..Default::default()
-        };
         canvas.stroke_path(&path, &paint, &stroke, ts, mask);
     }
 
@@ -342,11 +339,8 @@ fn render_image(
     match image.decode().unwrap() {
         DecodedImage::Raster(dynamic, _) => {
             let downscale = w < image.width();
-            let filter = if downscale {
+            let filter =
-                FilterType::Lanczos3
+                if downscale { FilterType::Lanczos3 } else { FilterType::CatmullRom };
-            } else {
-                FilterType::CatmullRom
-            };
             let buf = dynamic.resize(w, h, filter);
             for ((_, _, src), dest) in buf.pixels().zip(pixmap.pixels_mut()) {
                 let Rgba([r, g, b, a]) = src;

src/font/book.rs

@@ -305,9 +305,8 @@ fn typographic_family(mut family: &str) -> &str {
     const SEPARATORS: [char; 3] = [' ', '-', '_'];
 
     // Modifiers that can appear in combination with suffixes.
-    const MODIFIERS: &[&str] = &[
+    const MODIFIERS: &[&str] =
-        "extra", "ext", "ex", "x", "semi", "sem", "sm", "demi", "dem", "ultra",
+        &["extra", "ext", "ex", "x", "semi", "sem", "sm", "demi", "dem", "ultra"];
-    ];
 
     // Style suffixes.
     #[rustfmt::skip]
@@ -331,9 +330,8 @@ fn typographic_family(mut family: &str) -> &str {
         len = trimmed.len();
 
         // Find style suffix.
-        let mut t = match SUFFIXES.iter().find_map(|s| trimmed.strip_suffix(s)) {
+        let Some(mut t) = SUFFIXES.iter().find_map(|s| trimmed.strip_suffix(s)) else {
-            Some(t) => t,
+            break;
-            None => break,
         };
 
         // Strip optional separator.
@@ -432,19 +430,13 @@ mod tests {
         assert_eq!(typographic_family("eras bold"), "eras");
         assert_eq!(typographic_family("footlight mt light"), "footlight mt");
         assert_eq!(typographic_family("times new roman"), "times new roman");
-        assert_eq!(
+        assert_eq!(typographic_family("noto sans mono cond sembd"), "noto sans mono");
-            typographic_family("noto sans mono cond sembd"),
-            "noto sans mono"
-        );
         assert_eq!(typographic_family("noto serif SEMCOND sembd"), "noto serif");
         assert_eq!(typographic_family("crimson text"), "crimson text");
         assert_eq!(typographic_family("footlight light"), "footlight");
         assert_eq!(typographic_family("Noto Sans"), "Noto Sans");
         assert_eq!(typographic_family("Noto Sans Light"), "Noto Sans");
-        assert_eq!(
+        assert_eq!(typographic_family("Noto Sans Semicondensed Heavy"), "Noto Sans");
-            typographic_family("Noto Sans Semicondensed Heavy"),
-            "Noto Sans"
-        );
         assert_eq!(typographic_family("Familx"), "Familx");
         assert_eq!(typographic_family("Font Ultra"), "Font Ultra");
         assert_eq!(typographic_family("Font Ultra Bold"), "Font");

src/font/mod.rs

@@ -3,8 +3,8 @@
 mod book;
 mod variant;
 
-pub use book::*;
+pub use self::book::*;
-pub use variant::*;
+pub use self::variant::*;
 
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};

src/frame.rs

@@ -538,9 +538,6 @@ impl Role {
     pub fn is_weak(self) -> bool {
         // In Typst, all text is in a paragraph, so paragraph isn't very
         // descriptive.
-        matches!(
+        matches!(self, Self::Paragraph | Self::GenericBlock | Self::GenericInline)
-            self,
-            Self::Paragraph | Self::GenericBlock | Self::GenericInline
-        )
     }
 }

src/geom/axes.rs

@@ -54,10 +54,7 @@ impl<T> Axes<T> {
 
     /// Zip two instances into an instance over a tuple.
     pub fn zip<U>(self, other: Axes<U>) -> Axes<(T, U)> {
-        Axes {
+        Axes { x: (self.x, other.x), y: (self.y, other.y) }
-            x: (self.x, other.x),
-            y: (self.y, other.y),
-        }
     }
 
     /// Whether a condition is true for at least one of fields.
@@ -100,18 +97,12 @@ impl<T: Default> Axes<T> {
 impl<T: Ord> Axes<T> {
     /// The component-wise minimum of this and another instance.
     pub fn min(self, other: Self) -> Self {
-        Self {
+        Self { x: self.x.min(other.x), y: self.y.min(other.y) }
-            x: self.x.min(other.x),
-            y: self.y.min(other.y),
-        }
     }
 
     /// The component-wise minimum of this and another instance.
     pub fn max(self, other: Self) -> Self {
-        Self {
+        Self { x: self.x.max(other.x), y: self.y.max(other.y) }
-            x: self.x.max(other.x),
-            y: self.y.max(other.y),
-        }
     }
 }
 

src/geom/corners.rs

@@ -16,12 +16,7 @@ pub struct Corners<T> {
 impl<T> Corners<T> {
     /// Create a new instance from the four components.
     pub const fn new(top_left: T, top_right: T, bottom_right: T, bottom_left: T) -> Self {
-        Self {
+        Self { top_left, top_right, bottom_right, bottom_left }
-            top_left,
-            top_right,
-            bottom_right,
-            bottom_left,
-        }
     }
 
     /// Create an instance with four equal components.
@@ -66,12 +61,7 @@ impl<T> Corners<T> {
     /// An iterator over the corners, starting with the top left corner,
     /// clockwise.
     pub fn iter(&self) -> impl Iterator<Item = &T> {
-        [
+        [&self.top_left, &self.top_right, &self.bottom_right, &self.bottom_left]
-            &self.top_left,
-            &self.top_right,
-            &self.bottom_right,
-            &self.bottom_left,
-        ]
             .into_iter()
     }
 

src/geom/ellipse.rs

@@ -18,9 +18,5 @@ pub fn ellipse(size: Size, fill: Option<Paint>, stroke: Option<Stroke>) -> Shape
     path.cubic_to(point(rx, my), point(mx, ry), point(z, ry));
     path.cubic_to(point(-mx, ry), point(-rx, my), point(-rx, z));
 
-    Shape {
+    Shape { geometry: Geometry::Path(path), stroke, fill }
-        geometry: Geometry::Path(path),
-        stroke,
-        fill,
-    }
 }

src/geom/em.rs

@@ -45,7 +45,11 @@ impl Em {
     /// Convert to an absolute length at the given font size.
     pub fn at(self, font_size: Abs) -> Abs {
         let resolved = font_size * self.get();
-        if resolved.is_finite() { resolved } else { Abs::zero() }
+        if resolved.is_finite() {
+            resolved
+        } else {
+            Abs::zero()
+        }
     }
 }
 

src/geom/length.rs

@@ -92,10 +92,7 @@ impl Add for Length {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
-        Self {
+        Self { abs: self.abs + rhs.abs, em: self.em + rhs.em }
-            abs: self.abs + rhs.abs,
-            em: self.em + rhs.em,
-        }
     }
 }
 

src/geom/mod.rs

@@ -24,27 +24,27 @@ mod size;
 mod stroke;
 mod transform;
 
-pub use abs::*;
+pub use self::abs::*;
-pub use align::*;
+pub use self::align::*;
-pub use angle::*;
+pub use self::angle::*;
-pub use axes::*;
+pub use self::axes::*;
-pub use corners::*;
+pub use self::corners::*;
-pub use dir::*;
+pub use self::dir::*;
-pub use ellipse::*;
+pub use self::ellipse::*;
-pub use em::*;
+pub use self::em::*;
-pub use fr::*;
+pub use self::fr::*;
-pub use length::*;
+pub use self::length::*;
-pub use paint::*;
+pub use self::paint::*;
-pub use path::*;
+pub use self::path::*;
-pub use point::*;
+pub use self::point::*;
-pub use ratio::*;
+pub use self::ratio::*;
-pub use rel::*;
+pub use self::rel::*;
-pub use rounded::*;
+pub use self::rounded::*;
-pub use scalar::*;
+pub use self::scalar::*;
-pub use sides::*;
+pub use self::sides::*;
-pub use size::*;
+pub use self::size::*;
-pub use stroke::*;
+pub use self::stroke::*;
-pub use transform::*;
+pub use self::transform::*;
 
 use std::cmp::Ordering;
 use std::f64::consts::PI;
@@ -95,20 +95,12 @@ pub enum Geometry {
 impl Geometry {
     /// Fill the geometry without a stroke.
     pub fn filled(self, fill: Paint) -> Shape {
-        Shape {
+        Shape { geometry: self, fill: Some(fill), stroke: None }
-            geometry: self,
-            fill: Some(fill),
-            stroke: None,
-        }
     }
 
     /// Stroke the geometry without a fill.
     pub fn stroked(self, stroke: Stroke) -> Shape {
-        Shape {
+        Shape { geometry: self, fill: None, stroke: Some(stroke) }
-            geometry: self,
-            fill: None,
-            stroke: Some(stroke),
-        }
     }
 }
 

src/geom/paint.rs

@@ -324,12 +324,7 @@ impl CmykColor {
             round_u8(255.0 * (1.0 - c) * (1.0 - k))
         };
 
-        RgbaColor {
+        RgbaColor { r: f(self.c), g: f(self.m), b: f(self.y), a: 255 }
-            r: f(self.c),
-            g: f(self.m),
-            b: f(self.y),
-            a: 255,
-        }
     }
 
     /// Lighten this color by a factor.

src/geom/ratio.rs

@@ -46,7 +46,11 @@ impl Ratio {
     /// Return the ratio of the given `whole`.
     pub fn of<T: Numeric>(self, whole: T) -> T {
         let resolved = whole * self.get();
-        if resolved.is_finite() { resolved } else { T::zero() }
+        if resolved.is_finite() {
+            resolved
+        } else {
+            T::zero()
+        }
     }
 }
 

src/geom/rel.rs

@@ -128,10 +128,7 @@ impl<T: Numeric> Mul<f64> for Rel<T> {
     type Output = Self;
 
     fn mul(self, other: f64) -> Self::Output {
-        Self {
+        Self { rel: self.rel * other, abs: self.abs * other }
-            rel: self.rel * other,
-            abs: self.abs * other,
-        }
     }
 }
 
@@ -147,10 +144,7 @@ impl<T: Numeric> Div<f64> for Rel<T> {
     type Output = Self;
 
     fn div(self, other: f64) -> Self::Output {
-        Self {
+        Self { rel: self.rel / other, abs: self.abs / other }
-            rel: self.rel / other,
-            abs: self.abs / other,
-        }
     }
 }
 

src/geom/rounded.rs

@@ -21,11 +21,7 @@ pub fn rounded_rect(
     if !stroke.is_uniform() {
         for (path, stroke) in stroke_segments(size, radius, stroke) {
             if stroke.is_some() {
-                res.push(Shape {
+                res.push(Shape { geometry: Geometry::Path(path), fill: None, stroke });
-                    geometry: Geometry::Path(path),
-                    fill: None,
-                    stroke,
-                });
             }
         }
     }

src/model/args.rs

@@ -29,11 +29,7 @@ impl Args {
     pub fn new(span: Span, values: impl IntoIterator<Item = Value>) -> Self {
         let items = values
             .into_iter()
-            .map(|value| Arg {
+            .map(|value| Arg { span, name: None, value: Spanned::new(value, span) })
-                span,
-                name: None,
-                value: Spanned::new(value, span),
-            })
             .collect();
         Self { span, items }
     }

src/model/array.rs

@@ -287,11 +287,7 @@ impl Array {
 
     /// Resolve an index.
     fn locate(&self, index: i64) -> Option<usize> {
-        usize::try_from(if index >= 0 {
+        usize::try_from(if index >= 0 { index } else { self.len().checked_add(index)? })
-            index
-        } else {
-            self.len().checked_add(index)?
-        })
             .ok()
     }
 }

src/model/content.rs

@@ -161,10 +161,7 @@ impl Add for Content {
             return lhs;
         }
 
-        let seq = match (
+        let seq = match (lhs.downcast::<SequenceNode>(), rhs.downcast::<SequenceNode>()) {
-            lhs.downcast::<SequenceNode>(),
-            rhs.downcast::<SequenceNode>(),
-        ) {
             (Some(lhs), Some(rhs)) => lhs.0.iter().chain(&rhs.0).cloned().collect(),
             (Some(lhs), None) => lhs.0.iter().cloned().chain(iter::once(rhs)).collect(),
             (None, Some(rhs)) => iter::once(lhs).chain(rhs.0.iter().cloned()).collect(),

src/model/eval.rs

@@ -140,7 +140,6 @@ fn eval_markup(
                 vm.scopes.top.define(wrap.binding().take(), tail);
                 wrap.body().eval(vm)?.display(vm.world)
             }
-
             _ => node.eval(vm)?,
         });
 
@@ -369,10 +368,7 @@ impl Eval for ast::Frac {
     type Output = Content;
 
     fn eval(&self, vm: &mut Vm) -> SourceResult<Self::Output> {
-        Ok((vm.items.math_frac)(
+        Ok((vm.items.math_frac)(self.num().eval(vm)?, self.denom().eval(vm)?))
-            self.num().eval(vm)?,
-            self.denom().eval(vm)?,
-        ))
     }
 }
 
@@ -501,7 +497,6 @@ fn eval_code(
                 vm.scopes.top.define(wrap.binding().take(), tail);
                 wrap.body().eval(vm)?
             }
-
             _ => expr.eval(vm)?,
         };
 
@@ -676,18 +671,12 @@ impl Eval for ast::FieldAccess {
 
         Ok(match object {
             Value::Dict(dict) => dict.get(&field).at(span)?.clone(),
-
             Value::Content(node) => node
                 .to::<dyn Show>()
                 .and_then(|node| node.field(&field))
                 .ok_or_else(|| format!("unknown field {field:?}"))
                 .at(span)?,
-
+            v => bail!(self.target().span(), "cannot access field on {}", v.type_name()),
-            v => bail!(
-                self.target().span(),
-                "cannot access field on {}",
-                v.type_name()
-            ),
         })
     }
 }
@@ -706,7 +695,6 @@ impl Eval for ast::FuncCall {
                 let point = || Tracepoint::Call(func.name().map(Into::into));
                 func.call(vm, args).trace(vm.world, point, self.span())?
             }
-
             v => bail!(
                 self.callee().span(),
                 "expected callable or collection, found {}",

src/model/func.rs

@@ -32,12 +32,7 @@ impl Func {
         name: &'static str,
         func: fn(&mut Vm, &mut Args) -> SourceResult<Value>,
     ) -> Self {
-        Self(Arc::new(Repr::Native(Native {
+        Self(Arc::new(Repr::Native(Native { name, func, set: None, node: None })))
-            name,
-            func,
-            set: None,
-            node: None,
-        })))
     }
 
     /// Create a new function from a native rust node.
@@ -194,12 +189,15 @@ impl Closure {
 
         // Parse the arguments according to the parameter list.
         for (param, default) in &self.params {
-            scopes.top.define(param.clone(), match default {
+            scopes.top.define(
-                None => args.expect::<Value>(param)?,
+                param.clone(),
+                match default {
                     Some(default) => {
                         args.named::<Value>(param)?.unwrap_or_else(|| default.clone())
                     }
-            });
+                    None => args.expect::<Value>(param)?,
+                },
+            );
         }
 
         // Put the remaining arguments into the sink.

src/model/mod.rs

@@ -1,4 +1,4 @@
-//! Layout and computation model.
+//! Document and computation model.
 
 #[macro_use]
 mod items;
@@ -23,18 +23,18 @@ mod ops;
 mod scope;
 mod vm;
 
-pub use self::str::*;
-pub use args::*;
-pub use array::*;
-pub use cast::*;
-pub use content::*;
-pub use dict::*;
-pub use eval::*;
-pub use func::*;
-pub use items::*;
-pub use scope::*;
-pub use styles::*;
-pub use value::*;
-pub use vm::*;
-
 pub use typst_macros::{capability, node};
+
+pub use self::args::*;
+pub use self::array::*;
+pub use self::cast::*;
+pub use self::content::*;
+pub use self::dict::*;
+pub use self::eval::*;
+pub use self::func::*;
+pub use self::items::*;
+pub use self::scope::*;
+pub use self::str::*;
+pub use self::styles::*;
+pub use self::value::*;
+pub use self::vm::*;

src/model/ops.rs

@@ -103,18 +103,18 @@ pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> {
             if let (Some(&a), Some(&b)) =
                 (a.downcast::<GenAlign>(), b.downcast::<GenAlign>())
             {
-                if a.axis() != b.axis() {
+                if a.axis() == b.axis() {
-                    Value::dynamic(match a.axis() {
-                        Axis::X => Axes { x: a, y: b },
-                        Axis::Y => Axes { x: b, y: a },
-                    })
-                } else {
                     return Err(format!("cannot add two {:?} alignments", a.axis()));
                 }
-            } else {
+
+                return Ok(Value::dynamic(match a.axis() {
+                    Axis::X => Axes { x: a, y: b },
+                    Axis::Y => Axes { x: b, y: a },
+                }));
+            };
+
             mismatch!("cannot add {} and {}", a, b);
         }
-        }
 
         (a, b) => mismatch!("cannot add {} and {}", a, b),
     })
@@ -370,17 +370,11 @@ pub fn not_in(lhs: Value, rhs: Value) -> StrResult<Value> {
 
 /// Test for containment.
 pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
-    Some(match (lhs, rhs) {
+    match (lhs, rhs) {
-        (Str(a), Str(b)) => b.as_str().contains(a.as_str()),
+        (Str(a), Str(b)) => Some(b.as_str().contains(a.as_str())),
-        (Dyn(a), Str(b)) => {
+        (Dyn(a), Str(b)) => a.downcast::<Regex>().map(|regex| regex.is_match(b)),
-            if let Some(regex) = a.downcast::<Regex>() {
+        (Str(a), Dict(b)) => Some(b.contains(a)),
-                regex.is_match(b)
+        (a, Array(b)) => Some(b.contains(a)),
-            } else {
+        _ => Option::None,
-                return Option::None;
     }
 }
-        (Str(a), Dict(b)) => b.contains(a),
-        (a, Array(b)) => b.contains(a),
-        _ => return Option::None,
-    })
-}

src/model/str.rs

@@ -72,11 +72,7 @@ impl Str {
 
     /// Resolve an index.
     fn locate(&self, index: i64) -> Option<usize> {
-        usize::try_from(if index >= 0 {
+        usize::try_from(if index >= 0 { index } else { self.len().checked_add(index)? })
-            index
-        } else {
-            self.len().checked_add(index)?
-        })
             .ok()
     }
 
@@ -271,10 +267,7 @@ impl Str {
 /// The out of bounds access error message.
 #[cold]
 fn out_of_bounds(index: i64, len: i64) -> String {
-    format!(
+    format!("string index out of bounds (index: {}, len: {})", index, len)
-        "string index out of bounds (index: {}, len: {})",
-        index, len
-    )
 }
 
 /// Convert an item of std's `match_indices` to a dictionary.

src/model/styles.rs

@@ -159,10 +159,7 @@ impl StyleEntry {
             }
         }
 
-        StyleChain {
+        StyleChain { head: std::slice::from_ref(self), tail: Some(tail) }
-            head: std::slice::from_ref(self),
-            tail: Some(tail),
-        }
     }
 
     /// If this is a property, return it.
@@ -344,10 +341,7 @@ impl<'a> StyleChain<'a> {
 
     /// Iterate over the entries of the chain.
     fn entries(self) -> Entries<'a> {
-        Entries {
+        Entries { inner: [].as_slice().iter(), links: self.links() }
-            inner: [].as_slice().iter(),
-            links: self.links(),
-        }
     }
 
     /// Iterate over the links of the chain.
@@ -1066,11 +1060,7 @@ impl Recipe {
 
 impl Debug for Recipe {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(
+        write!(f, "Recipe matching {:?} from {:?}", self.pattern, self.func.span)
-            f,
-            "Recipe matching {:?} from {:?}",
-            self.pattern, self.func.span
-        )
     }
 }
 

src/model/value.rs

@@ -294,11 +294,8 @@ where
     }
 
     fn dyn_eq(&self, other: &Dynamic) -> bool {
-        if let Some(other) = other.downcast::<Self>() {
+        let Some(other) = other.downcast::<Self>() else { return false };
         self == other
-        } else {
-            false
-        }
     }
 
     fn dyn_type_name(&self) -> &'static str {
@@ -411,15 +408,9 @@ mod tests {
         test(Abs::pt(5.5), "5.5pt");
         test(Angle::deg(90.0), "90deg");
         test(Ratio::one() / 2.0, "50%");
-        test(
+        test(Ratio::new(0.3) + Length::from(Abs::cm(2.0)), "30% + 56.69pt");
-            Ratio::new(0.3) + Length::from(Abs::cm(2.0)),
-            "30% + 56.69pt",
-        );
         test(Fr::one() * 7.55, "7.55fr");
-        test(
+        test(Color::Rgba(RgbaColor::new(1, 1, 1, 0xff)), "rgb(\"#010101\")");
-            Color::Rgba(RgbaColor::new(1, 1, 1, 0xff)),
-            "rgb(\"#010101\")",
-        );
 
         // Collections.
         test("hello", r#""hello""#);

src/syntax/ast.rs

@@ -1471,7 +1471,11 @@ impl ForPattern {
     pub fn key(&self) -> Option<Ident> {
         let mut children = self.0.children().filter_map(SyntaxNode::cast);
         let key = children.next();
-        if children.next().is_some() { key } else { None }
+        if children.next().is_some() {
+            key
+        } else {
+            None
+        }
     }
 
     /// The value part of the pattern.

src/syntax/highlight.rs

@@ -421,20 +421,26 @@ mod tests {
 
         test("= *AB*", &[(0..6, Heading), (2..6, Strong)]);
 
-        test("#f(x + 1)", &[
+        test(
+            "#f(x + 1)",
+            &[
                 (0..2, Function),
                 (2..3, Bracket),
                 (5..6, Operator),
                 (7..8, Number),
                 (8..9, Bracket),
-        ]);
+            ],
+        );
 
-        test("#let f(x) = x", &[
+        test(
+            "#let f(x) = x",
+            &[
                 (0..4, Keyword),
                 (5..6, Function),
                 (6..7, Bracket),
                 (8..9, Bracket),
                 (10..11, Operator),
-        ]);
+            ],
+        );
     }
 }

src/syntax/incremental.rs

@@ -126,10 +126,13 @@ fn try_reparse(
     // If we were looking for a non-whitespace element and hit the end of
     // the file here, we instead use EOF as the end of the span.
     if let SearchState::RequireNonTrivia(start) = search {
-        search = SearchState::SpanFound(start, NodePos {
+        search = SearchState::SpanFound(
+            start,
+            NodePos {
                 idx: node.children().len() - 1,
                 offset: offset - node.children().last().unwrap().len(),
-        })
+            },
+        )
     }
 
     if let SearchState::Contained(pos) = search {
@@ -351,11 +354,7 @@ impl Ahead {
         Self {
             pos,
             at_start,
-            kind: if bounded {
+            kind: if bounded { AheadKind::Normal } else { AheadKind::Unbounded(true) },
-                AheadKind::Normal
-            } else {
-                AheadKind::Unbounded(true)
-            },
         }
     }
 

src/syntax/mod.rs

@@ -2,6 +2,7 @@
 
 pub mod ast;
 pub mod highlight;
+
 mod incremental;
 mod kind;
 mod node;
@@ -12,12 +13,12 @@ mod source;
 mod span;
 mod tokens;
 
-pub use kind::*;
+pub use self::kind::*;
-pub use node::*;
+pub use self::node::*;
-pub use parsing::*;
+pub use self::parsing::*;
-pub use source::*;
+pub use self::source::*;
-pub use span::*;
+pub use self::span::*;
-pub use tokens::*;
+pub use self::tokens::*;
 
 use incremental::reparse;
 use parser::*;

src/syntax/parser.rs

@@ -177,7 +177,11 @@ impl<'s> Parser<'s> {
 
     /// Peek at the current token without consuming it.
     pub fn peek(&self) -> Option<&NodeKind> {
-        if self.eof { None } else { self.current.as_ref() }
+        if self.eof {
+            None
+        } else {
+            self.current.as_ref()
+        }
     }
 
     /// Peek at the current token, but only if it follows immediately after the

src/syntax/parsing.rs

@@ -210,11 +210,7 @@ where
 
 /// Parse a markup node.
 fn markup_node(p: &mut Parser, at_start: &mut bool) {
-    let token = match p.peek() {
+    let Some(token) = p.peek() else { return };
-        Some(t) => t,
-        None => return,
-    };
-
     match token {
         // Whitespace.
         NodeKind::Space { newlines } => {
@@ -420,12 +416,9 @@ fn math_node_prec(p: &mut Parser, min_prec: usize, stop: Option<NodeKind>) {
             Some(NodeKind::Underscore) => {
                 (NodeKind::Script, 2, Assoc::Right, Some(NodeKind::Hat))
             }
-            Some(NodeKind::Hat) => (
+            Some(NodeKind::Hat) => {
-                NodeKind::Script,
+                (NodeKind::Script, 2, Assoc::Right, Some(NodeKind::Underscore))
-                2,
+            }
-                Assoc::Right,
-                Some(NodeKind::Underscore),
-            ),
             Some(NodeKind::Slash) => (NodeKind::Frac, 1, Assoc::Left, None),
             _ => break,
         };
@@ -454,11 +447,7 @@ fn math_node_prec(p: &mut Parser, min_prec: usize, stop: Option<NodeKind>) {
 
 /// Parse a primary math node.
 fn math_primary(p: &mut Parser) {
-    let token = match p.peek() {
+    let Some(token) = p.peek() else { return };
-        Some(t) => t,
-        None => return,
-    };
-
     match token {
         // Spaces, atoms and expressions.
         NodeKind::Space { .. }
@@ -652,7 +641,6 @@ fn literal(p: &mut Parser) -> bool {
             p.eat();
             true
         }
-
         _ => false,
     }
 }
@@ -724,21 +712,26 @@ enum CollectionKind {
 /// Returns the length of the collection and whether the literal contained any
 /// commas.
 fn collection(p: &mut Parser, keyed: bool) -> (CollectionKind, usize) {
-    let mut kind = None;
+    let mut collection_kind = None;
     let mut items = 0;
     let mut can_group = true;
     let mut missing_coma: Option<Marker> = None;
 
     while !p.eof() {
-        if let Ok(item_kind) = item(p, keyed) {
+        let Ok(item_kind) = item(p, keyed) else {
+            p.eat_if(NodeKind::Comma);
+            collection_kind = Some(CollectionKind::Group);
+            continue;
+        };
+
         match item_kind {
             NodeKind::Spread => can_group = false,
-                NodeKind::Named if kind.is_none() => {
+            NodeKind::Named if collection_kind.is_none() => {
-                    kind = Some(CollectionKind::Named);
+                collection_kind = Some(CollectionKind::Named);
                 can_group = false;
             }
-                _ if kind.is_none() => {
+            _ if collection_kind.is_none() => {
-                    kind = Some(CollectionKind::Positional);
+                collection_kind = Some(CollectionKind::Positional);
             }
             _ => {}
         }
@@ -758,16 +751,12 @@ fn collection(p: &mut Parser, keyed: bool) -> (CollectionKind, usize) {
         } else {
             missing_coma = Some(p.trivia_start());
         }
-        } else {
-            p.eat_if(NodeKind::Comma);
-            kind = Some(CollectionKind::Group);
-        }
     }
 
     let kind = if can_group && items == 1 {
         CollectionKind::Group
     } else {
-        kind.unwrap_or(CollectionKind::Positional)
+        collection_kind.unwrap_or(CollectionKind::Positional)
     };
 
     (kind, items)

src/syntax/resolve.rs

@@ -30,7 +30,6 @@ pub fn resolve_string(string: &str) -> EcoString {
                     None => out.push_str(s.from(start)),
                 }
             }
-
             _ => out.push_str(s.from(start)),
         }
     }
@@ -66,10 +65,7 @@ pub fn resolve_raw(column: usize, backticks: usize, text: &str) -> RawKind {
 /// Parse the lang tag and return it alongside the remaining inner raw text.
 fn split_at_lang_tag(raw: &str) -> (&str, &str) {
     let mut s = Scanner::new(raw);
-    (
+    (s.eat_until(|c: char| c == '`' || c.is_whitespace() || is_newline(c)), s.after())
-        s.eat_until(|c: char| c == '`' || c.is_whitespace() || is_newline(c)),
-        s.after(),
-    )
 }
 
 /// Trim raw text and splits it into lines.

src/syntax/source.rs

@@ -212,7 +212,6 @@ impl Source {
         (k == utf16_idx).then(|| self.text.len())
     }
 
-
     /// Return the byte position at which the given line starts.
     pub fn line_to_byte(&self, line_idx: usize) -> Option<usize> {
         self.lines.get(line_idx).map(|line| line.byte_idx)
@@ -312,10 +311,7 @@ fn lines(
             utf16_idx += 1;
         }
 
-        Some(Line {
+        Some(Line { byte_idx: byte_offset + s.cursor(), utf16_idx })
-            byte_idx: byte_offset + s.cursor(),
-            utf16_idx,
-        })
     })
 }
 
@@ -328,12 +324,15 @@ mod tests {
     #[test]
     fn test_source_file_new() {
         let source = Source::detached(TEST);
-        assert_eq!(source.lines, [
+        assert_eq!(
+            source.lines,
+            [
                 Line { byte_idx: 0, utf16_idx: 0 },
                 Line { byte_idx: 7, utf16_idx: 6 },
                 Line { byte_idx: 15, utf16_idx: 12 },
                 Line { byte_idx: 18, utf16_idx: 15 },
-        ]);
+            ]
+        );
     }
 
     #[test]

src/syntax/tokens.rs

@@ -558,9 +558,8 @@ impl<'s> Tokens<'s> {
             }
         }
 
-        let v = match number.parse::<f64>() {
+        let Ok(v) = number.parse::<f64>() else {
-            Ok(v) => v,
+            return NodeKind::Error(ErrorPos::Full, "invalid number".into());
-            Err(_) => return NodeKind::Error(ErrorPos::Full, "invalid number".into()),
         };
 
         match suffix {
@@ -653,7 +652,11 @@ fn column(string: &str, index: usize, offset: usize) -> usize {
         apply_offset = true;
     }
 
-    if apply_offset { res + offset } else { res }
+    if apply_offset {
+        res + offset
+    } else {
+        res
+    }
 }
 
 /// Whether this character denotes a newline.
@@ -767,8 +770,8 @@ mod tests {
     // - mode in which the suffix is applicable
     // - the suffix string
     // - the resulting suffix NodeKind
-    fn suffixes()
+    fn suffixes(
-    -> impl Iterator<Item = (char, Option<TokenMode>, &'static str, NodeKind)> {
+    ) -> impl Iterator<Item = (char, Option<TokenMode>, &'static str, NodeKind)> {
         [
             // Whitespace suffixes.
             (' ', None, " ", Space(0)),

src/util/fat.rs

@@ -5,7 +5,7 @@
 //! pointer metadata APIs are stable, we should definitely move to them:
 //! <https://github.com/rust-lang/rust/issues/81513>
 
-use std::alloc;
+use std::alloc::Layout;
 use std::mem;
 
 /// Create a fat pointer from a data address and a vtable address.
@@ -15,12 +15,8 @@ use std::mem;
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *const T {
-    debug_assert_eq!(
-        alloc::Layout::new::<*const T>(),
-        alloc::Layout::new::<FatPointer>(),
-    );
-
     let fat = FatPointer { data, vtable };
+    debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
     mem::transmute_copy::<FatPointer, *const T>(&fat)
 }
 
@@ -31,12 +27,8 @@ pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) -> *mut T {
-    debug_assert_eq!(
-        alloc::Layout::new::<*mut T>(),
-        alloc::Layout::new::<FatPointer>(),
-    );
-
     let fat = FatPointer { data, vtable };
+    debug_assert_eq!(Layout::new::<*mut T>(), Layout::new::<FatPointer>());
     mem::transmute_copy::<FatPointer, *mut T>(&fat)
 }
 
@@ -45,11 +37,7 @@ pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) ->
 /// # Safety
 /// Must only be called when `T` is a `dyn Trait`.
 pub unsafe fn vtable<T: ?Sized>(ptr: *const T) -> *const () {
-    debug_assert_eq!(
+    debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
-        alloc::Layout::new::<*const T>(),
-        alloc::Layout::new::<FatPointer>(),
-    );
-
     mem::transmute_copy::<*const T, FatPointer>(&ptr).vtable
 }
 

src/util/mod.rs

@@ -2,13 +2,13 @@
 
 pub mod fat;
 
-pub use buffer::Buffer;
-pub use eco::{format_eco, EcoString};
-
 #[macro_use]
 mod eco;
 mod buffer;
 
+pub use buffer::Buffer;
+pub use eco::{format_eco, EcoString};
+
 use std::any::TypeId;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::Hash;

tests/src/tests.rs

@@ -75,13 +75,8 @@ fn main() {
         let pdf_path =
             args.pdf.then(|| Path::new(PDF_DIR).join(path).with_extension("pdf"));
 
-        ok += test(
+        ok += test(&mut world, &src_path, &png_path, &ref_path, pdf_path.as_deref())
-            &mut world,
+            as usize;
-            &src_path,
-            &png_path,
-            &ref_path,
-            pdf_path.as_deref(),
-        ) as usize;
     }
 
     if len > 1 {
@@ -153,10 +148,8 @@ fn config() -> Config {
     let mut styles = typst_library::styles();
     styles.set(PageNode::WIDTH, Smart::Custom(Abs::pt(120.0).into()));
     styles.set(PageNode::HEIGHT, Smart::Auto);
-    styles.set(
+    styles
-        PageNode::MARGINS,
+        .set(PageNode::MARGINS, Sides::splat(Some(Smart::Custom(Abs::pt(10.0).into()))));
-        Sides::splat(Some(Smart::Custom(Abs::pt(10.0).into()))),
-    );
     styles.set(TextNode::SIZE, TextSize(Abs::pt(10.0).into()));
 
     // Hook up helpers into the global scope.
@@ -480,12 +473,6 @@ fn parse_metadata(source: &Source) -> (Option<bool>, Vec<(Range<usize>, String)>
             compare_ref = Some(true);
         }
 
-        let rest = if let Some(rest) = line.strip_prefix("// Error: ") {
-            rest
-        } else {
-            continue;
-        };
-
         fn num(s: &mut Scanner) -> usize {
             s.eat_while(char::is_numeric).parse().unwrap()
         }
@@ -501,6 +488,7 @@ fn parse_metadata(source: &Source) -> (Option<bool>, Vec<(Range<usize>, String)>
             source.line_column_to_byte(line, column).unwrap()
         };
 
+        let Some(rest) = line.strip_prefix("// Error: ") else { continue };
         let mut s = Scanner::new(rest);
         let start = pos(&mut s);
         let end = if s.eat_if('-') { pos(&mut s) } else { start };
@@ -582,10 +570,7 @@ fn test_reparse(text: &str, i: usize, rng: &mut LinearShift) -> bool {
             );
             println!("    Expected reference tree:\n{ref_root:#?}\n");
             println!("    Found incremental tree:\n{incr_root:#?}");
-            println!(
+            println!("    Full source ({}):\n\"{edited_src:?}\"", edited_src.len());
-                "    Full source ({}):\n\"{edited_src:?}\"",
-                edited_src.len()
-            );
         }
 
         ok &= test_spans(ref_root);
@@ -630,10 +615,7 @@ fn test_spans(root: &SyntaxNode) -> bool {
 fn test_spans_impl(node: &SyntaxNode, within: Range<u64>) -> bool {
     if !within.contains(&node.span().number()) {
         eprintln!("    Node: {node:#?}");
-        eprintln!(
+        eprintln!("    Wrong span order: {} not in {within:?} ❌", node.span().number(),);
-            "    Wrong span order: {} not in {within:?} ❌",
-            node.span().number(),
-        );
     }
 
     let start = node.span().number() + 1;