Style changes

41 files changed, 325 insertions, 451 deletions

diff --git a/src/diag.rs b/src/diag.rs
index 0a532713..7631b6d3 100644
--- a/src/diag.rs
+++ b/src/diag.rs
@@ -85,8 +85,8 @@ impl SourceError {
         let full = world.source(self.span.source()).range(self.span);
         match self.pos {
             ErrorPos::Full => full,
-            ErrorPos::Start => full.start .. full.start,
-            ErrorPos::End => full.end .. full.end,
+            ErrorPos::Start => full.start..full.start,
+            ErrorPos::End => full.end..full.end,
         }
     }
 }
diff --git a/src/export/mod.rs b/src/export/mod.rs
index 8e18174d..eb0731a9 100644
--- a/src/export/mod.rs
+++ b/src/export/mod.rs
@@ -3,5 +3,5 @@
 mod pdf;
 mod render;
 
-pub use pdf::pdf;
-pub use render::render;
+pub use self::pdf::pdf;
+pub use self::render::render;
diff --git a/src/export/pdf/mod.rs b/src/export/pdf/mod.rs
index 5f47043e..2547ddbf 100644
--- a/src/export/pdf/mod.rs
+++ b/src/export/pdf/mod.rs
@@ -174,7 +174,7 @@ where
         &'a self,
         refs: &'a [Ref],
     ) -> impl Iterator<Item = (Ref, usize)> + 'a {
-        refs.iter().copied().zip(0 .. self.to_pdf.len())
+        refs.iter().copied().zip(0..self.to_pdf.len())
     }
 
     fn items(&self) -> impl Iterator<Item = &T> + '_ {
diff --git a/src/export/render.rs b/src/export/render.rs
index 41fff863..bc82e9c8 100644
--- a/src/export/render.rs
+++ b/src/export/render.rs
@@ -256,8 +256,8 @@ fn render_outline_glyph(
     // Blend the glyph bitmap with the existing pixels on the canvas.
     // FIXME: This doesn't respect the clipping mask.
     let pixels = bytemuck::cast_slice_mut::<u8, u32>(canvas.data_mut());
-    for x in left.clamp(0, cw) .. right.clamp(0, cw) {
-        for y in top.clamp(0, ch) .. bottom.clamp(0, ch) {
+    for x in left.clamp(0, cw)..right.clamp(0, cw) {
+        for y in top.clamp(0, ch)..bottom.clamp(0, ch) {
             let ai = ((y - top) * mw + (x - left)) as usize;
             let cov = bitmap.coverage[ai];
             if cov == 0 {
@@ -312,10 +312,7 @@ fn render_shape(
 
     if let Some(Stroke { paint, thickness }) = shape.stroke {
         let paint = paint.into();
-        let stroke = sk::Stroke {
-            width: thickness.to_f32(),
-            ..Default::default()
-        };
+        let stroke = sk::Stroke { 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 {
-                FilterType::Lanczos3
-            } else {
-                FilterType::CatmullRom
-            };
+            let filter =
+                if downscale { FilterType::Lanczos3 } 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;
diff --git a/src/font/book.rs b/src/font/book.rs
index 49225c04..2ad30f1d 100644
--- a/src/font/book.rs
+++ b/src/font/book.rs
@@ -172,7 +172,7 @@ impl FontInfo {
     /// Compute metadata for all fonts in the given data.
     pub fn from_data(data: &[u8]) -> impl Iterator<Item = FontInfo> + '_ {
         let count = ttf_parser::fonts_in_collection(data).unwrap_or(1);
-        (0 .. count).filter_map(move |index| {
+        (0..count).filter_map(move |index| {
             let ttf = ttf_parser::Face::parse(data, index).ok()?;
             Self::from_ttf(&ttf)
         })
@@ -241,9 +241,9 @@ impl FontInfo {
         if let Some(panose) = ttf
             .raw_face()
             .table(Tag::from_bytes(b"OS/2"))
-            .and_then(|os2| os2.get(32 .. 45))
+            .and_then(|os2| os2.get(32..45))
         {
-            if matches!(panose, [2, 2 ..= 10, ..]) {
+            if matches!(panose, [2, 2..=10, ..]) {
                 flags.insert(FontFlags::SERIF);
             }
         }
@@ -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] = &[
-        "extra", "ext", "ex", "x", "semi", "sem", "sm", "demi", "dem", "ultra",
-    ];
+    const MODIFIERS: &[&str] =
+        &["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)) {
-            Some(t) => t,
-            None => break,
+        let Some(mut t) = SUFFIXES.iter().find_map(|s| trimmed.strip_suffix(s)) else {
+            break;
         };
 
         // Strip optional separator.
@@ -351,7 +349,7 @@ fn typographic_family(mut family: &str) -> &str {
         }
     }
 
-    &family[.. len]
+    &family[..len]
 }
 
 /// How many words the two strings share in their prefix.
@@ -411,7 +409,7 @@ impl Coverage {
         let mut cursor = 0;
 
         for &run in &self.0 {
-            if (cursor .. cursor + run).contains(&c) {
+            if (cursor..cursor + run).contains(&c) {
                 return inside;
             }
             cursor += run;
@@ -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!(
-            typographic_family("noto sans mono cond sembd"),
-            "noto sans mono"
-        );
+        assert_eq!(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!(
-            typographic_family("Noto Sans Semicondensed Heavy"),
-            "Noto Sans"
-        );
+        assert_eq!(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");
@@ -458,7 +450,7 @@ mod tests {
             assert_eq!(coverage.0, runs);
 
             let max = 5 + set.iter().copied().max().unwrap_or_default();
-            for c in 0 .. max {
+            for c in 0..max {
                 assert_eq!(set.contains(&c), coverage.contains(c));
             }
         }
diff --git a/src/font/mod.rs b/src/font/mod.rs
index 7cddf1ea..98875d8f 100644
--- a/src/font/mod.rs
+++ b/src/font/mod.rs
@@ -3,8 +3,8 @@
 mod book;
 mod variant;
 
-pub use book::*;
-pub use variant::*;
+pub use self::book::*;
+pub use self::variant::*;
 
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
diff --git a/src/frame.rs b/src/frame.rs
index 2eac6879..e2302d7c 100644
--- a/src/frame.rs
+++ b/src/frame.rs
@@ -153,7 +153,7 @@ impl Frame {
     where
         I: IntoIterator<Item = (Point, Element)>,
     {
-        Arc::make_mut(&mut self.elements).splice(0 .. 0, elements);
+        Arc::make_mut(&mut self.elements).splice(0..0, elements);
     }
 
     /// Add a frame at a position in the background.
@@ -181,7 +181,7 @@ impl Frame {
 
         // Try to transfer the elements without adjusting the position.
         // Also try to reuse the elements if the Arc isn't shared.
-        let range = layer .. layer;
+        let range = layer..layer;
         if pos.is_zero() {
             let sink = Arc::make_mut(&mut self.elements);
             match Arc::try_unwrap(frame.elements) {
@@ -407,7 +407,7 @@ impl Lang {
 
     /// Return the language code as an all lowercase string slice.
     pub fn as_str(&self) -> &str {
-        std::str::from_utf8(&self.0[.. usize::from(self.1)]).unwrap_or_default()
+        std::str::from_utf8(&self.0[..usize::from(self.1)]).unwrap_or_default()
     }
 
     /// The default direction for the language.
@@ -426,9 +426,9 @@ impl FromStr for Lang {
     /// Construct a language from a two- or three-byte ISO 639-1/2/3 code.
     fn from_str(iso: &str) -> Result<Self, Self::Err> {
         let len = iso.len();
-        if matches!(len, 2 ..= 3) && iso.is_ascii() {
+        if matches!(len, 2..=3) && iso.is_ascii() {
             let mut bytes = [b' '; 3];
-            bytes[.. len].copy_from_slice(iso.as_bytes());
+            bytes[..len].copy_from_slice(iso.as_bytes());
             bytes.make_ascii_lowercase();
             Ok(Self(bytes, len as u8))
         } else {
@@ -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!(
-            self,
-            Self::Paragraph | Self::GenericBlock | Self::GenericInline
-        )
+        matches!(self, Self::Paragraph | Self::GenericBlock | Self::GenericInline)
     }
 }
diff --git a/src/geom/axes.rs b/src/geom/axes.rs
index bfc40c2e..04023898 100644
--- a/src/geom/axes.rs
+++ b/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 {
-            x: (self.x, other.x),
-            y: (self.y, other.y),
-        }
+        Axes { 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 {
-            x: self.x.min(other.x),
-            y: self.y.min(other.y),
-        }
+        Self { 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 {
-            x: self.x.max(other.x),
-            y: self.y.max(other.y),
-        }
+        Self { x: self.x.max(other.x), y: self.y.max(other.y) }
     }
 }
 
diff --git a/src/geom/corners.rs b/src/geom/corners.rs
index 54fcd12f..d84160cc 100644
--- a/src/geom/corners.rs
+++ b/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 {
-            top_left,
-            top_right,
-            bottom_right,
-            bottom_left,
-        }
+        Self { top_left, top_right, bottom_right, bottom_left }
     }
 
     /// Create an instance with four equal components.
@@ -66,13 +61,8 @@ 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,
-        ]
-        .into_iter()
+        [&self.top_left, &self.top_right, &self.bottom_right, &self.bottom_left]
+            .into_iter()
     }
 
     /// Whether all sides are equal.
diff --git a/src/geom/ellipse.rs b/src/geom/ellipse.rs
index e734682e..ac20ffd3 100644
--- a/src/geom/ellipse.rs
+++ b/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 {
-        geometry: Geometry::Path(path),
-        stroke,
-        fill,
-    }
+    Shape { geometry: Geometry::Path(path), stroke, fill }
 }
diff --git a/src/geom/em.rs b/src/geom/em.rs
index d0ad9d98..93dc80e4 100644
--- a/src/geom/em.rs
+++ b/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()
+        }
     }
 }
 
diff --git a/src/geom/length.rs b/src/geom/length.rs
index cd526f99..230ea48b 100644
--- a/src/geom/length.rs
+++ b/src/geom/length.rs
@@ -92,10 +92,7 @@ impl Add for Length {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            abs: self.abs + rhs.abs,
-            em: self.em + rhs.em,
-        }
+        Self { abs: self.abs + rhs.abs, em: self.em + rhs.em }
     }
 }
 
diff --git a/src/geom/mod.rs b/src/geom/mod.rs
index c1469b26..3c7c2fc9 100644
--- a/src/geom/mod.rs
+++ b/src/geom/mod.rs
@@ -24,27 +24,27 @@ mod size;
 mod stroke;
 mod transform;
 
-pub use abs::*;
-pub use align::*;
-pub use angle::*;
-pub use axes::*;
-pub use corners::*;
-pub use dir::*;
-pub use ellipse::*;
-pub use em::*;
-pub use fr::*;
-pub use length::*;
-pub use paint::*;
-pub use path::*;
-pub use point::*;
-pub use ratio::*;
-pub use rel::*;
-pub use rounded::*;
-pub use scalar::*;
-pub use sides::*;
-pub use size::*;
-pub use stroke::*;
-pub use transform::*;
+pub use self::abs::*;
+pub use self::align::*;
+pub use self::angle::*;
+pub use self::axes::*;
+pub use self::corners::*;
+pub use self::dir::*;
+pub use self::ellipse::*;
+pub use self::em::*;
+pub use self::fr::*;
+pub use self::length::*;
+pub use self::paint::*;
+pub use self::path::*;
+pub use self::point::*;
+pub use self::ratio::*;
+pub use self::rel::*;
+pub use self::rounded::*;
+pub use self::scalar::*;
+pub use self::sides::*;
+pub use self::size::*;
+pub use self::stroke::*;
+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 {
-            geometry: self,
-            fill: Some(fill),
-            stroke: None,
-        }
+        Shape { geometry: self, fill: Some(fill), stroke: None }
     }
 
     /// Stroke the geometry without a fill.
     pub fn stroked(self, stroke: Stroke) -> Shape {
-        Shape {
-            geometry: self,
-            fill: None,
-            stroke: Some(stroke),
-        }
+        Shape { geometry: self, fill: None, stroke: Some(stroke) }
     }
 }
 
diff --git a/src/geom/paint.rs b/src/geom/paint.rs
index b07f09af..58b034ae 100644
--- a/src/geom/paint.rs
+++ b/src/geom/paint.rs
@@ -244,11 +244,11 @@ impl FromStr for RgbaColor {
         }
 
         let mut values: [u8; 4] = [u8::MAX; 4];
-        for elem in if alpha { 0 .. 4 } else { 0 .. 3 } {
+        for elem in if alpha { 0..4 } else { 0..3 } {
             let item_len = if long { 2 } else { 1 };
             let pos = elem * item_len;
 
-            let item = &hex_str[pos .. (pos + item_len)];
+            let item = &hex_str[pos..(pos + item_len)];
             values[elem] = u8::from_str_radix(item, 16).unwrap();
 
             if short {
@@ -324,12 +324,7 @@ impl CmykColor {
             round_u8(255.0 * (1.0 - c) * (1.0 - k))
         };
 
-        RgbaColor {
-            r: f(self.c),
-            g: f(self.m),
-            b: f(self.y),
-            a: 255,
-        }
+        RgbaColor { r: f(self.c), g: f(self.m), b: f(self.y), a: 255 }
     }
 
     /// Lighten this color by a factor.
diff --git a/src/geom/ratio.rs b/src/geom/ratio.rs
index 69f06dd2..5c58649d 100644
--- a/src/geom/ratio.rs
+++ b/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()
+        }
     }
 }
 
diff --git a/src/geom/rel.rs b/src/geom/rel.rs
index 5c3b0b43..a8e75d1c 100644
--- a/src/geom/rel.rs
+++ b/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 {
-            rel: self.rel * other,
-            abs: self.abs * other,
-        }
+        Self { 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 {
-            rel: self.rel / other,
-            abs: self.abs / other,
-        }
+        Self { rel: self.rel / other, abs: self.abs / other }
     }
 }
 
diff --git a/src/geom/rounded.rs b/src/geom/rounded.rs
index 70d351ee..7a58dae2 100644
--- a/src/geom/rounded.rs
+++ b/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 {
-                    geometry: Geometry::Path(path),
-                    fill: None,
-                    stroke,
-                });
+                res.push(Shape { geometry: Geometry::Path(path), fill: None, stroke });
             }
         }
     }
diff --git a/src/model/args.rs b/src/model/args.rs
index 9fb30b9c..fe5f8254 100644
--- a/src/model/args.rs
+++ b/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 {
-                span,
-                name: None,
-                value: Spanned::new(value, span),
-            })
+            .map(|value| Arg { span, name: None, value: Spanned::new(value, span) })
             .collect();
         Self { span, items }
     }
diff --git a/src/model/array.rs b/src/model/array.rs
index 053248ec..40b063e2 100644
--- a/src/model/array.rs
+++ b/src/model/array.rs
@@ -119,7 +119,7 @@ impl Array {
             .ok_or_else(|| out_of_bounds(end, len))?
             .max(start);
 
-        Ok(Self::from_vec(self.0[start .. end].to_vec()))
+        Ok(Self::from_vec(self.0[start..end].to_vec()))
     }
 
     /// Whether the array contains a specific value.
@@ -287,12 +287,8 @@ impl Array {
 
     /// Resolve an index.
     fn locate(&self, index: i64) -> Option<usize> {
-        usize::try_from(if index >= 0 {
-            index
-        } else {
-            self.len().checked_add(index)?
-        })
-        .ok()
+        usize::try_from(if index >= 0 { index } else { self.len().checked_add(index)? })
+            .ok()
     }
 }
 
diff --git a/src/model/content.rs b/src/model/content.rs
index 372f6ff6..7b09c697 100644
--- a/src/model/content.rs
+++ b/src/model/content.rs
@@ -161,10 +161,7 @@ impl Add for Content {
             return lhs;
         }
 
-        let seq = match (
-            lhs.downcast::<SequenceNode>(),
-            rhs.downcast::<SequenceNode>(),
-        ) {
+        let seq = match (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(),
diff --git a/src/model/eval.rs b/src/model/eval.rs
index 8e287f14..16e66818 100644
--- a/src/model/eval.rs
+++ b/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)?,
         });
 
@@ -162,7 +161,7 @@ impl Eval for ast::MarkupNode {
     fn eval(&self, vm: &mut Vm) -> SourceResult<Self::Output> {
         match self {
             Self::Space(v) => Ok(match v.newlines() {
-                0 ..= 1 => (vm.items.space)(),
+                0..=1 => (vm.items.space)(),
                 _ => (vm.items.parbreak)(),
             }),
             Self::Linebreak(v) => v.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)(
-            self.num().eval(vm)?,
-            self.denom().eval(vm)?,
-        ))
+        Ok((vm.items.math_frac)(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 {}",
diff --git a/src/model/func.rs b/src/model/func.rs
index 5be1aae3..456b6aa6 100644
--- a/src/model/func.rs
+++ b/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 {
-            name,
-            func,
-            set: None,
-            node: None,
-        })))
+        Self(Arc::new(Repr::Native(Native { name, func, set: None, node: None })))
     }
 
     /// Create a new function from a native rust node.
@@ -92,7 +87,7 @@ impl Func {
             Repr::Native(native) => (native.func)(vm, &mut args)?,
             Repr::Closure(closure) => closure.call(vm, &mut args)?,
             Repr::With(wrapped, applied) => {
-                args.items.splice(.. 0, applied.items.iter().cloned());
+                args.items.splice(..0, applied.items.iter().cloned());
                 return wrapped.call(vm, args);
             }
         };
@@ -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 {
-                None => args.expect::<Value>(param)?,
-                Some(default) => {
-                    args.named::<Value>(param)?.unwrap_or_else(|| default.clone())
-                }
-            });
+            scopes.top.define(
+                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.
diff --git a/src/model/mod.rs b/src/model/mod.rs
index fdebce0a..20bca106 100644
--- a/src/model/mod.rs
+++ b/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::*;
diff --git a/src/model/ops.rs b/src/model/ops.rs
index ee126b03..9d55fa63 100644
--- a/src/model/ops.rs
+++ b/src/model/ops.rs
@@ -103,17 +103,17 @@ 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() {
-                    Value::dynamic(match a.axis() {
-                        Axis::X => Axes { x: a, y: b },
-                        Axis::Y => Axes { x: b, y: a },
-                    })
-                } else {
+                if a.axis() == b.axis() {
                     return Err(format!("cannot add two {:?} alignments", a.axis()));
                 }
-            } else {
-                mismatch!("cannot add {} and {}", a, b);
-            }
+
+                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) {
-        (Str(a), Str(b)) => b.as_str().contains(a.as_str()),
-        (Dyn(a), Str(b)) => {
-            if let Some(regex) = a.downcast::<Regex>() {
-                regex.is_match(b)
-            } else {
-                return Option::None;
-            }
-        }
-        (Str(a), Dict(b)) => b.contains(a),
-        (a, Array(b)) => b.contains(a),
-        _ => return Option::None,
-    })
+    match (lhs, rhs) {
+        (Str(a), Str(b)) => Some(b.as_str().contains(a.as_str())),
+        (Dyn(a), Str(b)) => a.downcast::<Regex>().map(|regex| regex.is_match(b)),
+        (Str(a), Dict(b)) => Some(b.contains(a)),
+        (a, Array(b)) => Some(b.contains(a)),
+        _ => Option::None,
+    }
 }
diff --git a/src/model/str.rs b/src/model/str.rs
index 4aa40c54..1fcf7075 100644
--- a/src/model/str.rs
+++ b/src/model/str.rs
@@ -67,17 +67,13 @@ impl Str {
             .ok_or_else(|| out_of_bounds(end, len))?
             .max(start);
 
-        Ok(self.0[start .. end].into())
+        Ok(self.0[start..end].into())
     }
 
     /// Resolve an index.
     fn locate(&self, index: i64) -> Option<usize> {
-        usize::try_from(if index >= 0 {
-            index
-        } else {
-            self.len().checked_add(index)?
-        })
-        .ok()
+        usize::try_from(if index >= 0 { index } else { self.len().checked_add(index)? })
+            .ok()
     }
 
     /// Whether the given pattern exists in this string.
@@ -207,7 +203,7 @@ impl Str {
             Some(StrPattern::Regex(re)) => {
                 let s = self.as_str();
                 let mut last = 0;
-                let mut range = 0 .. s.len();
+                let mut range = 0..s.len();
 
                 for m in re.find_iter(s) {
                     // Does this match follow directly after the last one?
@@ -235,7 +231,7 @@ impl Str {
                     range.end = s.len();
                 }
 
-                &s[range.start .. range.start.max(range.end)]
+                &s[range.start..range.start.max(range.end)]
             }
         };
 
@@ -271,10 +267,7 @@ impl Str {
 /// The out of bounds access error message.
 #[cold]
 fn out_of_bounds(index: i64, len: i64) -> String {
-    format!(
-        "string index out of bounds (index: {}, len: {})",
-        index, len
-    )
+    format!("string index out of bounds (index: {}, len: {})", index, len)
 }
 
 /// Convert an item of std's `match_indices` to a dictionary.
diff --git a/src/model/styles.rs b/src/model/styles.rs
index 24566b09..9463e55e 100644
--- a/src/model/styles.rs
+++ b/src/model/styles.rs
@@ -94,7 +94,7 @@ impl StyleMap {
     /// This is useful over `chain` when you want to combine two maps, but you
     /// still need an owned map without a lifetime.
     pub fn apply_map(&mut self, tail: &Self) {
-        self.0.splice(0 .. 0, tail.0.iter().cloned());
+        self.0.splice(0..0, tail.0.iter().cloned());
     }
 
     /// Mark all contained properties as _scoped_. This means that they only
@@ -159,10 +159,7 @@ impl StyleEntry {
             }
         }
 
-        StyleChain {
-            head: std::slice::from_ref(self),
-            tail: Some(tail),
-        }
+        StyleChain { head: std::slice::from_ref(self), tail: Some(tail) }
     }
 
     /// If this is a property, return it.
@@ -328,7 +325,7 @@ impl<'a> StyleChain<'a> {
         let mut suffix = StyleMap::new();
         let take = self.links().count().saturating_sub(len);
         for link in self.links().take(take) {
-            suffix.0.splice(0 .. 0, link.iter().cloned());
+            suffix.0.splice(0..0, link.iter().cloned());
         }
         suffix
     }
@@ -344,10 +341,7 @@ impl<'a> StyleChain<'a> {
 
     /// Iterate over the entries of the chain.
     fn entries(self) -> Entries<'a> {
-        Entries {
-            inner: [].as_slice().iter(),
-            links: self.links(),
-        }
+        Entries { inner: [].as_slice().iter(), links: self.links() }
     }
 
     /// Iterate over the links of the chain.
@@ -582,12 +576,12 @@ impl<'a, T> StyleVecBuilder<'a, T> {
         for &(mut chain, _) in iter {
             let len = chain.links().count();
             if len < shared {
-                for _ in 0 .. shared - len {
+                for _ in 0..shared - len {
                     trunk.pop();
                 }
                 shared = len;
             } else if len > shared {
-                for _ in 0 .. len - shared {
+                for _ in 0..len - shared {
                     chain.pop();
                 }
             }
@@ -1017,7 +1011,7 @@ impl Recipe {
                 for mat in regex.find_iter(text) {
                     let start = mat.start();
                     if cursor < start {
-                        result.push(make(text[cursor .. start].into()));
+                        result.push(make(text[cursor..start].into()));
                     }
 
                     result.push(self.call(world, || Value::Str(mat.as_str().into()))?);
@@ -1029,7 +1023,7 @@ impl Recipe {
                 }
 
                 if cursor < text.len() {
-                    result.push(make(text[cursor ..].into()));
+                    result.push(make(text[cursor..].into()));
                 }
 
                 Content::sequence(result)
@@ -1066,11 +1060,7 @@ impl Recipe {
 
 impl Debug for Recipe {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Recipe matching {:?} from {:?}",
-            self.pattern, self.func.span
-        )
+        write!(f, "Recipe matching {:?} from {:?}", self.pattern, self.func.span)
     }
 }
 
diff --git a/src/model/value.rs b/src/model/value.rs
index 07719883..825e6f55 100644
--- a/src/model/value.rs
+++ b/src/model/value.rs
@@ -294,11 +294,8 @@ where
     }
 
     fn dyn_eq(&self, other: &Dynamic) -> bool {
-        if let Some(other) = other.downcast::<Self>() {
-            self == other
-        } else {
-            false
-        }
+        let Some(other) = other.downcast::<Self>() else { return false };
+        self == other
     }
 
     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(
-            Ratio::new(0.3) + Length::from(Abs::cm(2.0)),
-            "30% + 56.69pt",
-        );
+        test(Ratio::new(0.3) + Length::from(Abs::cm(2.0)), "30% + 56.69pt");
         test(Fr::one() * 7.55, "7.55fr");
-        test(
-            Color::Rgba(RgbaColor::new(1, 1, 1, 0xff)),
-            "rgb(\"#010101\")",
-        );
+        test(Color::Rgba(RgbaColor::new(1, 1, 1, 0xff)), "rgb(\"#010101\")");
 
         // Collections.
         test("hello", r#""hello""#);
diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
index 06e41fa0..61b8f0e6 100644
--- a/src/syntax/ast.rs
+++ b/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.
diff --git a/src/syntax/highlight.rs b/src/syntax/highlight.rs
index 0db45785..d5345fab 100644
--- a/src/syntax/highlight.rs
+++ b/src/syntax/highlight.rs
@@ -81,7 +81,7 @@ where
         F: FnMut(Range<usize>, Style),
     {
         if node.children().len() == 0 {
-            let range = offset .. offset + node.len();
+            let range = offset..offset + node.len();
             let style = highlighter.style_for_stack(&scopes);
             f(range, style);
             return;
@@ -112,7 +112,7 @@ where
         F: FnMut(Range<usize>, Category),
     {
         for (i, child) in node.children().enumerate() {
-            let span = offset .. offset + child.len();
+            let span = offset..offset + child.len();
             if range.start <= span.end && range.end >= span.start {
                 if let Some(category) = Category::determine(child, node, i) {
                     f(span, category);
@@ -412,29 +412,35 @@ mod tests {
         fn test(text: &str, goal: &[(Range<usize>, Category)]) {
             let mut vec = vec![];
             let source = Source::detached(text);
-            let full = 0 .. text.len();
+            let full = 0..text.len();
             highlight_categories(source.root(), full, &mut |range, category| {
                 vec.push((range, category));
             });
             assert_eq!(vec, goal);
         }
 
-        test("= *AB*", &[(0 .. 6, Heading), (2 .. 6, Strong)]);
-
-        test("#f(x + 1)", &[
-            (0 .. 2, Function),
-            (2 .. 3, Bracket),
-            (5 .. 6, Operator),
-            (7 .. 8, Number),
-            (8 .. 9, Bracket),
-        ]);
-
-        test("#let f(x) = x", &[
-            (0 .. 4, Keyword),
-            (5 .. 6, Function),
-            (6 .. 7, Bracket),
-            (8 .. 9, Bracket),
-            (10 .. 11, Operator),
-        ]);
+        test("= *AB*", &[(0..6, Heading), (2..6, Strong)]);
+
+        test(
+            "#f(x + 1)",
+            &[
+                (0..2, Function),
+                (2..3, Bracket),
+                (5..6, Operator),
+                (7..8, Number),
+                (8..9, Bracket),
+            ],
+        );
+
+        test(
+            "#let f(x) = x",
+            &[
+                (0..4, Keyword),
+                (5..6, Function),
+                (6..7, Bracket),
+                (8..9, Bracket),
+                (10..11, Operator),
+            ],
+        );
     }
 }
diff --git a/src/syntax/incremental.rs b/src/syntax/incremental.rs
index 15c0df0c..1087bb79 100644
--- a/src/syntax/incremental.rs
+++ b/src/syntax/incremental.rs
@@ -28,7 +28,7 @@ pub fn reparse(
     let id = root.span().source();
     *root = parse(text);
     root.numberize(id, Span::FULL).unwrap();
-    0 .. text.len()
+    0..text.len()
 }
 
 /// Try to reparse inside the given node.
@@ -55,7 +55,7 @@ fn try_reparse(
     // Find the the first child in the range of children to reparse.
     for (i, child) in node.children().enumerate() {
         let pos = NodePos { idx: i, offset };
-        let child_span = offset .. offset + child.len();
+        let child_span = offset..offset + child.len();
         child_outermost = outermost && i + 1 == original_count;
 
         match search {
@@ -81,7 +81,7 @@ fn try_reparse(
                 } else {
                     // Update compulsary state of `ahead_nontrivia`.
                     if let Some(ahead_nontrivia) = ahead.as_mut() {
-                        if let NodeKind::Space { newlines: (1 ..) } = child.kind() {
+                        if let NodeKind::Space { newlines: (1..) } = child.kind() {
                             ahead_nontrivia.newline();
                         }
                     }
@@ -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 {
-            idx: node.children().len() - 1,
-            offset: offset - node.children().last().unwrap().len(),
-        })
+        search = SearchState::SpanFound(
+            start,
+            NodePos {
+                idx: node.children().len() - 1,
+                offset: offset - node.children().last().unwrap().len(),
+            },
+        )
     }
 
     if let SearchState::Contained(pos) = search {
@@ -156,7 +159,7 @@ fn try_reparse(
             return Some(range);
         }
 
-        let superseded_span = pos.offset .. pos.offset + prev_len;
+        let superseded_span = pos.offset..pos.offset + prev_len;
         let func: Option<ReparseMode> = match child.kind() {
             NodeKind::CodeBlock => Some(ReparseMode::Code),
             NodeKind::ContentBlock => Some(ReparseMode::Content),
@@ -170,7 +173,7 @@ fn try_reparse(
                 change,
                 node,
                 func,
-                pos.idx .. pos.idx + 1,
+                pos.idx..pos.idx + 1,
                 superseded_span,
                 outermost,
             ) {
@@ -197,13 +200,13 @@ fn try_reparse(
     }
 
     let superseded_span =
-        start.offset .. end.offset + node.children().as_slice()[end.idx].len();
+        start.offset..end.offset + node.children().as_slice()[end.idx].len();
 
     replace(
         change,
         node,
         ReparseMode::MarkupElements { at_start, min_indent },
-        start.idx .. end.idx + 1,
+        start.idx..end.idx + 1,
         superseded_span,
         outermost,
     )
@@ -223,33 +226,33 @@ fn replace(
     let differential: isize =
         change.replacement_len as isize - change.replaced.len() as isize;
     let newborn_end = (superseded_span.end as isize + differential) as usize;
-    let newborn_span = superseded_span.start .. newborn_end;
+    let newborn_span = superseded_span.start..newborn_end;
 
     let mut prefix = "";
-    for (i, c) in change.text[.. newborn_span.start].char_indices().rev() {
+    for (i, c) in change.text[..newborn_span.start].char_indices().rev() {
         if is_newline(c) {
             break;
         }
-        prefix = &change.text[i .. newborn_span.start];
+        prefix = &change.text[i..newborn_span.start];
     }
 
     let (newborns, terminated, amount) = match mode {
         ReparseMode::Code => reparse_code_block(
             prefix,
-            &change.text[newborn_span.start ..],
+            &change.text[newborn_span.start..],
             newborn_span.len(),
         ),
         ReparseMode::Content => reparse_content_block(
             prefix,
-            &change.text[newborn_span.start ..],
+            &change.text[newborn_span.start..],
             newborn_span.len(),
         ),
         ReparseMode::MarkupElements { at_start, min_indent } => reparse_markup_elements(
             prefix,
-            &change.text[newborn_span.start ..],
+            &change.text[newborn_span.start..],
             newborn_span.len(),
             differential,
-            &node.children().as_slice()[superseded_start ..],
+            &node.children().as_slice()[superseded_start..],
             at_start,
             min_indent,
         ),
@@ -261,7 +264,7 @@ fn replace(
         return None;
     }
 
-    node.replace_children(superseded_start .. superseded_start + amount, newborns)
+    node.replace_children(superseded_start..superseded_start + amount, newborns)
         .ok()?;
 
     Some(newborn_span)
@@ -351,11 +354,7 @@ impl Ahead {
         Self {
             pos,
             at_start,
-            kind: if bounded {
-                AheadKind::Normal
-            } else {
-                AheadKind::Unbounded(true)
-            },
+            kind: if bounded { AheadKind::Normal } else { AheadKind::Unbounded(true) },
         }
     }
 
@@ -402,7 +401,7 @@ fn is_bounded(kind: &NodeKind) -> bool {
 /// previous value of the property.
 fn next_at_start(kind: &NodeKind, prev: bool) -> bool {
     match kind {
-        NodeKind::Space { newlines: (1 ..) } => true,
+        NodeKind::Space { newlines: (1..) } => true,
         NodeKind::Space { .. } | NodeKind::LineComment | NodeKind::BlockComment => prev,
         _ => false,
     }
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
index 1a23db5f..2ef49322 100644
--- a/src/syntax/mod.rs
+++ b/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 node::*;
-pub use parsing::*;
-pub use source::*;
-pub use span::*;
-pub use tokens::*;
+pub use self::kind::*;
+pub use self::node::*;
+pub use self::parsing::*;
+pub use self::source::*;
+pub use self::span::*;
+pub use self::tokens::*;
 
 use incremental::reparse;
 use parser::*;
diff --git a/src/syntax/node.rs b/src/syntax/node.rs
index 4ec4abdf..5758a4bf 100644
--- a/src/syntax/node.rs
+++ b/src/syntax/node.rs
@@ -291,16 +291,16 @@ impl InnerNode {
         let mut start = within.start;
         if range.is_none() {
             let end = start + stride;
-            self.data.numberize(id, start .. end)?;
+            self.data.numberize(id, start..end)?;
             self.upper = within.end;
             start = end;
         }
 
         // Number the children.
         let len = self.children.len();
-        for child in &mut self.children[range.unwrap_or(0 .. len)] {
+        for child in &mut self.children[range.unwrap_or(0..len)] {
             let end = start + child.descendants() as u64 * stride;
-            child.numberize(id, start .. end)?;
+            child.numberize(id, start..end)?;
             start = end;
         }
 
@@ -377,8 +377,8 @@ impl InnerNode {
         // - or if we were erroneous before due to a non-superseded node.
         self.erroneous = replacement.iter().any(SyntaxNode::erroneous)
             || (self.erroneous
-                && (self.children[.. range.start].iter().any(SyntaxNode::erroneous))
-                || self.children[range.end ..].iter().any(SyntaxNode::erroneous));
+                && (self.children[..range.start].iter().any(SyntaxNode::erroneous))
+                || self.children[range.end..].iter().any(SyntaxNode::erroneous));
 
         // Perform the replacement.
         let replacement_count = replacement.len();
@@ -392,7 +392,7 @@ impl InnerNode {
         let max_left = range.start;
         let max_right = self.children.len() - range.end;
         loop {
-            let renumber = range.start - left .. range.end + right;
+            let renumber = range.start - left..range.end + right;
 
             // The minimum assignable number is either
             // - the upper bound of the node right before the to-be-renumbered
@@ -416,7 +416,7 @@ impl InnerNode {
                 .map_or(self.upper(), |next| next.span().number());
 
             // Try to renumber.
-            let within = start_number .. end_number;
+            let within = start_number..end_number;
             let id = self.span().source();
             if self.numberize(id, Some(renumber), within).is_ok() {
                 return Ok(());
@@ -529,7 +529,7 @@ impl NodeData {
 
     /// If the span points into this node, convert it to a byte range.
     fn range(&self, span: Span, offset: usize) -> Option<Range<usize>> {
-        (self.span == span).then(|| offset .. offset + self.len())
+        (self.span == span).then(|| offset..offset + self.len())
     }
 }
 
diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs
index 4c8e1013..8d51f7eb 100644
--- a/src/syntax/parser.rs
+++ b/src/syntax/parser.rs
@@ -97,7 +97,7 @@ impl<'s> Parser<'s> {
             // Trailing trivia should not be wrapped into the new node.
             let idx = self.children.len();
             self.children.push(SyntaxNode::default());
-            self.children.extend(children.drain(until.0 ..));
+            self.children.extend(children.drain(until.0..));
             self.children[idx] = InnerNode::with_children(kind, children).into();
         }
 
@@ -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
@@ -192,7 +196,7 @@ impl<'s> Parser<'s> {
 
     /// Peek at the source of the current token.
     pub fn peek_src(&self) -> &'s str {
-        self.get(self.current_start() .. self.current_end())
+        self.get(self.current_start()..self.current_end())
     }
 
     /// Obtain a range of the source code.
@@ -303,7 +307,7 @@ impl<'s> Parser<'s> {
             if group_mode != TokenMode::Markup {
                 let start = self.trivia_start().0;
                 target = self.current_start
-                    - self.children[start ..].iter().map(SyntaxNode::len).sum::<usize>();
+                    - self.children[start..].iter().map(SyntaxNode::len).sum::<usize>();
                 self.children.truncate(start);
             }
 
@@ -466,7 +470,7 @@ impl Marker {
     /// with the given `kind`.
     pub fn end(self, p: &mut Parser, kind: NodeKind) {
         let until = p.trivia_start().0.max(self.0);
-        let children = p.children.drain(self.0 .. until).collect();
+        let children = p.children.drain(self.0..until).collect();
         p.children
             .insert(self.0, InnerNode::with_children(kind, children).into());
     }
@@ -476,7 +480,7 @@ impl Marker {
     where
         F: FnMut(&SyntaxNode) -> Result<(), &'static str>,
     {
-        for child in &mut p.children[self.0 ..] {
+        for child in &mut p.children[self.0..] {
             // Don't expose errors.
             if child.kind().is_error() {
                 continue;
diff --git a/src/syntax/parsing.rs b/src/syntax/parsing.rs
index 10b4c4c2..fecc527c 100644
--- a/src/syntax/parsing.rs
+++ b/src/syntax/parsing.rs
@@ -90,7 +90,7 @@ pub(crate) fn reparse_markup_elements(
     let mut stopped = false;
 
     'outer: while !p.eof() {
-        if let Some(NodeKind::Space { newlines: (1 ..) }) = p.peek() {
+        if let Some(NodeKind::Space { newlines: (1..) }) = p.peek() {
             if p.column(p.current_end()) < min_indent {
                 return None;
             }
@@ -167,7 +167,7 @@ fn markup_indented(p: &mut Parser, min_indent: usize) {
 
     while !p.eof() {
         match p.peek() {
-            Some(NodeKind::Space { newlines: (1 ..) })
+            Some(NodeKind::Space { newlines: (1..) })
                 if p.column(p.current_end()) < min_indent =>
             {
                 break;
@@ -195,7 +195,7 @@ where
     p.perform(NodeKind::Markup { min_indent: usize::MAX }, |p| {
         let mut at_start = false;
         while let Some(kind) = p.peek() {
-            if let NodeKind::Space { newlines: (1 ..) } = kind {
+            if let NodeKind::Space { newlines: (1..) } = kind {
                 break;
             }
 
@@ -210,11 +210,7 @@ where
 
 /// Parse a markup node.
 fn markup_node(p: &mut Parser, at_start: &mut bool) {
-    let token = match p.peek() {
-        Some(t) => t,
-        None => return,
-    };
-
+    let Some(token) = p.peek() else { return };
     match token {
         // Whitespace.
         NodeKind::Space { newlines } => {
@@ -316,7 +312,7 @@ fn heading(p: &mut Parser, at_start: bool) {
         markup_line(p, |kind| matches!(kind, NodeKind::Label(_)));
         marker.end(p, NodeKind::Heading);
     } else {
-        let text = p.get(current_start .. p.prev_end()).into();
+        let text = p.get(current_start..p.prev_end()).into();
         marker.convert(p, NodeKind::Text(text));
     }
 }
@@ -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) => (
-                NodeKind::Script,
-                2,
-                Assoc::Right,
-                Some(NodeKind::Underscore),
-            ),
+            Some(NodeKind::Hat) => {
+                (NodeKind::Script, 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() {
-        Some(t) => t,
-        None => return,
-    };
-
+    let Some(token) = p.peek() else { return };
     match token {
         // Spaces, atoms and expressions.
         NodeKind::Space { .. }
@@ -652,7 +641,6 @@ fn literal(p: &mut Parser) -> bool {
             p.eat();
             true
         }
-
         _ => false,
     }
 }
@@ -724,50 +712,51 @@ 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) {
-            match item_kind {
-                NodeKind::Spread => can_group = false,
-                NodeKind::Named if kind.is_none() => {
-                    kind = Some(CollectionKind::Named);
-                    can_group = false;
-                }
-                _ if kind.is_none() => {
-                    kind = Some(CollectionKind::Positional);
-                }
-                _ => {}
+        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 collection_kind.is_none() => {
+                collection_kind = Some(CollectionKind::Named);
+                can_group = false;
+            }
+            _ if collection_kind.is_none() => {
+                collection_kind = Some(CollectionKind::Positional);
             }
+            _ => {}
+        }
 
-            items += 1;
+        items += 1;
 
-            if let Some(marker) = missing_coma.take() {
-                p.expected_at(marker, "comma");
-            }
+        if let Some(marker) = missing_coma.take() {
+            p.expected_at(marker, "comma");
+        }
 
-            if p.eof() {
-                break;
-            }
+        if p.eof() {
+            break;
+        }
 
-            if p.eat_if(NodeKind::Comma) {
-                can_group = false;
-            } else {
-                missing_coma = Some(p.trivia_start());
-            }
+        if p.eat_if(NodeKind::Comma) {
+            can_group = false;
         } else {
-            p.eat_if(NodeKind::Comma);
-            kind = Some(CollectionKind::Group);
+            missing_coma = Some(p.trivia_start());
         }
     }
 
     let kind = if can_group && items == 1 {
         CollectionKind::Group
     } else {
-        kind.unwrap_or(CollectionKind::Positional)
+        collection_kind.unwrap_or(CollectionKind::Positional)
     };
 
     (kind, items)
diff --git a/src/syntax/resolve.rs b/src/syntax/resolve.rs
index 2ad35cec..bbed3c5c 100644
--- a/src/syntax/resolve.rs
+++ b/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.
@@ -94,7 +90,7 @@ fn trim_and_split_raw(column: usize, mut raw: &str) -> (String, bool) {
             .take_while(|c| c.is_whitespace())
             .map(char::len_utf8)
             .sum();
-        *line = &line[offset ..];
+        *line = &line[offset..];
     }
 
     let had_newline = lines.len() > 1;
@@ -127,13 +123,13 @@ fn split_lines(text: &str) -> Vec<&str> {
                 s.eat_if('\n');
             }
 
-            lines.push(&text[start .. end]);
+            lines.push(&text[start..end]);
             start = s.cursor();
         }
         end = s.cursor();
     }
 
-    lines.push(&text[start ..]);
+    lines.push(&text[start..]);
     lines
 }
 
diff --git a/src/syntax/source.rs b/src/syntax/source.rs
index 1b87b1c9..48b0ff0e 100644
--- a/src/syntax/source.rs
+++ b/src/syntax/source.rs
@@ -123,13 +123,13 @@ impl Source {
         self.lines.truncate(line + 1);
 
         // Handle adjoining of \r and \n.
-        if self.text[.. start_byte].ends_with('\r') && with.starts_with('\n') {
+        if self.text[..start_byte].ends_with('\r') && with.starts_with('\n') {
             self.lines.pop();
         }
 
         // Recalculate the line starts after the edit.
         self.lines
-            .extend(lines(start_byte, start_utf16, &self.text[start_byte ..]));
+            .extend(lines(start_byte, start_utf16, &self.text[start_byte..]));
 
         // Incrementally reparse the replaced range.
         let mut root = std::mem::take(&mut self.root).into_inner();
@@ -146,7 +146,7 @@ impl Source {
     /// Get the length of the file in UTF-16 code units.
     pub fn len_utf16(&self) -> usize {
         let last = self.lines.last().unwrap();
-        last.utf16_idx + self.text[last.byte_idx ..].len_utf16()
+        last.utf16_idx + self.text[last.byte_idx..].len_utf16()
     }
 
     /// Get the length of the file in lines.
@@ -167,7 +167,7 @@ impl Source {
     pub fn byte_to_utf16(&self, byte_idx: usize) -> Option<usize> {
         let line_idx = self.byte_to_line(byte_idx)?;
         let line = self.lines.get(line_idx)?;
-        let head = self.text.get(line.byte_idx .. byte_idx)?;
+        let head = self.text.get(line.byte_idx..byte_idx)?;
         Some(line.utf16_idx + head.len_utf16())
     }
 
@@ -188,7 +188,7 @@ impl Source {
     pub fn byte_to_column(&self, byte_idx: usize) -> Option<usize> {
         let line = self.byte_to_line(byte_idx)?;
         let start = self.line_to_byte(line)?;
-        let head = self.get(start .. byte_idx)?;
+        let head = self.get(start..byte_idx)?;
         Some(head.chars().count())
     }
 
@@ -202,7 +202,7 @@ impl Source {
         )?;
 
         let mut k = line.utf16_idx;
-        for (i, c) in self.text[line.byte_idx ..].char_indices() {
+        for (i, c) in self.text[line.byte_idx..].char_indices() {
             if k >= utf16_idx {
                 return Some(line.byte_idx + i);
             }
@@ -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)
@@ -222,7 +221,7 @@ impl Source {
     pub fn line_to_range(&self, line_idx: usize) -> Option<Range<usize>> {
         let start = self.line_to_byte(line_idx)?;
         let end = self.line_to_byte(line_idx + 1).unwrap_or(self.text.len());
-        Some(start .. end)
+        Some(start..end)
     }
 
     /// Return the byte index of the given (line, column) pair.
@@ -237,7 +236,7 @@ impl Source {
         let range = self.line_to_range(line_idx)?;
         let line = self.get(range.clone())?;
         let mut chars = line.chars();
-        for _ in 0 .. column_idx {
+        for _ in 0..column_idx {
             chars.next();
         }
         Some(range.start + (line.len() - chars.as_str().len()))
@@ -312,10 +311,7 @@ fn lines(
             utf16_idx += 1;
         }
 
-        Some(Line {
-            byte_idx: byte_offset + s.cursor(),
-            utf16_idx,
-        })
+        Some(Line { 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, [
-            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 },
-        ]);
+        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]
@@ -411,20 +410,20 @@ mod tests {
         }
 
         // Test inserting at the begining.
-        test("abc\n", 0 .. 0, "hi\n", "hi\nabc\n");
-        test("\nabc", 0 .. 0, "hi\r", "hi\r\nabc");
+        test("abc\n", 0..0, "hi\n", "hi\nabc\n");
+        test("\nabc", 0..0, "hi\r", "hi\r\nabc");
 
         // Test editing in the middle.
-        test(TEST, 4 .. 16, "❌", "ä\tc❌i\rjkl");
+        test(TEST, 4..16, "❌", "ä\tc❌i\rjkl");
 
         // Test appending.
-        test("abc\ndef", 7 .. 7, "hi", "abc\ndefhi");
-        test("abc\ndef\n", 8 .. 8, "hi", "abc\ndef\nhi");
+        test("abc\ndef", 7..7, "hi", "abc\ndefhi");
+        test("abc\ndef\n", 8..8, "hi", "abc\ndef\nhi");
 
         // Test appending with adjoining \r and \n.
-        test("abc\ndef\r", 8 .. 8, "\nghi", "abc\ndef\r\nghi");
+        test("abc\ndef\r", 8..8, "\nghi", "abc\ndef\r\nghi");
 
         // Test removing everything.
-        test(TEST, 0 .. 21, "", "");
+        test(TEST, 0..21, "", "");
     }
 }
diff --git a/src/syntax/span.rs b/src/syntax/span.rs
index e3ff67b8..08bce4d5 100644
--- a/src/syntax/span.rs
+++ b/src/syntax/span.rs
@@ -70,7 +70,7 @@ impl Span {
     const DETACHED: u64 = 1;
 
     /// The full range of numbers available to spans.
-    pub const FULL: Range<u64> = 2 .. (1 << Self::BITS);
+    pub const FULL: Range<u64> = 2..(1 << Self::BITS);
 
     /// Create a new span from a source id and a unique number.
     ///
diff --git a/src/syntax/tokens.rs b/src/syntax/tokens.rs
index c787fa69..f18bb780 100644
--- a/src/syntax/tokens.rs
+++ b/src/syntax/tokens.rs
@@ -373,7 +373,7 @@ impl<'s> Tokens<'s> {
             NodeKind::Raw(Arc::new(resolve_raw(
                 column,
                 backticks,
-                self.s.get(start .. end),
+                self.s.get(start..end),
             )))
         } else {
             self.terminated = false;
@@ -548,7 +548,7 @@ impl<'s> Tokens<'s> {
             self.s.eat_while(char::is_ascii_alphanumeric);
         }
 
-        let number = self.s.get(start .. suffix_start);
+        let number = self.s.get(start..suffix_start);
         let suffix = self.s.from(suffix_start);
 
         // Find out whether it is a simple number.
@@ -558,9 +558,8 @@ impl<'s> Tokens<'s> {
             }
         }
 
-        let v = match number.parse::<f64>() {
-            Ok(v) => v,
-            Err(_) => return NodeKind::Error(ErrorPos::Full, "invalid number".into()),
+        let Ok(v) = number.parse::<f64>() else {
+            return NodeKind::Error(ErrorPos::Full, "invalid number".into());
         };
 
         match suffix {
@@ -636,7 +635,7 @@ fn keyword(ident: &str) -> Option<NodeKind> {
 #[inline]
 fn column(string: &str, index: usize, offset: usize) -> usize {
     let mut apply_offset = false;
-    let res = string[.. index]
+    let res = string[..index]
         .char_indices()
         .rev()
         .take_while(|&(_, c)| !is_newline(c))
@@ -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()
-    -> impl Iterator<Item = (char, Option<TokenMode>, &'static str, NodeKind)> {
+    fn suffixes(
+    ) -> impl Iterator<Item = (char, Option<TokenMode>, &'static str, NodeKind)> {
         [
             // Whitespace suffixes.
             (' ', None, " ", Space(0)),
diff --git a/src/util/eco.rs b/src/util/eco.rs
index 800760e2..5a4d7629 100644
--- a/src/util/eco.rs
+++ b/src/util/eco.rs
@@ -68,7 +68,7 @@ impl EcoString {
         let len = slice.len();
         Self(if len <= LIMIT {
             let mut buf = [0; LIMIT];
-            buf[.. len].copy_from_slice(slice.as_bytes());
+            buf[..len].copy_from_slice(slice.as_bytes());
             Repr::Small { buf, len: len as u8 }
         } else {
             Repr::Large(Arc::new(s.into()))
@@ -116,7 +116,7 @@ impl EcoString {
                 let prev = usize::from(*len);
                 let new = prev + string.len();
                 if new <= LIMIT {
-                    buf[prev .. new].copy_from_slice(string.as_bytes());
+                    buf[prev..new].copy_from_slice(string.as_bytes());
                     *len = new as u8;
                 } else {
                     let mut spilled = String::with_capacity(new);
@@ -161,7 +161,7 @@ impl EcoString {
     pub fn to_lowercase(&self) -> Self {
         if let Repr::Small { mut buf, len } = self.0 {
             if self.is_ascii() {
-                buf[.. usize::from(len)].make_ascii_lowercase();
+                buf[..usize::from(len)].make_ascii_lowercase();
                 return Self(Repr::Small { buf, len });
             }
         }
@@ -173,7 +173,7 @@ impl EcoString {
     pub fn to_uppercase(&self) -> Self {
         if let Repr::Small { mut buf, len } = self.0 {
             if self.is_ascii() {
-                buf[.. usize::from(len)].make_ascii_uppercase();
+                buf[..usize::from(len)].make_ascii_uppercase();
                 return Self(Repr::Small { buf, len });
             }
         }
@@ -191,10 +191,10 @@ impl EcoString {
             let prev = usize::from(len);
             let new = prev.saturating_mul(n);
             if new <= LIMIT {
-                let src = &buf[.. prev];
+                let src = &buf[..prev];
                 let mut buf = [0; LIMIT];
-                for i in 0 .. n {
-                    buf[prev * i .. prev * (i + 1)].copy_from_slice(src);
+                for i in 0..n {
+                    buf[prev * i..prev * (i + 1)].copy_from_slice(src);
                 }
                 return Self(Repr::Small { buf, len: new as u8 });
             }
@@ -217,7 +217,7 @@ impl Deref for EcoString {
             // Furthermore, we still do the bounds-check on the len in case
             // it gets corrupted somehow.
             Repr::Small { buf, len } => unsafe {
-                std::str::from_utf8_unchecked(&buf[.. usize::from(*len)])
+                std::str::from_utf8_unchecked(&buf[..usize::from(*len)])
             },
             Repr::Large(string) => string.as_str(),
         }
@@ -398,9 +398,9 @@ mod tests {
         assert_eq!(EcoString::from("abc"), "abc");
 
         // Test around the inline limit.
-        assert_eq!(EcoString::from(&ALPH[.. LIMIT - 1]), ALPH[.. LIMIT - 1]);
-        assert_eq!(EcoString::from(&ALPH[.. LIMIT]), ALPH[.. LIMIT]);
-        assert_eq!(EcoString::from(&ALPH[.. LIMIT + 1]), ALPH[.. LIMIT + 1]);
+        assert_eq!(EcoString::from(&ALPH[..LIMIT - 1]), ALPH[..LIMIT - 1]);
+        assert_eq!(EcoString::from(&ALPH[..LIMIT]), ALPH[..LIMIT]);
+        assert_eq!(EcoString::from(&ALPH[..LIMIT + 1]), ALPH[..LIMIT + 1]);
 
         // Test heap string.
         assert_eq!(EcoString::from(ALPH), ALPH);
@@ -443,7 +443,7 @@ mod tests {
         assert_eq!(v, "Hello World");
 
         // Remove one-by-one.
-        for _ in 0 .. 10 {
+        for _ in 0..10 {
             v.pop();
         }
 
@@ -462,7 +462,7 @@ mod tests {
     fn test_str_index() {
         // Test that we can use the index syntax.
         let v = EcoString::from("abc");
-        assert_eq!(&v[.. 2], "ab");
+        assert_eq!(&v[..2], "ab");
     }
 
     #[test]
diff --git a/src/util/fat.rs b/src/util/fat.rs
index bb557bc9..728f6ae8 100644
--- a/src/util/fat.rs
+++ b/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!(
-        alloc::Layout::new::<*const T>(),
-        alloc::Layout::new::<FatPointer>(),
-    );
-
+    debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
     mem::transmute_copy::<*const T, FatPointer>(&ptr).vtable
 }
 
diff --git a/src/util/mod.rs b/src/util/mod.rs
index df3c446e..c6809d23 100644
--- a/src/util/mod.rs
+++ b/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;