Merge pull request #46 from typst/parser-ng

Next Generation Parser

9 files changed, 1869 insertions, 1468 deletions

diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
new file mode 100644
index 00000000..288c749a
--- /dev/null
+++ b/src/syntax/ast.rs
@@ -0,0 +1,988 @@
+//! A typed layer over the red-green tree.
+
+use std::ops::Deref;
+
+use super::{Green, GreenData, NodeKind, RedNode, RedRef, Span};
+use crate::geom::{AngularUnit, LengthUnit};
+use crate::util::EcoString;
+
+/// A typed AST node.
+pub trait TypedNode: Sized {
+    /// Convert from a red node to a typed node.
+    fn from_red(value: RedRef) -> Option<Self>;
+
+    /// A reference to the underlying red node.
+    fn as_red(&self) -> RedRef<'_>;
+
+    /// The source code location.
+    fn span(&self) -> Span {
+        self.as_red().span()
+    }
+}
+
+macro_rules! node {
+    ($(#[$attr:meta])* $name:ident) => {
+        node!{$(#[$attr])* $name: $name}
+    };
+    ($(#[$attr:meta])* $name:ident: $variant:ident) => {
+        node!{$(#[$attr])* $name: NodeKind::$variant}
+    };
+    ($(#[$attr:meta])* $name:ident: $($variant:pat)|*) => {
+        #[derive(Debug, Clone, PartialEq)]
+        #[repr(transparent)]
+        $(#[$attr])*
+        pub struct $name(RedNode);
+
+        impl TypedNode for $name {
+            fn from_red(node: RedRef) -> Option<Self> {
+                if matches!(node.kind(), $($variant)|*) {
+                    Some(Self(node.own()))
+                } else {
+                    None
+                }
+            }
+
+            fn as_red(&self) -> RedRef<'_> {
+                self.0.as_ref()
+            }
+        }
+    };
+}
+
+node! {
+    /// The syntactical root capable of representing a full parsed document.
+    Markup
+}
+
+impl Markup {
+    /// The markup nodes.
+    pub fn nodes(&self) -> impl Iterator<Item = MarkupNode> + '_ {
+        self.0.children().filter_map(|node| match node.kind() {
+            NodeKind::Space(_) => Some(MarkupNode::Space),
+            NodeKind::Linebreak => Some(MarkupNode::Linebreak),
+            NodeKind::Parbreak => Some(MarkupNode::Parbreak),
+            NodeKind::Strong => Some(MarkupNode::Strong),
+            NodeKind::Emph => Some(MarkupNode::Emph),
+            NodeKind::Text(s) => Some(MarkupNode::Text(s.clone())),
+            NodeKind::UnicodeEscape(c) => Some(MarkupNode::Text((*c).into())),
+            NodeKind::EnDash => Some(MarkupNode::Text("\u{2013}".into())),
+            NodeKind::EmDash => Some(MarkupNode::Text("\u{2014}".into())),
+            NodeKind::NonBreakingSpace => Some(MarkupNode::Text("\u{00A0}".into())),
+            NodeKind::Math(math) => Some(MarkupNode::Math(math.as_ref().clone())),
+            NodeKind::Raw(raw) => Some(MarkupNode::Raw(raw.as_ref().clone())),
+            NodeKind::Heading => node.cast().map(MarkupNode::Heading),
+            NodeKind::List => node.cast().map(MarkupNode::List),
+            NodeKind::Enum => node.cast().map(MarkupNode::Enum),
+            _ => node.cast().map(MarkupNode::Expr),
+        })
+    }
+}
+
+/// A single piece of markup.
+#[derive(Debug, Clone, PartialEq)]
+pub enum MarkupNode {
+    /// Whitespace containing less than two newlines.
+    Space,
+    /// A forced line break: `\`.
+    Linebreak,
+    /// A paragraph break: Two or more newlines.
+    Parbreak,
+    /// Strong text was enabled / disabled: `*`.
+    Strong,
+    /// Emphasized text was enabled / disabled: `_`.
+    Emph,
+    /// Plain text.
+    Text(EcoString),
+    /// A raw block with optional syntax highlighting: `` `...` ``.
+    Raw(RawNode),
+    /// A math formula: `$a^2 = b^2 + c^2$`.
+    Math(MathNode),
+    /// A section heading: `= Introduction`.
+    Heading(HeadingNode),
+    /// An item in an unordered list: `- ...`.
+    List(ListNode),
+    /// An item in an enumeration (ordered list): `1. ...`.
+    Enum(EnumNode),
+    /// An expression.
+    Expr(Expr),
+}
+
+/// A raw block with optional syntax highlighting: `` `...` ``.
+#[derive(Debug, Clone, PartialEq)]
+pub struct RawNode {
+    /// An optional identifier specifying the language to syntax-highlight in.
+    pub lang: Option<EcoString>,
+    /// The raw text, determined as the raw string between the backticks trimmed
+    /// according to the above rules.
+    pub text: EcoString,
+    /// Whether the element is block-level, that is, it has 3+ backticks
+    /// and contains at least one newline.
+    pub block: bool,
+}
+
+/// A math formula: `$a^2 + b^2 = c^2$`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MathNode {
+    /// The formula between the dollars / brackets.
+    pub formula: EcoString,
+    /// Whether the formula is display-level, that is, it is surrounded by
+    /// `$[..]$`.
+    pub display: bool,
+}
+
+node! {
+    /// A section heading: `= Introduction`.
+    HeadingNode: Heading
+}
+
+impl HeadingNode {
+    /// The contents of the heading.
+    pub fn body(&self) -> Markup {
+        self.0.cast_first_child().expect("heading is missing markup body")
+    }
+
+    /// The section depth (numer of equals signs).
+    pub fn level(&self) -> usize {
+        self.0.children().filter(|n| n.kind() == &NodeKind::Eq).count()
+    }
+}
+
+node! {
+    /// An item in an unordered list: `- ...`.
+    ListNode: List
+}
+
+impl ListNode {
+    /// The contents of the list item.
+    pub fn body(&self) -> Markup {
+        self.0.cast_first_child().expect("list node is missing body")
+    }
+}
+
+node! {
+    /// An item in an enumeration (ordered list): `1. ...`.
+    EnumNode: Enum
+}
+
+impl EnumNode {
+    /// The contents of the list item.
+    pub fn body(&self) -> Markup {
+        self.0.cast_first_child().expect("enum node is missing body")
+    }
+
+    /// The number, if any.
+    pub fn number(&self) -> Option<usize> {
+        self.0
+            .children()
+            .find_map(|node| match node.kind() {
+                NodeKind::EnumNumbering(num) => Some(num.clone()),
+                _ => None,
+            })
+            .expect("enum node is missing number")
+    }
+}
+
+/// An expression.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    /// A literal: `1`, `true`, ...
+    Lit(Lit),
+    /// An identifier: `left`.
+    Ident(Ident),
+    /// An array expression: `(1, "hi", 12cm)`.
+    Array(ArrayExpr),
+    /// A dictionary expression: `(thickness: 3pt, pattern: dashed)`.
+    Dict(DictExpr),
+    /// A template expression: `[*Hi* there!]`.
+    Template(TemplateExpr),
+    /// A grouped expression: `(1 + 2)`.
+    Group(GroupExpr),
+    /// A block expression: `{ let x = 1; x + 2 }`.
+    Block(BlockExpr),
+    /// A unary operation: `-x`.
+    Unary(UnaryExpr),
+    /// A binary operation: `a + b`.
+    Binary(BinaryExpr),
+    /// An invocation of a function: `f(x, y)`.
+    Call(CallExpr),
+    /// A closure expression: `(x, y) => z`.
+    Closure(ClosureExpr),
+    /// A with expression: `f with (x, y: 1)`.
+    With(WithExpr),
+    /// A let expression: `let x = 1`.
+    Let(LetExpr),
+    /// An if-else expression: `if x { y } else { z }`.
+    If(IfExpr),
+    /// A while loop expression: `while x { y }`.
+    While(WhileExpr),
+    /// A for loop expression: `for x in y { z }`.
+    For(ForExpr),
+    /// An import expression: `import a, b, c from "utils.typ"`.
+    Import(ImportExpr),
+    /// An include expression: `include "chapter1.typ"`.
+    Include(IncludeExpr),
+}
+
+impl TypedNode for Expr {
+    fn from_red(node: RedRef) -> Option<Self> {
+        match node.kind() {
+            NodeKind::Ident(_) => node.cast().map(Self::Ident),
+            NodeKind::Array => node.cast().map(Self::Array),
+            NodeKind::Dict => node.cast().map(Self::Dict),
+            NodeKind::Template => node.cast().map(Self::Template),
+            NodeKind::Group => node.cast().map(Self::Group),
+            NodeKind::Block => node.cast().map(Self::Block),
+            NodeKind::Unary => node.cast().map(Self::Unary),
+            NodeKind::Binary => node.cast().map(Self::Binary),
+            NodeKind::Call => node.cast().map(Self::Call),
+            NodeKind::Closure => node.cast().map(Self::Closure),
+            NodeKind::WithExpr => node.cast().map(Self::With),
+            NodeKind::LetExpr => node.cast().map(Self::Let),
+            NodeKind::IfExpr => node.cast().map(Self::If),
+            NodeKind::WhileExpr => node.cast().map(Self::While),
+            NodeKind::ForExpr => node.cast().map(Self::For),
+            NodeKind::ImportExpr => node.cast().map(Self::Import),
+            NodeKind::IncludeExpr => node.cast().map(Self::Include),
+            _ => node.cast().map(Self::Lit),
+        }
+    }
+
+    fn as_red(&self) -> RedRef<'_> {
+        match self {
+            Self::Lit(v) => v.as_red(),
+            Self::Ident(v) => v.as_red(),
+            Self::Array(v) => v.as_red(),
+            Self::Dict(v) => v.as_red(),
+            Self::Template(v) => v.as_red(),
+            Self::Group(v) => v.as_red(),
+            Self::Block(v) => v.as_red(),
+            Self::Unary(v) => v.as_red(),
+            Self::Binary(v) => v.as_red(),
+            Self::Call(v) => v.as_red(),
+            Self::Closure(v) => v.as_red(),
+            Self::With(v) => v.as_red(),
+            Self::Let(v) => v.as_red(),
+            Self::If(v) => v.as_red(),
+            Self::While(v) => v.as_red(),
+            Self::For(v) => v.as_red(),
+            Self::Import(v) => v.as_red(),
+            Self::Include(v) => v.as_red(),
+        }
+    }
+}
+
+impl Expr {
+    /// Whether the expression can be shortened in markup with a hashtag.
+    pub fn has_short_form(&self) -> bool {
+        matches!(self,
+            Self::Ident(_)
+            | Self::Call(_)
+            | Self::Let(_)
+            | Self::If(_)
+            | Self::While(_)
+            | Self::For(_)
+            | Self::Import(_)
+            | Self::Include(_)
+        )
+    }
+}
+
+node! {
+    /// A literal: `1`, `true`, ...
+    Lit: NodeKind::None
+       | NodeKind::Auto
+       | NodeKind::Bool(_)
+       | NodeKind::Int(_)
+       | NodeKind::Float(_)
+       | NodeKind::Length(_, _)
+       | NodeKind::Angle(_, _)
+       | NodeKind::Percentage(_)
+       | NodeKind::Fraction(_)
+       | NodeKind::Str(_)
+}
+
+impl Lit {
+    /// The kind of literal.
+    pub fn kind(&self) -> LitKind {
+        match *self.0.kind() {
+            NodeKind::None => LitKind::None,
+            NodeKind::Auto => LitKind::Auto,
+            NodeKind::Bool(v) => LitKind::Bool(v),
+            NodeKind::Int(v) => LitKind::Int(v),
+            NodeKind::Float(v) => LitKind::Float(v),
+            NodeKind::Length(v, unit) => LitKind::Length(v, unit),
+            NodeKind::Angle(v, unit) => LitKind::Angle(v, unit),
+            NodeKind::Percentage(v) => LitKind::Percent(v),
+            NodeKind::Fraction(v) => LitKind::Fractional(v),
+            NodeKind::Str(ref v) => LitKind::Str(v.clone()),
+            _ => panic!("literal is of wrong kind"),
+        }
+    }
+}
+
+/// The kind of a literal.
+#[derive(Debug, Clone, PartialEq)]
+pub enum LitKind {
+    /// The none literal: `none`.
+    None,
+    /// The auto literal: `auto`.
+    Auto,
+    /// A boolean literal: `true`, `false`.
+    Bool(bool),
+    /// An integer literal: `120`.
+    Int(i64),
+    /// A floating-point literal: `1.2`, `10e-4`.
+    Float(f64),
+    /// A length literal: `12pt`, `3cm`.
+    Length(f64, LengthUnit),
+    /// An angle literal:  `1.5rad`, `90deg`.
+    Angle(f64, AngularUnit),
+    /// A percent literal: `50%`.
+    ///
+    /// _Note_: `50%` is stored as `50.0` here, but as `0.5` in the
+    /// corresponding [value](crate::geom::Relative).
+    Percent(f64),
+    /// A fraction unit literal: `1fr`.
+    Fractional(f64),
+    /// A string literal: `"hello!"`.
+    Str(EcoString),
+}
+
+node! {
+    /// An array expression: `(1, "hi", 12cm)`.
+    ArrayExpr: Array
+}
+
+impl ArrayExpr {
+    /// The array items.
+    pub fn items(&self) -> impl Iterator<Item = Expr> + '_ {
+        self.0.children().filter_map(RedRef::cast)
+    }
+}
+
+node! {
+    /// A dictionary expression: `(thickness: 3pt, pattern: dashed)`.
+    DictExpr: Dict
+}
+
+impl DictExpr {
+    /// The named dictionary items.
+    pub fn items(&self) -> impl Iterator<Item = Named> + '_ {
+        self.0.children().filter_map(RedRef::cast)
+    }
+}
+
+node! {
+    /// A pair of a name and an expression: `pattern: dashed`.
+    Named
+}
+
+impl Named {
+    /// The name: `pattern`.
+    pub fn name(&self) -> Ident {
+        self.0.cast_first_child().expect("named pair is missing name")
+    }
+
+    /// The right-hand side of the pair: `dashed`.
+    pub fn expr(&self) -> Expr {
+        self.0.cast_last_child().expect("named pair is missing expression")
+    }
+}
+
+node! {
+    /// A template expression: `[*Hi* there!]`.
+    TemplateExpr: Template
+}
+
+impl TemplateExpr {
+    /// The contents of the template.
+    pub fn body(&self) -> Markup {
+        self.0.cast_first_child().expect("template is missing body")
+    }
+}
+
+node! {
+    /// A grouped expression: `(1 + 2)`.
+    GroupExpr: Group
+}
+
+impl GroupExpr {
+    /// The wrapped expression.
+    pub fn expr(&self) -> Expr {
+        self.0.cast_first_child().expect("group is missing expression")
+    }
+}
+
+node! {
+    /// A block expression: `{ let x = 1; x + 2 }`.
+    BlockExpr: Block
+}
+
+impl BlockExpr {
+    /// The list of expressions contained in the block.
+    pub fn exprs(&self) -> impl Iterator<Item = Expr> + '_ {
+        self.0.children().filter_map(RedRef::cast)
+    }
+}
+
+node! {
+    /// A unary operation: `-x`.
+    UnaryExpr: Unary
+}
+
+impl UnaryExpr {
+    /// The operator: `-`.
+    pub fn op(&self) -> UnOp {
+        self.0
+            .children()
+            .find_map(|node| UnOp::from_token(node.kind()))
+            .expect("unary expression is missing operator")
+    }
+
+    /// The expression to operator on: `x`.
+    pub fn expr(&self) -> Expr {
+        self.0.cast_last_child().expect("unary expression is missing child")
+    }
+}
+
+/// A unary operator.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum UnOp {
+    /// The plus operator: `+`.
+    Pos,
+    /// The negation operator: `-`.
+    Neg,
+    /// The boolean `not`.
+    Not,
+}
+
+impl UnOp {
+    /// Try to convert the token into a unary operation.
+    pub fn from_token(token: &NodeKind) -> Option<Self> {
+        Some(match token {
+            NodeKind::Plus => Self::Pos,
+            NodeKind::Minus => Self::Neg,
+            NodeKind::Not => Self::Not,
+            _ => return None,
+        })
+    }
+
+    /// The precedence of this operator.
+    pub fn precedence(self) -> usize {
+        match self {
+            Self::Pos | Self::Neg => 7,
+            Self::Not => 4,
+        }
+    }
+
+    /// The string representation of this operation.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Pos => "+",
+            Self::Neg => "-",
+            Self::Not => "not",
+        }
+    }
+}
+
+node! {
+    /// A binary operation: `a + b`.
+    BinaryExpr: Binary
+}
+
+impl BinaryExpr {
+    /// The binary operator: `+`.
+    pub fn op(&self) -> BinOp {
+        self.0
+            .children()
+            .find_map(|node| BinOp::from_token(node.kind()))
+            .expect("binary expression is missing operator")
+    }
+
+    /// The left-hand side of the operation: `a`.
+    pub fn lhs(&self) -> Expr {
+        self.0
+            .cast_first_child()
+            .expect("binary expression is missing left-hand side")
+    }
+
+    /// The right-hand side of the operation: `b`.
+    pub fn rhs(&self) -> Expr {
+        self.0
+            .cast_last_child()
+            .expect("binary expression is missing right-hand side")
+    }
+}
+
+/// A binary operator.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum BinOp {
+    /// The addition operator: `+`.
+    Add,
+    /// The subtraction operator: `-`.
+    Sub,
+    /// The multiplication operator: `*`.
+    Mul,
+    /// The division operator: `/`.
+    Div,
+    /// The short-circuiting boolean `and`.
+    And,
+    /// The short-circuiting boolean `or`.
+    Or,
+    /// The equality operator: `==`.
+    Eq,
+    /// The inequality operator: `!=`.
+    Neq,
+    /// The less-than operator: `<`.
+    Lt,
+    /// The less-than or equal operator: `<=`.
+    Leq,
+    /// The greater-than operator: `>`.
+    Gt,
+    /// The greater-than or equal operator: `>=`.
+    Geq,
+    /// The assignment operator: `=`.
+    Assign,
+    /// The add-assign operator: `+=`.
+    AddAssign,
+    /// The subtract-assign oeprator: `-=`.
+    SubAssign,
+    /// The multiply-assign operator: `*=`.
+    MulAssign,
+    /// The divide-assign operator: `/=`.
+    DivAssign,
+}
+
+impl BinOp {
+    /// Try to convert the token into a binary operation.
+    pub fn from_token(token: &NodeKind) -> Option<Self> {
+        Some(match token {
+            NodeKind::Plus => Self::Add,
+            NodeKind::Minus => Self::Sub,
+            NodeKind::Star => Self::Mul,
+            NodeKind::Slash => Self::Div,
+            NodeKind::And => Self::And,
+            NodeKind::Or => Self::Or,
+            NodeKind::EqEq => Self::Eq,
+            NodeKind::ExclEq => Self::Neq,
+            NodeKind::Lt => Self::Lt,
+            NodeKind::LtEq => Self::Leq,
+            NodeKind::Gt => Self::Gt,
+            NodeKind::GtEq => Self::Geq,
+            NodeKind::Eq => Self::Assign,
+            NodeKind::PlusEq => Self::AddAssign,
+            NodeKind::HyphEq => Self::SubAssign,
+            NodeKind::StarEq => Self::MulAssign,
+            NodeKind::SlashEq => Self::DivAssign,
+            _ => return None,
+        })
+    }
+
+    /// The precedence of this operator.
+    pub fn precedence(self) -> usize {
+        match self {
+            Self::Mul | Self::Div => 6,
+            Self::Add | Self::Sub => 5,
+            Self::Eq | Self::Neq | Self::Lt | Self::Leq | Self::Gt | Self::Geq => 4,
+            Self::And => 3,
+            Self::Or => 2,
+            Self::Assign
+            | Self::AddAssign
+            | Self::SubAssign
+            | Self::MulAssign
+            | Self::DivAssign => 1,
+        }
+    }
+
+    /// The associativity of this operator.
+    pub fn associativity(self) -> Associativity {
+        match self {
+            Self::Add
+            | Self::Sub
+            | Self::Mul
+            | Self::Div
+            | Self::And
+            | Self::Or
+            | Self::Eq
+            | Self::Neq
+            | Self::Lt
+            | Self::Leq
+            | Self::Gt
+            | Self::Geq => Associativity::Left,
+            Self::Assign
+            | Self::AddAssign
+            | Self::SubAssign
+            | Self::MulAssign
+            | Self::DivAssign => Associativity::Right,
+        }
+    }
+
+    /// The string representation of this operation.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Add => "+",
+            Self::Sub => "-",
+            Self::Mul => "*",
+            Self::Div => "/",
+            Self::And => "and",
+            Self::Or => "or",
+            Self::Eq => "==",
+            Self::Neq => "!=",
+            Self::Lt => "<",
+            Self::Leq => "<=",
+            Self::Gt => ">",
+            Self::Geq => ">=",
+            Self::Assign => "=",
+            Self::AddAssign => "+=",
+            Self::SubAssign => "-=",
+            Self::MulAssign => "*=",
+            Self::DivAssign => "/=",
+        }
+    }
+}
+
+/// The associativity of a binary operator.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum Associativity {
+    /// Left-associative: `a + b + c` is equivalent to `(a + b) + c`.
+    Left,
+    /// Right-associative: `a = b = c` is equivalent to `a = (b = c)`.
+    Right,
+}
+
+node! {
+    /// An invocation of a function: `foo(...)`.
+    CallExpr: Call
+}
+
+impl CallExpr {
+    /// The function to call.
+    pub fn callee(&self) -> Expr {
+        self.0.cast_first_child().expect("call is missing callee")
+    }
+
+    /// The arguments to the function.
+    pub fn args(&self) -> CallArgs {
+        self.0.cast_last_child().expect("call is missing argument list")
+    }
+}
+
+node! {
+    /// The arguments to a function: `12, draw: false`.
+    CallArgs
+}
+
+impl CallArgs {
+    /// The positional and named arguments.
+    pub fn items(&self) -> impl Iterator<Item = CallArg> + '_ {
+        self.0.children().filter_map(RedRef::cast)
+    }
+}
+
+/// An argument to a function call.
+#[derive(Debug, Clone, PartialEq)]
+pub enum CallArg {
+    /// A positional argument: `12`.
+    Pos(Expr),
+    /// A named argument: `draw: false`.
+    Named(Named),
+    /// A spreaded argument: `..things`.
+    Spread(Expr),
+}
+
+impl TypedNode for CallArg {
+    fn from_red(node: RedRef) -> Option<Self> {
+        match node.kind() {
+            NodeKind::Named => node.cast().map(CallArg::Named),
+            NodeKind::Spread => node.cast_first_child().map(CallArg::Spread),
+            _ => node.cast().map(CallArg::Pos),
+        }
+    }
+
+    fn as_red(&self) -> RedRef<'_> {
+        match self {
+            Self::Pos(v) => v.as_red(),
+            Self::Named(v) => v.as_red(),
+            Self::Spread(v) => v.as_red(),
+        }
+    }
+}
+
+impl CallArg {
+    /// The name of this argument.
+    pub fn span(&self) -> Span {
+        match self {
+            Self::Pos(expr) => expr.span(),
+            Self::Named(named) => named.span(),
+            Self::Spread(expr) => expr.span(),
+        }
+    }
+}
+
+node! {
+    /// A closure expression: `(x, y) => z`.
+    ClosureExpr: Closure
+}
+
+impl ClosureExpr {
+    /// The name of the closure.
+    ///
+    /// This only exists if you use the function syntax sugar: `let f(x) = y`.
+    pub fn name(&self) -> Option<Ident> {
+        self.0.cast_first_child()
+    }
+
+    /// The parameter bindings.
+    pub fn params(&self) -> impl Iterator<Item = ClosureParam> + '_ {
+        self.0
+            .children()
+            .find(|x| x.kind() == &NodeKind::ClosureParams)
+            .expect("closure is missing parameter list")
+            .children()
+            .filter_map(RedRef::cast)
+    }
+
+    /// The body of the closure.
+    pub fn body(&self) -> Expr {
+        self.0.cast_last_child().expect("closure is missing body")
+    }
+}
+
+/// A parameter to a closure.
+#[derive(Debug, Clone, PartialEq)]
+pub enum ClosureParam {
+    /// A positional parameter: `x`.
+    Pos(Ident),
+    /// A named parameter with a default value: `draw: false`.
+    Named(Named),
+    /// A parameter sink: `..args`.
+    Sink(Ident),
+}
+
+impl TypedNode for ClosureParam {
+    fn from_red(node: RedRef) -> Option<Self> {
+        match node.kind() {
+            NodeKind::Ident(_) => node.cast().map(ClosureParam::Pos),
+            NodeKind::Named => node.cast().map(ClosureParam::Named),
+            NodeKind::Spread => node.cast_first_child().map(ClosureParam::Sink),
+            _ => None,
+        }
+    }
+
+    fn as_red(&self) -> RedRef<'_> {
+        match self {
+            Self::Pos(v) => v.as_red(),
+            Self::Named(v) => v.as_red(),
+            Self::Sink(v) => v.as_red(),
+        }
+    }
+}
+
+node! {
+    /// A with expression: `f with (x, y: 1)`.
+    WithExpr
+}
+
+impl WithExpr {
+    /// The function to apply the arguments to.
+    pub fn callee(&self) -> Expr {
+        self.0.cast_first_child().expect("with expression is missing callee")
+    }
+
+    /// The arguments to apply to the function.
+    pub fn args(&self) -> CallArgs {
+        self.0
+            .cast_first_child()
+            .expect("with expression is missing argument list")
+    }
+}
+
+node! {
+    /// A let expression: `let x = 1`.
+    LetExpr
+}
+
+impl LetExpr {
+    /// The binding to assign to.
+    pub fn binding(&self) -> Ident {
+        match self.0.cast_first_child() {
+            Some(Expr::Ident(binding)) => binding,
+            Some(Expr::With(with)) => match with.callee() {
+                Expr::Ident(binding) => binding,
+                _ => panic!("let .. with callee must be identifier"),
+            },
+            Some(Expr::Closure(closure)) => {
+                closure.name().expect("let-bound closure is missing name")
+            }
+            _ => panic!("let expression is missing binding"),
+        }
+    }
+
+    /// The expression the binding is initialized with.
+    pub fn init(&self) -> Option<Expr> {
+        if self.0.cast_first_child::<Ident>().is_some() {
+            self.0.children().filter_map(RedRef::cast).nth(1)
+        } else {
+            // This is a let .. with expression.
+            self.0.cast_first_child()
+        }
+    }
+}
+
+node! {
+    /// An import expression: `import a, b, c from "utils.typ"`.
+    ImportExpr
+}
+
+impl ImportExpr {
+    /// The items to be imported.
+    pub fn imports(&self) -> Imports {
+        self.0
+            .children()
+            .find_map(|node| match node.kind() {
+                NodeKind::Star => Some(Imports::Wildcard),
+                NodeKind::ImportItems => {
+                    let items = node.children().filter_map(RedRef::cast).collect();
+                    Some(Imports::Items(items))
+                }
+                _ => None,
+            })
+            .expect("import is missing items")
+    }
+
+    /// The location of the importable file.
+    pub fn path(&self) -> Expr {
+        self.0.cast_last_child().expect("import is missing path")
+    }
+}
+
+/// The items that ought to be imported from a file.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Imports {
+    /// All items in the scope of the file should be imported.
+    Wildcard,
+    /// The specified items from the file should be imported.
+    Items(Vec<Ident>),
+}
+
+node! {
+    /// An include expression: `include "chapter1.typ"`.
+    IncludeExpr
+}
+
+impl IncludeExpr {
+    /// The location of the file to be included.
+    pub fn path(&self) -> Expr {
+        self.0.cast_last_child().expect("include is missing path")
+    }
+}
+
+node! {
+    /// An if-else expression: `if x { y } else { z }`.
+    IfExpr
+}
+
+impl IfExpr {
+    /// The condition which selects the body to evaluate.
+    pub fn condition(&self) -> Expr {
+        self.0.cast_first_child().expect("if expression is missing condition")
+    }
+
+    /// The expression to evaluate if the condition is true.
+    pub fn if_body(&self) -> Expr {
+        self.0
+            .children()
+            .filter_map(RedRef::cast)
+            .nth(1)
+            .expect("if expression is missing body")
+    }
+
+    /// The expression to evaluate if the condition is false.
+    pub fn else_body(&self) -> Option<Expr> {
+        self.0.children().filter_map(RedRef::cast).nth(2)
+    }
+}
+
+node! {
+    /// A while loop expression: `while x { y }`.
+    WhileExpr
+}
+
+impl WhileExpr {
+    /// The condition which selects whether to evaluate the body.
+    pub fn condition(&self) -> Expr {
+        self.0.cast_first_child().expect("while loop is missing condition")
+    }
+
+    /// The expression to evaluate while the condition is true.
+    pub fn body(&self) -> Expr {
+        self.0.cast_last_child().expect("while loop is missing body")
+    }
+}
+
+node! {
+    /// A for loop expression: `for x in y { z }`.
+    ForExpr
+}
+
+impl ForExpr {
+    /// The pattern to assign to.
+    pub fn pattern(&self) -> ForPattern {
+        self.0.cast_first_child().expect("for loop is missing pattern")
+    }
+
+    /// The expression to iterate over.
+    pub fn iter(&self) -> Expr {
+        self.0.cast_first_child().expect("for loop is missing iterable")
+    }
+
+    /// The expression to evaluate for each iteration.
+    pub fn body(&self) -> Expr {
+        self.0.cast_last_child().expect("for loop is missing body")
+    }
+}
+
+node! {
+    /// A for-in loop expression: `for x in y { z }`.
+    ForPattern
+}
+
+impl ForPattern {
+    /// The key part of the pattern: index for arrays, name for dictionaries.
+    pub fn key(&self) -> Option<Ident> {
+        let mut children = self.0.children().filter_map(RedRef::cast);
+        let key = children.next();
+        if children.next().is_some() { key } else { None }
+    }
+
+    /// The value part of the pattern.
+    pub fn value(&self) -> Ident {
+        self.0.cast_last_child().expect("for loop pattern is missing value")
+    }
+}
+
+node! {
+    /// An identifier.
+    Ident: NodeKind::Ident(_)
+}
+
+impl Ident {
+    /// Take out the contained [`EcoString`].
+    pub fn take(self) -> EcoString {
+        match self.0.green {
+            Green::Token(GreenData { kind: NodeKind::Ident(id), .. }) => id,
+            _ => panic!("identifier is of wrong kind"),
+        }
+    }
+}
+
+impl Deref for Ident {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        match &self.0.green {
+            Green::Token(GreenData { kind: NodeKind::Ident(id), .. }) => id,
+            _ => panic!("identifier is of wrong kind"),
+        }
+    }
+}
diff --git a/src/syntax/expr.rs b/src/syntax/expr.rs
deleted file mode 100644
index 904515ba..00000000
--- a/src/syntax/expr.rs
+++ /dev/null
@@ -1,584 +0,0 @@
-use std::rc::Rc;
-
-use super::{Ident, Markup, Span, Token};
-use crate::geom::{AngularUnit, LengthUnit};
-use crate::util::EcoString;
-
-/// An expression.
-#[derive(Debug, Clone, PartialEq)]
-pub enum Expr {
-    /// An identifier: `left`.
-    Ident(Box<Ident>),
-    /// A literal: `1`, `true`, ...
-    Lit(Box<Lit>),
-    /// An array expression: `(1, "hi", 12cm)`.
-    Array(Box<ArrayExpr>),
-    /// A dictionary expression: `(thickness: 3pt, pattern: dashed)`.
-    Dict(Box<DictExpr>),
-    /// A template expression: `[*Hi* there!]`.
-    Template(Box<TemplateExpr>),
-    /// A grouped expression: `(1 + 2)`.
-    Group(Box<GroupExpr>),
-    /// A block expression: `{ let x = 1; x + 2 }`.
-    Block(Box<BlockExpr>),
-    /// A unary operation: `-x`.
-    Unary(Box<UnaryExpr>),
-    /// A binary operation: `a + b`.
-    Binary(Box<BinaryExpr>),
-    /// An invocation of a function: `f(x, y)`.
-    Call(Box<CallExpr>),
-    /// A closure expression: `(x, y) => z`.
-    Closure(Box<ClosureExpr>),
-    /// A with expression: `f with (x, y: 1)`.
-    With(Box<WithExpr>),
-    /// A let expression: `let x = 1`.
-    Let(Box<LetExpr>),
-    /// An if-else expression: `if x { y } else { z }`.
-    If(Box<IfExpr>),
-    /// A while loop expression: `while x { y }`.
-    While(Box<WhileExpr>),
-    /// A for loop expression: `for x in y { z }`.
-    For(Box<ForExpr>),
-    /// An import expression: `import a, b, c from "utils.typ"`.
-    Import(Box<ImportExpr>),
-    /// An include expression: `include "chapter1.typ"`.
-    Include(Box<IncludeExpr>),
-}
-
-impl Expr {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        match self {
-            Self::Ident(v) => v.span,
-            Self::Lit(v) => v.span(),
-            Self::Array(v) => v.span,
-            Self::Dict(v) => v.span,
-            Self::Template(v) => v.span,
-            Self::Group(v) => v.span,
-            Self::Block(v) => v.span,
-            Self::Unary(v) => v.span,
-            Self::Binary(v) => v.span,
-            Self::Call(v) => v.span,
-            Self::Closure(v) => v.span,
-            Self::With(v) => v.span,
-            Self::Let(v) => v.span,
-            Self::If(v) => v.span,
-            Self::While(v) => v.span,
-            Self::For(v) => v.span,
-            Self::Import(v) => v.span,
-            Self::Include(v) => v.span,
-        }
-    }
-
-    /// Whether the expression can be shortened in markup with a hashtag.
-    pub fn has_short_form(&self) -> bool {
-        matches!(self,
-            Self::Ident(_)
-            | Self::Call(_)
-            | Self::Let(_)
-            | Self::If(_)
-            | Self::While(_)
-            | Self::For(_)
-            | Self::Import(_)
-            | Self::Include(_)
-        )
-    }
-}
-
-/// A literal: `1`, `true`, ...
-#[derive(Debug, Clone, PartialEq)]
-pub enum Lit {
-    /// The none literal: `none`.
-    None(Span),
-    /// The auto literal: `auto`.
-    Auto(Span),
-    /// A boolean literal: `true`, `false`.
-    Bool(Span, bool),
-    /// An integer literal: `120`.
-    Int(Span, i64),
-    /// A floating-point literal: `1.2`, `10e-4`.
-    Float(Span, f64),
-    /// A length literal: `12pt`, `3cm`.
-    Length(Span, f64, LengthUnit),
-    /// An angle literal:  `1.5rad`, `90deg`.
-    Angle(Span, f64, AngularUnit),
-    /// A percent literal: `50%`.
-    ///
-    /// _Note_: `50%` is stored as `50.0` here, but as `0.5` in the
-    /// corresponding [value](crate::geom::Relative).
-    Percent(Span, f64),
-    /// A fraction unit literal: `1fr`.
-    Fractional(Span, f64),
-    /// A string literal: `"hello!"`.
-    Str(Span, EcoString),
-}
-
-impl Lit {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        match *self {
-            Self::None(span) => span,
-            Self::Auto(span) => span,
-            Self::Bool(span, _) => span,
-            Self::Int(span, _) => span,
-            Self::Float(span, _) => span,
-            Self::Length(span, _, _) => span,
-            Self::Angle(span, _, _) => span,
-            Self::Percent(span, _) => span,
-            Self::Fractional(span, _) => span,
-            Self::Str(span, _) => span,
-        }
-    }
-}
-
-/// An array expression: `(1, "hi", 12cm)`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ArrayExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The entries of the array.
-    pub items: Vec<Expr>,
-}
-
-/// A dictionary expression: `(thickness: 3pt, pattern: dashed)`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct DictExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The named dictionary entries.
-    pub items: Vec<Named>,
-}
-
-/// A pair of a name and an expression: `pattern: dashed`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Named {
-    /// The name: `pattern`.
-    pub name: Ident,
-    /// The right-hand side of the pair: `dashed`.
-    pub expr: Expr,
-}
-
-impl Named {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        self.name.span.join(self.expr.span())
-    }
-}
-
-/// A template expression: `[*Hi* there!]`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct TemplateExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The contents of the template.
-    pub body: Markup,
-}
-
-/// A grouped expression: `(1 + 2)`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct GroupExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The wrapped expression.
-    pub expr: Expr,
-}
-
-/// A block expression: `{ let x = 1; x + 2 }`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct BlockExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The list of expressions contained in the block.
-    pub exprs: Vec<Expr>,
-}
-
-/// A unary operation: `-x`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct UnaryExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The operator: `-`.
-    pub op: UnOp,
-    /// The expression to operator on: `x`.
-    pub expr: Expr,
-}
-
-/// A unary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum UnOp {
-    /// The plus operator: `+`.
-    Pos,
-    /// The negation operator: `-`.
-    Neg,
-    /// The boolean `not`.
-    Not,
-}
-
-impl UnOp {
-    /// Try to convert the token into a unary operation.
-    pub fn from_token(token: Token) -> Option<Self> {
-        Some(match token {
-            Token::Plus => Self::Pos,
-            Token::Hyph => Self::Neg,
-            Token::Not => Self::Not,
-            _ => return None,
-        })
-    }
-
-    /// The precedence of this operator.
-    pub fn precedence(self) -> usize {
-        match self {
-            Self::Pos | Self::Neg => 8,
-            Self::Not => 3,
-        }
-    }
-
-    /// The string representation of this operation.
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::Pos => "+",
-            Self::Neg => "-",
-            Self::Not => "not",
-        }
-    }
-}
-
-/// A binary operation: `a + b`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct BinaryExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The left-hand side of the operation: `a`.
-    pub lhs: Expr,
-    /// The operator: `+`.
-    pub op: BinOp,
-    /// The right-hand side of the operation: `b`.
-    pub rhs: Expr,
-}
-
-/// A binary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum BinOp {
-    /// The addition operator: `+`.
-    Add,
-    /// The subtraction operator: `-`.
-    Sub,
-    /// The multiplication operator: `*`.
-    Mul,
-    /// The division operator: `/`.
-    Div,
-    /// The short-circuiting boolean `and`.
-    And,
-    /// The short-circuiting boolean `or`.
-    Or,
-    /// The equality operator: `==`.
-    Eq,
-    /// The inequality operator: `!=`.
-    Neq,
-    /// The less-than operator: `<`.
-    Lt,
-    /// The less-than or equal operator: `<=`.
-    Leq,
-    /// The greater-than operator: `>`.
-    Gt,
-    /// The greater-than or equal operator: `>=`.
-    Geq,
-    /// The assignment operator: `=`.
-    Assign,
-    /// The add-assign operator: `+=`.
-    AddAssign,
-    /// The subtract-assign oeprator: `-=`.
-    SubAssign,
-    /// The multiply-assign operator: `*=`.
-    MulAssign,
-    /// The divide-assign operator: `/=`.
-    DivAssign,
-}
-
-impl BinOp {
-    /// Try to convert the token into a binary operation.
-    pub fn from_token(token: Token) -> Option<Self> {
-        Some(match token {
-            Token::Plus => Self::Add,
-            Token::Hyph => Self::Sub,
-            Token::Star => Self::Mul,
-            Token::Slash => Self::Div,
-            Token::And => Self::And,
-            Token::Or => Self::Or,
-            Token::EqEq => Self::Eq,
-            Token::ExclEq => Self::Neq,
-            Token::Lt => Self::Lt,
-            Token::LtEq => Self::Leq,
-            Token::Gt => Self::Gt,
-            Token::GtEq => Self::Geq,
-            Token::Eq => Self::Assign,
-            Token::PlusEq => Self::AddAssign,
-            Token::HyphEq => Self::SubAssign,
-            Token::StarEq => Self::MulAssign,
-            Token::SlashEq => Self::DivAssign,
-            _ => return None,
-        })
-    }
-
-    /// The precedence of this operator.
-    pub fn precedence(self) -> usize {
-        match self {
-            Self::Mul | Self::Div => 6,
-            Self::Add | Self::Sub => 5,
-            Self::Eq | Self::Neq | Self::Lt | Self::Leq | Self::Gt | Self::Geq => 4,
-            Self::And => 3,
-            Self::Or => 2,
-            Self::Assign
-            | Self::AddAssign
-            | Self::SubAssign
-            | Self::MulAssign
-            | Self::DivAssign => 1,
-        }
-    }
-
-    /// The associativity of this operator.
-    pub fn associativity(self) -> Associativity {
-        match self {
-            Self::Add
-            | Self::Sub
-            | Self::Mul
-            | Self::Div
-            | Self::And
-            | Self::Or
-            | Self::Eq
-            | Self::Neq
-            | Self::Lt
-            | Self::Leq
-            | Self::Gt
-            | Self::Geq => Associativity::Left,
-            Self::Assign
-            | Self::AddAssign
-            | Self::SubAssign
-            | Self::MulAssign
-            | Self::DivAssign => Associativity::Right,
-        }
-    }
-
-    /// The string representation of this operation.
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::Add => "+",
-            Self::Sub => "-",
-            Self::Mul => "*",
-            Self::Div => "/",
-            Self::And => "and",
-            Self::Or => "or",
-            Self::Eq => "==",
-            Self::Neq => "!=",
-            Self::Lt => "<",
-            Self::Leq => "<=",
-            Self::Gt => ">",
-            Self::Geq => ">=",
-            Self::Assign => "=",
-            Self::AddAssign => "+=",
-            Self::SubAssign => "-=",
-            Self::MulAssign => "*=",
-            Self::DivAssign => "/=",
-        }
-    }
-}
-
-/// The associativity of a binary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum Associativity {
-    /// Left-associative: `a + b + c` is equivalent to `(a + b) + c`.
-    Left,
-    /// Right-associative: `a = b = c` is equivalent to `a = (b = c)`.
-    Right,
-}
-
-/// An invocation of a function: `foo(...)`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct CallExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The function to call.
-    pub callee: Expr,
-    /// The arguments to the function.
-    pub args: CallArgs,
-}
-
-/// The arguments to a function: `12, draw: false`.
-///
-/// In case of a bracketed invocation with a body, the body is _not_
-/// included in the span for the sake of clearer error messages.
-#[derive(Debug, Clone, PartialEq)]
-pub struct CallArgs {
-    /// The source code location.
-    pub span: Span,
-    /// The positional and named arguments.
-    pub items: Vec<CallArg>,
-}
-
-/// An argument to a function call.
-#[derive(Debug, Clone, PartialEq)]
-pub enum CallArg {
-    /// A positional argument: `12`.
-    Pos(Expr),
-    /// A named argument: `draw: false`.
-    Named(Named),
-    /// A spreaded argument: `..things`.
-    Spread(Expr),
-}
-
-impl CallArg {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        match self {
-            Self::Pos(expr) => expr.span(),
-            Self::Named(named) => named.span(),
-            Self::Spread(expr) => expr.span(),
-        }
-    }
-}
-
-/// A closure expression: `(x, y) => z`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ClosureExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The name of the closure.
-    ///
-    /// This only exists if you use the function syntax sugar: `let f(x) = y`.
-    pub name: Option<Ident>,
-    /// The parameter bindings.
-    pub params: Vec<ClosureParam>,
-    /// The body of the closure.
-    pub body: Rc<Expr>,
-}
-
-/// An parameter to a closure.
-#[derive(Debug, Clone, PartialEq)]
-pub enum ClosureParam {
-    /// A positional parameter: `x`.
-    Pos(Ident),
-    /// A named parameter with a default value: `draw: false`.
-    Named(Named),
-    /// A parameter sink: `..args`.
-    Sink(Ident),
-}
-
-impl ClosureParam {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        match self {
-            Self::Pos(ident) => ident.span,
-            Self::Named(named) => named.span(),
-            Self::Sink(ident) => ident.span,
-        }
-    }
-}
-
-/// A with expression: `f with (x, y: 1)`.
-///
-/// Applies arguments to a function.
-#[derive(Debug, Clone, PartialEq)]
-pub struct WithExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The function to apply the arguments to.
-    pub callee: Expr,
-    /// The arguments to apply to the function.
-    pub args: CallArgs,
-}
-
-/// A let expression: `let x = 1`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct LetExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The binding to assign to.
-    pub binding: Ident,
-    /// The expression the binding is initialized with.
-    pub init: Option<Expr>,
-}
-
-/// An import expression: `import a, b, c from "utils.typ"`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ImportExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The items to be imported.
-    pub imports: Imports,
-    /// The location of the importable file.
-    pub path: Expr,
-}
-
-/// The items that ought to be imported from a file.
-#[derive(Debug, Clone, PartialEq)]
-pub enum Imports {
-    /// All items in the scope of the file should be imported.
-    Wildcard,
-    /// The specified identifiers from the file should be imported.
-    Idents(Vec<Ident>),
-}
-
-/// An include expression: `include "chapter1.typ"`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct IncludeExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The location of the file to be included.
-    pub path: Expr,
-}
-
-/// An if-else expression: `if x { y } else { z }`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct IfExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The condition which selects the body to evaluate.
-    pub condition: Expr,
-    /// The expression to evaluate if the condition is true.
-    pub if_body: Expr,
-    /// The expression to evaluate if the condition is false.
-    pub else_body: Option<Expr>,
-}
-
-/// A while loop expression: `while x { y }`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct WhileExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The condition which selects whether to evaluate the body.
-    pub condition: Expr,
-    /// The expression to evaluate while the condition is true.
-    pub body: Expr,
-}
-
-/// A for loop expression: `for x in y { z }`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ForExpr {
-    /// The source code location.
-    pub span: Span,
-    /// The pattern to assign to.
-    pub pattern: ForPattern,
-    /// The expression to iterate over.
-    pub iter: Expr,
-    /// The expression to evaluate for each iteration.
-    pub body: Expr,
-}
-
-/// A pattern in a for loop.
-#[derive(Debug, Clone, PartialEq)]
-pub enum ForPattern {
-    /// A value pattern: `for v in array`.
-    Value(Ident),
-    /// A key-value pattern: `for k, v in dict`.
-    KeyValue(Ident, Ident),
-}
-
-impl ForPattern {
-    /// The source code location.
-    pub fn span(&self) -> Span {
-        match self {
-            Self::Value(v) => v.span,
-            Self::KeyValue(k, v) => k.span.join(v.span),
-        }
-    }
-}
diff --git a/src/syntax/ident.rs b/src/syntax/ident.rs
deleted file mode 100644
index 398e2ff9..00000000
--- a/src/syntax/ident.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use std::borrow::Borrow;
-use std::ops::Deref;
-
-use unicode_xid::UnicodeXID;
-
-use super::Span;
-use crate::util::EcoString;
-
-/// An unicode identifier with a few extra permissible characters.
-///
-/// In addition to what is specified in the [Unicode Standard][uax31], we allow:
-/// - `_` as a starting character,
-/// - `_` and `-` as continuing characters.
-///
-/// [uax31]: http://www.unicode.org/reports/tr31/
-#[derive(Debug, Clone, PartialEq)]
-pub struct Ident {
-    /// The source code location.
-    pub span: Span,
-    /// The identifier string.
-    pub string: EcoString,
-}
-
-impl Ident {
-    /// Create a new identifier from a string checking that it is a valid.
-    pub fn new(
-        string: impl AsRef<str> + Into<EcoString>,
-        span: impl Into<Span>,
-    ) -> Option<Self> {
-        if is_ident(string.as_ref()) {
-            Some(Self { span: span.into(), string: string.into() })
-        } else {
-            None
-        }
-    }
-
-    /// Return a reference to the underlying string.
-    pub fn as_str(&self) -> &str {
-        self
-    }
-}
-
-impl Deref for Ident {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        self.string.as_str()
-    }
-}
-
-impl AsRef<str> for Ident {
-    fn as_ref(&self) -> &str {
-        self
-    }
-}
-
-impl Borrow<str> for Ident {
-    fn borrow(&self) -> &str {
-        self
-    }
-}
-
-impl From<&Ident> for EcoString {
-    fn from(ident: &Ident) -> Self {
-        ident.string.clone()
-    }
-}
-
-/// Whether a string is a valid identifier.
-pub fn is_ident(string: &str) -> bool {
-    let mut chars = string.chars();
-    chars
-        .next()
-        .map_or(false, |c| is_id_start(c) && chars.all(is_id_continue))
-}
-
-/// Whether a character can start an identifier.
-pub fn is_id_start(c: char) -> bool {
-    c.is_xid_start() || c == '_'
-}
-
-/// Whether a character can continue an identifier.
-pub fn is_id_continue(c: char) -> bool {
-    c.is_xid_continue() || c == '_' || c == '-'
-}
diff --git a/src/syntax/markup.rs b/src/syntax/markup.rs
deleted file mode 100644
index 09a37116..00000000
--- a/src/syntax/markup.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use super::{Expr, Ident, Span};
-use crate::util::EcoString;
-
-/// The syntactical root capable of representing a full parsed document.
-pub type Markup = Vec<MarkupNode>;
-
-/// A single piece of markup.
-#[derive(Debug, Clone, PartialEq)]
-pub enum MarkupNode {
-    /// Whitespace containing less than two newlines.
-    Space,
-    /// A forced line break: `\`.
-    Linebreak(Span),
-    /// A paragraph break: Two or more newlines.
-    Parbreak(Span),
-    /// Strong text was enabled / disabled: `*`.
-    Strong(Span),
-    /// Emphasized text was enabled / disabled: `_`.
-    Emph(Span),
-    /// Plain text.
-    Text(EcoString),
-    /// A raw block with optional syntax highlighting: `` `...` ``.
-    Raw(Box<RawNode>),
-    /// A section heading: `= Introduction`.
-    Heading(Box<HeadingNode>),
-    /// An item in an unordered list: `- ...`.
-    List(Box<ListNode>),
-    /// An item in an enumeration (ordered list): `1. ...`.
-    Enum(Box<EnumNode>),
-    /// An expression.
-    Expr(Expr),
-}
-
-/// A raw block with optional syntax highlighting: `` `...` ``.
-#[derive(Debug, Clone, PartialEq)]
-pub struct RawNode {
-    /// The source code location.
-    pub span: Span,
-    /// An optional identifier specifying the language to syntax-highlight in.
-    pub lang: Option<Ident>,
-    /// The raw text, determined as the raw string between the backticks trimmed
-    /// according to the above rules.
-    pub text: EcoString,
-    /// Whether the element is block-level, that is, it has 3+ backticks
-    /// and contains at least one newline.
-    pub block: bool,
-}
-
-/// A section heading: `= Introduction`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct HeadingNode {
-    /// The source code location.
-    pub span: Span,
-    /// The section depth (numer of equals signs).
-    pub level: usize,
-    /// The contents of the heading.
-    pub body: Markup,
-}
-
-/// An item in an unordered list: `- ...`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ListNode {
-    /// The source code location.
-    pub span: Span,
-    /// The contents of the list item.
-    pub body: Markup,
-}
-
-/// An item in an enumeration (ordered list): `1. ...`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct EnumNode {
-    /// The source code location.
-    pub span: Span,
-    /// The number, if any.
-    pub number: Option<usize>,
-    /// The contents of the list item.
-    pub body: Markup,
-}
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
index 8dbb108d..ca6ed243 100644
--- a/src/syntax/mod.rs
+++ b/src/syntax/mod.rs
@@ -1,16 +1,747 @@
 //! Syntax types.
 
-mod expr;
-mod ident;
-mod markup;
+pub mod ast;
 mod pretty;
 mod span;
-mod token;
-pub mod visit;
 
-pub use expr::*;
-pub use ident::*;
-pub use markup::*;
+use std::fmt::{self, Debug, Display, Formatter};
+use std::rc::Rc;
+
 pub use pretty::*;
 pub use span::*;
-pub use token::*;
+
+use self::ast::{MathNode, RawNode, TypedNode};
+use crate::diag::Error;
+use crate::geom::{AngularUnit, LengthUnit};
+use crate::source::SourceId;
+use crate::util::EcoString;
+
+/// An inner of leaf node in the untyped green tree.
+#[derive(Clone, PartialEq)]
+pub enum Green {
+    /// A reference-counted inner node.
+    Node(Rc<GreenNode>),
+    /// A terminal, owned token.
+    Token(GreenData),
+}
+
+impl Green {
+    /// Returns the metadata of the node.
+    fn data(&self) -> &GreenData {
+        match self {
+            Green::Node(n) => &n.data,
+            Green::Token(t) => &t,
+        }
+    }
+
+    /// The type of the node.
+    pub fn kind(&self) -> &NodeKind {
+        self.data().kind()
+    }
+
+    /// The length of the node.
+    pub fn len(&self) -> usize {
+        self.data().len()
+    }
+
+    /// Whether the node or its children contain an error.
+    pub fn erroneous(&self) -> bool {
+        match self {
+            Self::Node(node) => node.erroneous,
+            Self::Token(data) => data.kind.is_error(),
+        }
+    }
+
+    /// The node's children.
+    pub fn children(&self) -> &[Green] {
+        match self {
+            Green::Node(n) => &n.children(),
+            Green::Token(_) => &[],
+        }
+    }
+
+    /// Change the type of the node.
+    pub fn convert(&mut self, kind: NodeKind) {
+        match self {
+            Self::Node(node) => {
+                let node = Rc::make_mut(node);
+                node.erroneous |= kind.is_error();
+                node.data.kind = kind;
+            }
+            Self::Token(data) => data.kind = kind,
+        }
+    }
+}
+
+impl Default for Green {
+    fn default() -> Self {
+        Self::Token(GreenData::new(NodeKind::None, 0))
+    }
+}
+
+impl Debug for Green {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{:?}: {}", self.kind(), self.len())?;
+        if let Self::Node(n) = self {
+            if !n.children.is_empty() {
+                f.write_str(" ")?;
+                f.debug_list().entries(&n.children).finish()?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// An inner node in the untyped green tree.
+#[derive(Debug, Clone, PartialEq)]
+pub struct GreenNode {
+    /// Node metadata.
+    data: GreenData,
+    /// This node's children, losslessly make up this node.
+    children: Vec<Green>,
+    /// Whether this node or any of its children are erroneous.
+    erroneous: bool,
+}
+
+impl GreenNode {
+    /// Creates a new node with the given kind and a single child.
+    pub fn with_child(kind: NodeKind, child: impl Into<Green>) -> Self {
+        Self::with_children(kind, vec![child.into()])
+    }
+
+    /// Creates a new node with the given kind and children.
+    pub fn with_children(kind: NodeKind, children: Vec<Green>) -> Self {
+        let mut erroneous = kind.is_error();
+        let len = children
+            .iter()
+            .inspect(|c| erroneous |= c.erroneous())
+            .map(Green::len)
+            .sum();
+
+        Self {
+            data: GreenData::new(kind, len),
+            children,
+            erroneous,
+        }
+    }
+
+    /// The node's children.
+    pub fn children(&self) -> &[Green] {
+        &self.children
+    }
+}
+
+impl From<GreenNode> for Green {
+    fn from(node: GreenNode) -> Self {
+        Rc::new(node).into()
+    }
+}
+
+impl From<Rc<GreenNode>> for Green {
+    fn from(node: Rc<GreenNode>) -> Self {
+        Self::Node(node)
+    }
+}
+
+/// Data shared between inner and leaf nodes.
+#[derive(Debug, Clone, PartialEq)]
+pub struct GreenData {
+    /// What kind of node this is (each kind would have its own struct in a
+    /// strongly typed AST).
+    kind: NodeKind,
+    /// The byte length of the node in the source.
+    len: usize,
+}
+
+impl GreenData {
+    /// Create new node metadata.
+    pub fn new(kind: NodeKind, len: usize) -> Self {
+        Self { len, kind }
+    }
+
+    /// The type of the node.
+    pub fn kind(&self) -> &NodeKind {
+        &self.kind
+    }
+
+    /// The length of the node.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}
+
+impl From<GreenData> for Green {
+    fn from(token: GreenData) -> Self {
+        Self::Token(token)
+    }
+}
+
+/// A owned wrapper for a green node with span information.
+///
+/// Owned variant of [`RedRef`]. Can be [cast](Self::cast) to an AST node.
+#[derive(Clone, PartialEq)]
+pub struct RedNode {
+    id: SourceId,
+    offset: usize,
+    green: Green,
+}
+
+impl RedNode {
+    /// Create a new red node from a root [`GreenNode`].
+    pub fn from_root(root: Rc<GreenNode>, id: SourceId) -> Self {
+        Self { id, offset: 0, green: root.into() }
+    }
+
+    /// Convert to a borrowed representation.
+    pub fn as_ref(&self) -> RedRef<'_> {
+        RedRef {
+            id: self.id,
+            offset: self.offset,
+            green: &self.green,
+        }
+    }
+
+    /// The type of the node.
+    pub fn kind(&self) -> &NodeKind {
+        self.as_ref().kind()
+    }
+
+    /// The length of the node.
+    pub fn len(&self) -> usize {
+        self.as_ref().len()
+    }
+
+    /// The span of the node.
+    pub fn span(&self) -> Span {
+        self.as_ref().span()
+    }
+
+    /// The error messages for this node and its descendants.
+    pub fn errors(&self) -> Vec<Error> {
+        self.as_ref().errors()
+    }
+
+    /// Convert the node to a typed AST node.
+    pub fn cast<T>(self) -> Option<T>
+    where
+        T: TypedNode,
+    {
+        self.as_ref().cast()
+    }
+
+    /// The children of the node.
+    pub fn children(&self) -> Children<'_> {
+        self.as_ref().children()
+    }
+
+    /// Get the first child that can cast to some AST type.
+    pub fn cast_first_child<T: TypedNode>(&self) -> Option<T> {
+        self.as_ref().cast_first_child()
+    }
+
+    /// Get the last child that can cast to some AST type.
+    pub fn cast_last_child<T: TypedNode>(&self) -> Option<T> {
+        self.as_ref().cast_last_child()
+    }
+}
+
+impl Debug for RedNode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.as_ref().fmt(f)
+    }
+}
+
+/// A borrowed wrapper for a green node with span information.
+///
+/// Borrowed variant of [`RedNode`]. Can be [cast](Self::cast) to an AST node.
+#[derive(Copy, Clone, PartialEq)]
+pub struct RedRef<'a> {
+    id: SourceId,
+    offset: usize,
+    green: &'a Green,
+}
+
+impl<'a> RedRef<'a> {
+    /// Convert to an owned representation.
+    pub fn own(self) -> RedNode {
+        RedNode {
+            id: self.id,
+            offset: self.offset,
+            green: self.green.clone(),
+        }
+    }
+
+    /// The type of the node.
+    pub fn kind(self) -> &'a NodeKind {
+        self.green.kind()
+    }
+
+    /// The length of the node.
+    pub fn len(self) -> usize {
+        self.green.len()
+    }
+
+    /// The span of the node.
+    pub fn span(self) -> Span {
+        Span::new(self.id, self.offset, self.offset + self.green.len())
+    }
+
+    /// The error messages for this node and its descendants.
+    pub fn errors(self) -> Vec<Error> {
+        if !self.green.erroneous() {
+            return vec![];
+        }
+
+        match self.kind() {
+            NodeKind::Error(pos, msg) => {
+                let span = match pos {
+                    ErrorPos::Start => self.span().at_start(),
+                    ErrorPos::Full => self.span(),
+                    ErrorPos::End => self.span().at_end(),
+                };
+
+                vec![Error::new(span, msg.to_string())]
+            }
+            _ => self
+                .children()
+                .filter(|red| red.green.erroneous())
+                .flat_map(|red| red.errors())
+                .collect(),
+        }
+    }
+
+    /// Convert the node to a typed AST node.
+    pub fn cast<T>(self) -> Option<T>
+    where
+        T: TypedNode,
+    {
+        T::from_red(self)
+    }
+
+    /// The node's children.
+    pub fn children(self) -> Children<'a> {
+        let children = match &self.green {
+            Green::Node(node) => node.children(),
+            Green::Token(_) => &[],
+        };
+
+        Children {
+            id: self.id,
+            iter: children.iter(),
+            front: self.offset,
+            back: self.offset + self.len(),
+        }
+    }
+
+    /// Get the first child that can cast to some AST type.
+    pub fn cast_first_child<T: TypedNode>(self) -> Option<T> {
+        self.children().find_map(RedRef::cast)
+    }
+
+    /// Get the last child that can cast to some AST type.
+    pub fn cast_last_child<T: TypedNode>(self) -> Option<T> {
+        self.children().rev().find_map(RedRef::cast)
+    }
+}
+
+impl Debug for RedRef<'_> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{:?}: {:?}", self.kind(), self.span())?;
+        let mut children = self.children().peekable();
+        if children.peek().is_some() {
+            f.write_str(" ")?;
+            f.debug_list().entries(children.map(RedRef::own)).finish()?;
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over the children of a red node.
+pub struct Children<'a> {
+    id: SourceId,
+    iter: std::slice::Iter<'a, Green>,
+    front: usize,
+    back: usize,
+}
+
+impl<'a> Iterator for Children<'a> {
+    type Item = RedRef<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|green| {
+            let offset = self.front;
+            self.front += green.len();
+            RedRef { id: self.id, offset, green }
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl DoubleEndedIterator for Children<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back().map(|green| {
+            self.back -= green.len();
+            RedRef { id: self.id, offset: self.back, green }
+        })
+    }
+}
+
+impl ExactSizeIterator for Children<'_> {}
+
+/// All syntactical building blocks that can be part of a Typst document.
+///
+/// Can be emitted as a token by the tokenizer or as part of a green node by
+/// the parser.
+#[derive(Debug, Clone, PartialEq)]
+pub enum NodeKind {
+    /// A left square bracket: `[`.
+    LeftBracket,
+    /// A right square bracket: `]`.
+    RightBracket,
+    /// A left curly brace: `{`.
+    LeftBrace,
+    /// A right curly brace: `}`.
+    RightBrace,
+    /// A left round parenthesis: `(`.
+    LeftParen,
+    /// A right round parenthesis: `)`.
+    RightParen,
+    /// An asterisk: `*`.
+    Star,
+    /// A comma: `,`.
+    Comma,
+    /// A semicolon: `;`.
+    Semicolon,
+    /// A colon: `:`.
+    Colon,
+    /// A plus: `+`.
+    Plus,
+    /// A hyphen: `-`.
+    Minus,
+    /// A slash: `/`.
+    Slash,
+    /// A single equals sign: `=`.
+    Eq,
+    /// Two equals signs: `==`.
+    EqEq,
+    /// An exclamation mark followed by an equals sign: `!=`.
+    ExclEq,
+    /// A less-than sign: `<`.
+    Lt,
+    /// A less-than sign followed by an equals sign: `<=`.
+    LtEq,
+    /// A greater-than sign: `>`.
+    Gt,
+    /// A greater-than sign followed by an equals sign: `>=`.
+    GtEq,
+    /// A plus followed by an equals sign: `+=`.
+    PlusEq,
+    /// A hyphen followed by an equals sign: `-=`.
+    HyphEq,
+    /// An asterisk followed by an equals sign: `*=`.
+    StarEq,
+    /// A slash followed by an equals sign: `/=`.
+    SlashEq,
+    /// The `not` operator.
+    Not,
+    /// The `and` operator.
+    And,
+    /// The `or` operator.
+    Or,
+    /// The `with` operator.
+    With,
+    /// Two dots: `..`.
+    Dots,
+    /// An equals sign followed by a greater-than sign: `=>`.
+    Arrow,
+    /// The none literal: `none`.
+    None,
+    /// The auto literal: `auto`.
+    Auto,
+    /// The `let` keyword.
+    Let,
+    /// The `if` keyword.
+    If,
+    /// The `else` keyword.
+    Else,
+    /// The `for` keyword.
+    For,
+    /// The `in` keyword.
+    In,
+    /// The `while` keyword.
+    While,
+    /// The `break` keyword.
+    Break,
+    /// The `continue` keyword.
+    Continue,
+    /// The `return` keyword.
+    Return,
+    /// The `import` keyword.
+    Import,
+    /// The `include` keyword.
+    Include,
+    /// The `from` keyword.
+    From,
+    /// Template markup.
+    Markup,
+    /// One or more whitespace characters.
+    Space(usize),
+    /// A forced line break: `\`.
+    Linebreak,
+    /// A paragraph break: Two or more newlines.
+    Parbreak,
+    /// A consecutive non-markup string.
+    Text(EcoString),
+    /// A non-breaking space: `~`.
+    NonBreakingSpace,
+    /// An en-dash: `--`.
+    EnDash,
+    /// An em-dash: `---`.
+    EmDash,
+    /// A slash and the letter "u" followed by a hexadecimal unicode entity
+    /// enclosed in curly braces: `\u{1F5FA}`.
+    UnicodeEscape(char),
+    /// Strong text was enabled / disabled: `*`.
+    Strong,
+    /// Emphasized text was enabled / disabled: `_`.
+    Emph,
+    /// A section heading: `= Introduction`.
+    Heading,
+    /// An item in an enumeration (ordered list): `1. ...`.
+    Enum,
+    /// A numbering: `23.`.
+    ///
+    /// Can also exist without the number: `.`.
+    EnumNumbering(Option<usize>),
+    /// An item in an unordered list: `- ...`.
+    List,
+    /// An arbitrary number of backticks followed by inner contents, terminated
+    /// with the same number of backticks: `` `...` ``.
+    Raw(Rc<RawNode>),
+    /// Dollar signs surrounding inner contents.
+    Math(Rc<MathNode>),
+    /// An identifier: `center`.
+    Ident(EcoString),
+    /// A boolean: `true`, `false`.
+    Bool(bool),
+    /// An integer: `120`.
+    Int(i64),
+    /// A floating-point number: `1.2`, `10e-4`.
+    Float(f64),
+    /// A length: `12pt`, `3cm`.
+    Length(f64, LengthUnit),
+    /// An angle: `90deg`.
+    Angle(f64, AngularUnit),
+    /// A percentage: `50%`.
+    ///
+    /// _Note_: `50%` is stored as `50.0` here, as in the corresponding
+    /// [literal](ast::LitKind::Percent).
+    Percentage(f64),
+    /// A fraction unit: `3fr`.
+    Fraction(f64),
+    /// A quoted string: `"..."`.
+    Str(EcoString),
+    /// An array expression: `(1, "hi", 12cm)`.
+    Array,
+    /// A dictionary expression: `(thickness: 3pt, pattern: dashed)`.
+    Dict,
+    /// A named pair: `thickness: 3pt`.
+    Named,
+    /// A grouped expression: `(1 + 2)`.
+    Group,
+    /// A unary operation: `-x`.
+    Unary,
+    /// A binary operation: `a + b`.
+    Binary,
+    /// An invocation of a function: `f(x, y)`.
+    Call,
+    /// A function call's argument list: `(x, y)`.
+    CallArgs,
+    /// A closure expression: `(x, y) => z`.
+    Closure,
+    /// A closure's parameters: `(x, y)`.
+    ClosureParams,
+    /// A parameter sink: `..x`.
+    Spread,
+    /// A template expression: `[*Hi* there!]`.
+    Template,
+    /// A block expression: `{ let x = 1; x + 2 }`.
+    Block,
+    /// A for loop expression: `for x in y { ... }`.
+    ForExpr,
+    /// A while loop expression: `while x { ... }`.
+    WhileExpr,
+    /// An if expression: `if x { ... }`.
+    IfExpr,
+    /// A let expression: `let x = 1`.
+    LetExpr,
+    /// The `with` expression: `with (1)`.
+    WithExpr,
+    /// A for loop's destructuring pattern: `x` or `x, y`.
+    ForPattern,
+    /// The import expression: `import x from "foo.typ"`.
+    ImportExpr,
+    /// Items to import: `a, b, c`.
+    ImportItems,
+    /// The include expression: `include "foo.typ"`.
+    IncludeExpr,
+    /// Two slashes followed by inner contents, terminated with a newline:
+    /// `//<str>\n`.
+    LineComment,
+    /// A slash and a star followed by inner contents,  terminated with a star
+    /// and a slash: `/*<str>*/`.
+    ///
+    /// The comment can contain nested block comments.
+    BlockComment,
+    /// Tokens that appear in the wrong place.
+    Error(ErrorPos, EcoString),
+    /// Unknown character sequences.
+    Unknown(EcoString),
+}
+
+/// Where in a node an error should be annotated.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ErrorPos {
+    /// At the start of the node.
+    Start,
+    /// Over the full width of the node.
+    Full,
+    /// At the end of the node.
+    End,
+}
+
+impl NodeKind {
+    /// Whether this is some kind of parenthesis.
+    pub fn is_paren(&self) -> bool {
+        matches!(self, Self::LeftParen | Self::RightParen)
+    }
+
+    /// Whether this is some kind of bracket.
+    pub fn is_bracket(&self) -> bool {
+        matches!(self, Self::LeftBracket | Self::RightBracket)
+    }
+
+    /// Whether this is some kind of brace.
+    pub fn is_brace(&self) -> bool {
+        matches!(self, Self::LeftBrace | Self::RightBrace)
+    }
+
+    /// Whether this is some kind of error.
+    pub fn is_error(&self) -> bool {
+        matches!(self, NodeKind::Error(_, _) | NodeKind::Unknown(_))
+    }
+
+    /// A human-readable name for the kind.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::LeftBracket => "opening bracket",
+            Self::RightBracket => "closing bracket",
+            Self::LeftBrace => "opening brace",
+            Self::RightBrace => "closing brace",
+            Self::LeftParen => "opening paren",
+            Self::RightParen => "closing paren",
+            Self::Star => "star",
+            Self::Comma => "comma",
+            Self::Semicolon => "semicolon",
+            Self::Colon => "colon",
+            Self::Plus => "plus",
+            Self::Minus => "minus",
+            Self::Slash => "slash",
+            Self::Eq => "assignment operator",
+            Self::EqEq => "equality operator",
+            Self::ExclEq => "inequality operator",
+            Self::Lt => "less-than operator",
+            Self::LtEq => "less-than or equal operator",
+            Self::Gt => "greater-than operator",
+            Self::GtEq => "greater-than or equal operator",
+            Self::PlusEq => "add-assign operator",
+            Self::HyphEq => "subtract-assign operator",
+            Self::StarEq => "multiply-assign operator",
+            Self::SlashEq => "divide-assign operator",
+            Self::Not => "operator `not`",
+            Self::And => "operator `and`",
+            Self::Or => "operator `or`",
+            Self::With => "operator `with`",
+            Self::Dots => "dots",
+            Self::Arrow => "arrow",
+            Self::None => "`none`",
+            Self::Auto => "`auto`",
+            Self::Let => "keyword `let`",
+            Self::If => "keyword `if`",
+            Self::Else => "keyword `else`",
+            Self::For => "keyword `for`",
+            Self::In => "keyword `in`",
+            Self::While => "keyword `while`",
+            Self::Break => "keyword `break`",
+            Self::Continue => "keyword `continue`",
+            Self::Return => "keyword `return`",
+            Self::Import => "keyword `import`",
+            Self::Include => "keyword `include`",
+            Self::From => "keyword `from`",
+            Self::Markup => "markup",
+            Self::Space(_) => "space",
+            Self::Linebreak => "forced linebreak",
+            Self::Parbreak => "paragraph break",
+            Self::Text(_) => "text",
+            Self::NonBreakingSpace => "non-breaking space",
+            Self::EnDash => "en dash",
+            Self::EmDash => "em dash",
+            Self::UnicodeEscape(_) => "unicode escape sequence",
+            Self::Strong => "strong",
+            Self::Emph => "emphasis",
+            Self::Heading => "heading",
+            Self::Enum => "enumeration item",
+            Self::EnumNumbering(_) => "enumeration item numbering",
+            Self::List => "list item",
+            Self::Raw(_) => "raw block",
+            Self::Math(_) => "math formula",
+            Self::Ident(_) => "identifier",
+            Self::Bool(_) => "boolean",
+            Self::Int(_) => "integer",
+            Self::Float(_) => "float",
+            Self::Length(_, _) => "length",
+            Self::Angle(_, _) => "angle",
+            Self::Percentage(_) => "percentage",
+            Self::Fraction(_) => "`fr` value",
+            Self::Str(_) => "string",
+            Self::Array => "array",
+            Self::Dict => "dictionary",
+            Self::Named => "named argument",
+            Self::Group => "group",
+            Self::Unary => "unary expression",
+            Self::Binary => "binary expression",
+            Self::Call => "call",
+            Self::CallArgs => "call arguments",
+            Self::Closure => "closure",
+            Self::ClosureParams => "closure parameters",
+            Self::Spread => "parameter sink",
+            Self::Template => "template",
+            Self::Block => "block",
+            Self::ForExpr => "for-loop expression",
+            Self::WhileExpr => "while-loop expression",
+            Self::IfExpr => "`if` expression",
+            Self::LetExpr => "`let` expression",
+            Self::WithExpr => "`with` expression",
+            Self::ForPattern => "for-loop destructuring pattern",
+            Self::ImportExpr => "`import` expression",
+            Self::ImportItems => "import items",
+            Self::IncludeExpr => "`include` expression",
+            Self::LineComment => "line comment",
+            Self::BlockComment => "block comment",
+            Self::Error(_, _) => "parse error",
+            Self::Unknown(src) => match src.as_str() {
+                "*/" => "end of block comment",
+                _ => "invalid token",
+            },
+        }
+    }
+}
+
+impl Display for NodeKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.pad(self.as_str())
+    }
+}
diff --git a/src/syntax/pretty.rs b/src/syntax/pretty.rs
index 3d02f39f..c453fb56 100644
--- a/src/syntax/pretty.rs
+++ b/src/syntax/pretty.rs
@@ -2,7 +2,7 @@
 
 use std::fmt::{self, Arguments, Write};
 
-use super::*;
+use super::ast::*;
 
 /// Pretty print an item and return the resulting string.
 pub fn pretty<T>(item: &T) -> String
@@ -46,20 +46,24 @@ impl Printer {
         Write::write_fmt(self, fmt)
     }
 
-    /// Write a list of items joined by a joiner.
-    pub fn join<T, I, F>(&mut self, items: I, joiner: &str, mut write_item: F)
+    /// Write a list of items joined by a joiner and return how many there were.
+    pub fn join<T, I, F>(&mut self, items: I, joiner: &str, mut write_item: F) -> usize
     where
         I: IntoIterator<Item = T>,
         F: FnMut(T, &mut Self),
     {
+        let mut count = 0;
         let mut iter = items.into_iter();
         if let Some(first) = iter.next() {
             write_item(first, self);
+            count += 1;
         }
         for item in iter {
             self.push_str(joiner);
             write_item(item, self);
+            count += 1;
         }
+        count
     }
 
     /// Finish pretty printing and return the underlying buffer.
@@ -77,7 +81,7 @@ impl Write for Printer {
 
 impl Pretty for Markup {
     fn pretty(&self, p: &mut Printer) {
-        for node in self {
+        for node in self.nodes() {
             node.pretty(p);
         }
     }
@@ -88,12 +92,13 @@ impl Pretty for MarkupNode {
         match self {
             // TODO: Handle escaping.
             Self::Space => p.push(' '),
-            Self::Linebreak(_) => p.push_str(r"\"),
-            Self::Parbreak(_) => p.push_str("\n\n"),
-            Self::Strong(_) => p.push('*'),
-            Self::Emph(_) => p.push('_'),
+            Self::Linebreak => p.push_str(r"\"),
+            Self::Parbreak => p.push_str("\n\n"),
+            Self::Strong => p.push('*'),
+            Self::Emph => p.push('_'),
             Self::Text(text) => p.push_str(text),
             Self::Raw(raw) => raw.pretty(p),
+            Self::Math(math) => math.pretty(p),
             Self::Heading(heading) => heading.pretty(p),
             Self::List(list) => list.pretty(p),
             Self::Enum(enum_) => enum_.pretty(p),
@@ -136,7 +141,7 @@ impl Pretty for RawNode {
 
         // Language tag.
         if let Some(lang) = &self.lang {
-            lang.pretty(p);
+            p.push_str(lang);
         }
 
         // Start untrimming.
@@ -163,38 +168,52 @@ impl Pretty for RawNode {
     }
 }
 
+impl Pretty for MathNode {
+    fn pretty(&self, p: &mut Printer) {
+        p.push('$');
+        if self.display {
+            p.push('[');
+        }
+        p.push_str(&self.formula);
+        if self.display {
+            p.push(']');
+        }
+        p.push('$');
+    }
+}
+
 impl Pretty for HeadingNode {
     fn pretty(&self, p: &mut Printer) {
-        for _ in 0 .. self.level {
+        for _ in 0 .. self.level() {
             p.push('=');
         }
         p.push(' ');
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
 impl Pretty for ListNode {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("- ");
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
 impl Pretty for EnumNode {
     fn pretty(&self, p: &mut Printer) {
-        if let Some(number) = self.number {
+        if let Some(number) = self.number() {
             write!(p, "{}", number).unwrap();
         }
         p.push_str(". ");
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
 impl Pretty for Expr {
     fn pretty(&self, p: &mut Printer) {
         match self {
-            Self::Ident(v) => v.pretty(p),
             Self::Lit(v) => v.pretty(p),
+            Self::Ident(v) => v.pretty(p),
             Self::Array(v) => v.pretty(p),
             Self::Dict(v) => v.pretty(p),
             Self::Template(v) => v.pretty(p),
@@ -217,17 +236,17 @@ impl Pretty for Expr {
 
 impl Pretty for Lit {
     fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::None(_) => p.push_str("none"),
-            Self::Auto(_) => p.push_str("auto"),
-            Self::Bool(_, v) => write!(p, "{}", v).unwrap(),
-            Self::Int(_, v) => write!(p, "{}", v).unwrap(),
-            Self::Float(_, v) => write!(p, "{}", v).unwrap(),
-            Self::Length(_, v, u) => write!(p, "{}{:?}", v, u).unwrap(),
-            Self::Angle(_, v, u) => write!(p, "{}{:?}", v, u).unwrap(),
-            Self::Percent(_, v) => write!(p, "{}%", v).unwrap(),
-            Self::Fractional(_, v) => write!(p, "{}fr", v).unwrap(),
-            Self::Str(_, v) => write!(p, "{:?}", v).unwrap(),
+        match self.kind() {
+            LitKind::None => p.push_str("none"),
+            LitKind::Auto => p.push_str("auto"),
+            LitKind::Bool(v) => write!(p, "{}", v).unwrap(),
+            LitKind::Int(v) => write!(p, "{}", v).unwrap(),
+            LitKind::Float(v) => write!(p, "{}", v).unwrap(),
+            LitKind::Length(v, u) => write!(p, "{}{:?}", v, u).unwrap(),
+            LitKind::Angle(v, u) => write!(p, "{}{:?}", v, u).unwrap(),
+            LitKind::Percent(v) => write!(p, "{}%", v).unwrap(),
+            LitKind::Fractional(v) => write!(p, "{}fr", v).unwrap(),
+            LitKind::Str(v) => write!(p, "{:?}", v).unwrap(),
         }
     }
 }
@@ -235,8 +254,10 @@ impl Pretty for Lit {
 impl Pretty for ArrayExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push('(');
-        p.join(&self.items, ", ", |item, p| item.pretty(p));
-        if self.items.len() == 1 {
+
+        let items = self.items();
+        let len = p.join(items, ", ", |item, p| item.pretty(p));
+        if len == 1 {
             p.push(',');
         }
         p.push(')');
@@ -246,10 +267,9 @@ impl Pretty for ArrayExpr {
 impl Pretty for DictExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push('(');
-        if self.items.is_empty() {
+        let len = p.join(self.items(), ", ", |named, p| named.pretty(p));
+        if len == 0 {
             p.push(':');
-        } else {
-            p.join(&self.items, ", ", |named, p| named.pretty(p));
         }
         p.push(')');
     }
@@ -257,16 +277,16 @@ impl Pretty for DictExpr {
 
 impl Pretty for Named {
     fn pretty(&self, p: &mut Printer) {
-        self.name.pretty(p);
+        self.name().pretty(p);
         p.push_str(": ");
-        self.expr.pretty(p);
+        self.expr().pretty(p);
     }
 }
 
 impl Pretty for TemplateExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push('[');
-        self.body.pretty(p);
+        self.body().pretty(p);
         p.push(']');
     }
 }
@@ -274,7 +294,7 @@ impl Pretty for TemplateExpr {
 impl Pretty for GroupExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push('(');
-        self.expr.pretty(p);
+        self.expr().pretty(p);
         p.push(')');
     }
 }
@@ -282,11 +302,11 @@ impl Pretty for GroupExpr {
 impl Pretty for BlockExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push('{');
-        if self.exprs.len() > 1 {
+        if self.exprs().count() > 1 {
             p.push(' ');
         }
-        p.join(&self.exprs, "; ", |expr, p| expr.pretty(p));
-        if self.exprs.len() > 1 {
+        let len = p.join(self.exprs(), "; ", |expr, p| expr.pretty(p));
+        if len > 1 {
             p.push(' ');
         }
         p.push('}');
@@ -295,11 +315,12 @@ impl Pretty for BlockExpr {
 
 impl Pretty for UnaryExpr {
     fn pretty(&self, p: &mut Printer) {
-        self.op.pretty(p);
-        if self.op == UnOp::Not {
+        let op = self.op();
+        op.pretty(p);
+        if op == UnOp::Not {
             p.push(' ');
         }
-        self.expr.pretty(p);
+        self.expr().pretty(p);
     }
 }
 
@@ -311,11 +332,11 @@ impl Pretty for UnOp {
 
 impl Pretty for BinaryExpr {
     fn pretty(&self, p: &mut Printer) {
-        self.lhs.pretty(p);
+        self.lhs().pretty(p);
         p.push(' ');
-        self.op.pretty(p);
+        self.op().pretty(p);
         p.push(' ');
-        self.rhs.pretty(p);
+        self.rhs().pretty(p);
     }
 }
 
@@ -327,7 +348,7 @@ impl Pretty for BinOp {
 
 impl Pretty for CallExpr {
     fn pretty(&self, p: &mut Printer) {
-        self.callee.pretty(p);
+        self.callee().pretty(p);
 
         let mut write_args = |items: &[CallArg]| {
             p.push('(');
@@ -335,7 +356,8 @@ impl Pretty for CallExpr {
             p.push(')');
         };
 
-        match self.args.items.as_slice() {
+        let args: Vec<_> = self.args().items().collect();
+        match args.as_slice() {
             // This can be moved behind the arguments.
             //
             // Example: Transforms "#v(a, [b])" => "#v(a)[b]".
@@ -345,7 +367,6 @@ impl Pretty for CallExpr {
                 }
                 template.pretty(p);
             }
-
             items => write_args(items),
         }
     }
@@ -353,7 +374,7 @@ impl Pretty for CallExpr {
 
 impl Pretty for CallArgs {
     fn pretty(&self, p: &mut Printer) {
-        p.join(&self.items, ", ", |item, p| item.pretty(p));
+        p.join(self.items(), ", ", |item, p| item.pretty(p));
     }
 }
 
@@ -372,15 +393,16 @@ impl Pretty for CallArg {
 
 impl Pretty for ClosureExpr {
     fn pretty(&self, p: &mut Printer) {
-        if let [param] = self.params.as_slice() {
+        let params: Vec<_> = self.params().collect();
+        if let [param] = params.as_slice() {
             param.pretty(p);
         } else {
             p.push('(');
-            p.join(self.params.iter(), ", ", |item, p| item.pretty(p));
+            p.join(params.iter(), ", ", |item, p| item.pretty(p));
             p.push(')');
         }
         p.push_str(" => ");
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
@@ -399,9 +421,9 @@ impl Pretty for ClosureParam {
 
 impl Pretty for WithExpr {
     fn pretty(&self, p: &mut Printer) {
-        self.callee.pretty(p);
+        self.callee().pretty(p);
         p.push_str(" with (");
-        self.args.pretty(p);
+        self.args().pretty(p);
         p.push(')');
     }
 }
@@ -409,13 +431,13 @@ impl Pretty for WithExpr {
 impl Pretty for LetExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("let ");
-        self.binding.pretty(p);
-        if let Some(Expr::Closure(closure)) = &self.init {
+        self.binding().pretty(p);
+        if let Some(Expr::Closure(closure)) = self.init() {
             p.push('(');
-            p.join(closure.params.iter(), ", ", |item, p| item.pretty(p));
+            p.join(closure.params(), ", ", |item, p| item.pretty(p));
             p.push_str(") = ");
-            closure.body.pretty(p);
-        } else if let Some(init) = &self.init {
+            closure.body().pretty(p);
+        } else if let Some(init) = self.init() {
             p.push_str(" = ");
             init.pretty(p);
         }
@@ -425,10 +447,10 @@ impl Pretty for LetExpr {
 impl Pretty for IfExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("if ");
-        self.condition.pretty(p);
+        self.condition().pretty(p);
         p.push(' ');
-        self.if_body.pretty(p);
-        if let Some(expr) = &self.else_body {
+        self.if_body().pretty(p);
+        if let Some(expr) = self.else_body() {
             p.push_str(" else ");
             expr.pretty(p);
         }
@@ -438,42 +460,40 @@ impl Pretty for IfExpr {
 impl Pretty for WhileExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("while ");
-        self.condition.pretty(p);
+        self.condition().pretty(p);
         p.push(' ');
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
 impl Pretty for ForExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("for ");
-        self.pattern.pretty(p);
+        self.pattern().pretty(p);
         p.push_str(" in ");
-        self.iter.pretty(p);
+        self.iter().pretty(p);
         p.push(' ');
-        self.body.pretty(p);
+        self.body().pretty(p);
     }
 }
 
 impl Pretty for ForPattern {
     fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::Value(v) => v.pretty(p),
-            Self::KeyValue(k, v) => {
-                k.pretty(p);
-                p.push_str(", ");
-                v.pretty(p);
-            }
+        if let Some(key) = self.key() {
+            key.pretty(p);
+            p.push_str(", ");
         }
+
+        self.value().pretty(p);
     }
 }
 
 impl Pretty for ImportExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("import ");
-        self.imports.pretty(p);
+        self.imports().pretty(p);
         p.push_str(" from ");
-        self.path.pretty(p);
+        self.path().pretty(p);
     }
 }
 
@@ -481,7 +501,9 @@ impl Pretty for Imports {
     fn pretty(&self, p: &mut Printer) {
         match self {
             Self::Wildcard => p.push('*'),
-            Self::Idents(idents) => p.join(idents, ", ", |item, p| item.pretty(p)),
+            Self::Items(idents) => {
+                p.join(idents, ", ", |item, p| item.pretty(p));
+            }
         }
     }
 }
@@ -489,20 +511,19 @@ impl Pretty for Imports {
 impl Pretty for IncludeExpr {
     fn pretty(&self, p: &mut Printer) {
         p.push_str("include ");
-        self.path.pretty(p);
+        self.path().pretty(p);
     }
 }
 
 impl Pretty for Ident {
     fn pretty(&self, p: &mut Printer) {
-        p.push_str(self.as_str());
+        p.push_str(self);
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parse::parse;
     use crate::source::SourceFile;
 
     #[track_caller]
@@ -513,7 +534,7 @@ mod tests {
     #[track_caller]
     fn test_parse(src: &str, expected: &str) {
         let source = SourceFile::detached(src);
-        let ast = parse(&source).unwrap();
+        let ast = source.ast().unwrap();
         let found = pretty(&ast);
         if found != expected {
             println!("tree:     {:#?}", ast);
@@ -551,6 +572,11 @@ mod tests {
         test_parse("``` 1```", "`1`");
         test_parse("``` 1 ```", "`1 `");
         test_parse("```` ` ````", "``` ` ```");
+
+        // Math node.
+        roundtrip("$$");
+        roundtrip("$a+b$");
+        roundtrip("$[ a^2 + b^2 = c^2 ]$");
     }
 
     #[test]
diff --git a/src/syntax/span.rs b/src/syntax/span.rs
index bfb9e755..47d96589 100644
--- a/src/syntax/span.rs
+++ b/src/syntax/span.rs
@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt::{self, Debug, Formatter};
-use std::ops::{Add, Range};
+use std::ops::Range;
 
 use serde::{Deserialize, Serialize};
 
@@ -53,23 +53,19 @@ pub struct Span {
     /// The id of the source file.
     pub source: SourceId,
     /// The inclusive start position.
-    pub start: Pos,
+    pub start: usize,
     /// The inclusive end position.
-    pub end: Pos,
+    pub end: usize,
 }
 
 impl Span {
     /// Create a new span from start and end positions.
-    pub fn new(source: SourceId, start: impl Into<Pos>, end: impl Into<Pos>) -> Self {
-        Self {
-            source,
-            start: start.into(),
-            end: end.into(),
-        }
+    pub fn new(source: SourceId, start: usize, end: usize) -> Self {
+        Self { source, start, end }
     }
 
     /// Create a span including just a single position.
-    pub fn at(source: SourceId, pos: impl Into<Pos> + Copy) -> Self {
+    pub fn at(source: SourceId, pos: usize) -> Self {
         Self::new(source, pos, pos)
     }
 
@@ -77,19 +73,34 @@ impl Span {
     pub fn detached() -> Self {
         Self {
             source: SourceId::from_raw(0),
-            start: Pos::ZERO,
-            end: Pos::ZERO,
+            start: 0,
+            end: 0,
         }
     }
 
     /// Create a span with a different start position.
-    pub fn with_start(self, start: impl Into<Pos>) -> Self {
-        Self { start: start.into(), ..self }
+    pub fn with_start(self, start: usize) -> Self {
+        Self { start, ..self }
     }
 
     /// Create a span with a different end position.
-    pub fn with_end(self, end: impl Into<Pos>) -> Self {
-        Self { end: end.into(), ..self }
+    pub fn with_end(self, end: usize) -> Self {
+        Self { end, ..self }
+    }
+
+    /// The byte length of the spanned region.
+    pub fn len(self) -> usize {
+        self.end - self.start
+    }
+
+    /// A new span at the position of this span's start.
+    pub fn at_start(&self) -> Span {
+        Self::at(self.source, self.start)
+    }
+
+    /// A new span at the position of this span's end.
+    pub fn at_end(&self) -> Span {
+        Self::at(self.source, self.end)
     }
 
     /// Create a new span with the earlier start and later end position.
@@ -109,14 +120,19 @@ impl Span {
         *self = self.join(other)
     }
 
+    /// Test whether a position is within the span.
+    pub fn contains(&self, pos: usize) -> bool {
+        self.start <= pos && self.end >= pos
+    }
+
     /// Test whether one span complete contains the other span.
-    pub fn contains(self, other: Self) -> bool {
+    pub fn surrounds(self, other: Self) -> bool {
         self.source == other.source && self.start <= other.start && self.end >= other.end
     }
 
-    /// Convert to a `Range<Pos>` for indexing.
+    /// Convert to a `Range<usize>` for indexing.
     pub fn to_range(self) -> Range<usize> {
-        self.start.to_usize() .. self.end.to_usize()
+        self.start .. self.end
     }
 }
 
@@ -135,77 +151,3 @@ impl PartialOrd for Span {
         }
     }
 }
-
-/// A byte position in source code.
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
-pub struct Pos(pub u32);
-
-impl Pos {
-    /// The zero position.
-    pub const ZERO: Self = Self(0);
-
-    /// Convert to a usize for indexing.
-    pub fn to_usize(self) -> usize {
-        self.0 as usize
-    }
-}
-
-impl Debug for Pos {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        Debug::fmt(&self.0, f)
-    }
-}
-
-impl From<u32> for Pos {
-    fn from(index: u32) -> Self {
-        Self(index)
-    }
-}
-
-impl From<usize> for Pos {
-    fn from(index: usize) -> Self {
-        Self(index as u32)
-    }
-}
-
-impl<T> Add<T> for Pos
-where
-    T: Into<Pos>,
-{
-    type Output = Self;
-
-    fn add(self, rhs: T) -> Self {
-        Pos(self.0 + rhs.into().0)
-    }
-}
-
-/// Convert a position or range into a span.
-pub trait IntoSpan {
-    /// Convert into a span by providing the source id.
-    fn into_span(self, source: SourceId) -> Span;
-}
-
-impl IntoSpan for Span {
-    fn into_span(self, source: SourceId) -> Span {
-        debug_assert_eq!(self.source, source);
-        self
-    }
-}
-
-impl IntoSpan for Pos {
-    fn into_span(self, source: SourceId) -> Span {
-        Span::new(source, self, self)
-    }
-}
-
-impl IntoSpan for usize {
-    fn into_span(self, source: SourceId) -> Span {
-        Span::new(source, self, self)
-    }
-}
-
-impl IntoSpan for Range<usize> {
-    fn into_span(self, source: SourceId) -> Span {
-        Span::new(source, self.start, self.end)
-    }
-}
diff --git a/src/syntax/token.rs b/src/syntax/token.rs
deleted file mode 100644
index 22dd104b..00000000
--- a/src/syntax/token.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-use crate::geom::{AngularUnit, LengthUnit};
-
-/// A minimal semantic entity of source code.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Token<'s> {
-    /// A left square bracket: `[`.
-    LeftBracket,
-    /// A right square bracket: `]`.
-    RightBracket,
-    /// A left curly brace: `{`.
-    LeftBrace,
-    /// A right curly brace: `}`.
-    RightBrace,
-    /// A left round parenthesis: `(`.
-    LeftParen,
-    /// A right round parenthesis: `)`.
-    RightParen,
-    /// An asterisk: `*`.
-    Star,
-    /// An underscore: `_`.
-    Underscore,
-    /// A tilde: `~`.
-    Tilde,
-    /// Two hyphens: `--`.
-    HyphHyph,
-    /// Three hyphens: `---`.
-    HyphHyphHyph,
-    /// A backslash followed by nothing or whitespace: `\`.
-    Backslash,
-    /// A comma: `,`.
-    Comma,
-    /// A semicolon: `;`.
-    Semicolon,
-    /// A colon: `:`.
-    Colon,
-    /// A plus: `+`.
-    Plus,
-    /// A hyphen: `-`.
-    Hyph,
-    /// A slash: `/`.
-    Slash,
-    /// A single equals sign: `=`.
-    Eq,
-    /// Two equals signs: `==`.
-    EqEq,
-    /// An exclamation mark followed by an equals sign: `!=`.
-    ExclEq,
-    /// A less-than sign: `<`.
-    Lt,
-    /// A less-than sign followed by an equals sign: `<=`.
-    LtEq,
-    /// A greater-than sign: `>`.
-    Gt,
-    /// A greater-than sign followed by an equals sign: `>=`.
-    GtEq,
-    /// A plus followed by an equals sign: `+=`.
-    PlusEq,
-    /// A hyphen followed by an equals sign: `-=`.
-    HyphEq,
-    /// An asterisk followed by an equals sign: `*=`.
-    StarEq,
-    /// A slash followed by an equals sign: `/=`.
-    SlashEq,
-    /// Two dots: `..`.
-    Dots,
-    /// An equals sign followed by a greater-than sign: `=>`.
-    Arrow,
-    /// The `not` operator.
-    Not,
-    /// The `and` operator.
-    And,
-    /// The `or` operator.
-    Or,
-    /// The `with` operator.
-    With,
-    /// The none literal: `none`.
-    None,
-    /// The auto literal: `auto`.
-    Auto,
-    /// The `let` keyword.
-    Let,
-    /// The `if` keyword.
-    If,
-    /// The `else` keyword.
-    Else,
-    /// The `for` keyword.
-    For,
-    /// The `in` keyword.
-    In,
-    /// The `while` keyword.
-    While,
-    /// The `break` keyword.
-    Break,
-    /// The `continue` keyword.
-    Continue,
-    /// The `return` keyword.
-    Return,
-    /// The `import` keyword.
-    Import,
-    /// The `include` keyword.
-    Include,
-    /// The `from` keyword.
-    From,
-    /// One or more whitespace characters.
-    ///
-    /// The contained `usize` denotes the number of newlines that were contained
-    /// in the whitespace.
-    Space(usize),
-    /// A consecutive non-markup string.
-    Text(&'s str),
-    /// A slash and the letter "u" followed by a hexadecimal unicode entity
-    /// enclosed in curly braces: `\u{1F5FA}`.
-    UnicodeEscape(UnicodeEscapeToken<'s>),
-    /// An arbitrary number of backticks followed by inner contents, terminated
-    /// with the same number of backticks: `` `...` ``.
-    Raw(RawToken<'s>),
-    /// One or two dollar signs followed by inner contents, terminated with the
-    /// same number of dollar signs.
-    Math(MathToken<'s>),
-    /// A numbering: `23.`.
-    ///
-    /// Can also exist without the number: `.`.
-    Numbering(Option<usize>),
-    /// An identifier: `center`.
-    Ident(&'s str),
-    /// A boolean: `true`, `false`.
-    Bool(bool),
-    /// An integer: `120`.
-    Int(i64),
-    /// A floating-point number: `1.2`, `10e-4`.
-    Float(f64),
-    /// A length: `12pt`, `3cm`.
-    Length(f64, LengthUnit),
-    /// An angle: `90deg`.
-    Angle(f64, AngularUnit),
-    /// A percentage: `50%`.
-    ///
-    /// _Note_: `50%` is stored as `50.0` here, as in the corresponding
-    /// [literal](super::Lit::Percent).
-    Percent(f64),
-    /// A fraction unit: `3fr`.
-    Fraction(f64),
-    /// A quoted string: `"..."`.
-    Str(StrToken<'s>),
-    /// Two slashes followed by inner contents, terminated with a newline:
-    /// `//<str>\n`.
-    LineComment(&'s str),
-    /// A slash and a star followed by inner contents,  terminated with a star
-    /// and a slash: `/*<str>*/`.
-    ///
-    /// The comment can contain nested block comments.
-    BlockComment(&'s str),
-    /// Things that are not valid tokens.
-    Invalid(&'s str),
-}
-
-/// A quoted string token: `"..."`.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct StrToken<'s> {
-    /// The string inside the quotes.
-    ///
-    /// _Note_: If the string contains escape sequences these are not yet
-    /// applied to be able to just store a string slice here instead of
-    /// a `String`. The resolving is done later in the parser.
-    pub string: &'s str,
-    /// Whether the closing quote was present.
-    pub terminated: bool,
-}
-
-/// A raw block token: `` `...` ``.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct RawToken<'s> {
-    /// The raw text between the backticks.
-    pub text: &'s str,
-    /// The number of opening backticks.
-    pub backticks: usize,
-    /// Whether all closing backticks were present.
-    pub terminated: bool,
-}
-
-/// A math formula token: `$2pi + x$` or `$[f'(x) = x^2]$`.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct MathToken<'s> {
-    /// The formula between the dollars.
-    pub formula: &'s str,
-    /// Whether the formula is display-level, that is, it is surrounded by
-    /// `$[..]`.
-    pub display: bool,
-    /// Whether the closing dollars were present.
-    pub terminated: bool,
-}
-
-/// A unicode escape sequence token: `\u{1F5FA}`.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct UnicodeEscapeToken<'s> {
-    /// The escape sequence between the braces.
-    pub sequence: &'s str,
-    /// Whether the closing brace was present.
-    pub terminated: bool,
-}
-
-impl<'s> Token<'s> {
-    /// The English name of this token for use in error messages.
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::LeftBracket => "opening bracket",
-            Self::RightBracket => "closing bracket",
-            Self::LeftBrace => "opening brace",
-            Self::RightBrace => "closing brace",
-            Self::LeftParen => "opening paren",
-            Self::RightParen => "closing paren",
-            Self::Star => "star",
-            Self::Underscore => "underscore",
-            Self::Tilde => "tilde",
-            Self::HyphHyph => "en dash",
-            Self::HyphHyphHyph => "em dash",
-            Self::Backslash => "backslash",
-            Self::Comma => "comma",
-            Self::Semicolon => "semicolon",
-            Self::Colon => "colon",
-            Self::Plus => "plus",
-            Self::Hyph => "minus",
-            Self::Slash => "slash",
-            Self::Eq => "assignment operator",
-            Self::EqEq => "equality operator",
-            Self::ExclEq => "inequality operator",
-            Self::Lt => "less-than operator",
-            Self::LtEq => "less-than or equal operator",
-            Self::Gt => "greater-than operator",
-            Self::GtEq => "greater-than or equal operator",
-            Self::PlusEq => "add-assign operator",
-            Self::HyphEq => "subtract-assign operator",
-            Self::StarEq => "multiply-assign operator",
-            Self::SlashEq => "divide-assign operator",
-            Self::Dots => "dots",
-            Self::Arrow => "arrow",
-            Self::Not => "operator `not`",
-            Self::And => "operator `and`",
-            Self::Or => "operator `or`",
-            Self::With => "operator `with`",
-            Self::None => "`none`",
-            Self::Auto => "`auto`",
-            Self::Let => "keyword `let`",
-            Self::If => "keyword `if`",
-            Self::Else => "keyword `else`",
-            Self::For => "keyword `for`",
-            Self::In => "keyword `in`",
-            Self::While => "keyword `while`",
-            Self::Break => "keyword `break`",
-            Self::Continue => "keyword `continue`",
-            Self::Return => "keyword `return`",
-            Self::Import => "keyword `import`",
-            Self::Include => "keyword `include`",
-            Self::From => "keyword `from`",
-            Self::Space(_) => "space",
-            Self::Text(_) => "text",
-            Self::UnicodeEscape(_) => "unicode escape sequence",
-            Self::Raw(_) => "raw block",
-            Self::Math(_) => "math formula",
-            Self::Numbering(_) => "numbering",
-            Self::Ident(_) => "identifier",
-            Self::Bool(_) => "boolean",
-            Self::Int(_) => "integer",
-            Self::Float(_) => "float",
-            Self::Length(_, _) => "length",
-            Self::Angle(_, _) => "angle",
-            Self::Percent(_) => "percentage",
-            Self::Fraction(_) => "`fr` value",
-            Self::Str(_) => "string",
-            Self::LineComment(_) => "line comment",
-            Self::BlockComment(_) => "block comment",
-            Self::Invalid("*/") => "end of block comment",
-            Self::Invalid(_) => "invalid token",
-        }
-    }
-}
diff --git a/src/syntax/visit.rs b/src/syntax/visit.rs
deleted file mode 100644
index 40e8eb93..00000000
--- a/src/syntax/visit.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-//! Mutable and immutable syntax tree traversal.
-
-use super::*;
-
-/// Implement the immutable and the mutable visitor version.
-macro_rules! impl_visitors {
-    ($($name:ident($($tts:tt)*) $body:block)*) => {
-        macro_rules! r {
-            (rc: $x:expr) => { $x.as_ref() };
-            ($x:expr) => { &$x };
-        }
-
-        impl_visitor! {
-            Visit,
-            immutable,
-            immutably,
-            [$(($name($($tts)*) $body))*]
-        }
-
-        macro_rules! r {
-            (rc: $x:expr) => { std::rc::Rc::make_mut(&mut $x) };
-            ($x:expr) => { &mut $x };
-        }
-
-        impl_visitor! {
-            VisitMut,
-            mutable,
-            mutably,
-            [$(($name($($tts)*) $body mut))*] mut
-        }
-    };
-}
-
-/// Implement an immutable or mutable visitor.
-macro_rules! impl_visitor {
-    (
-        $visit:ident,
-        $mutability:ident,
-        $adjective:ident,
-        [$((
-            $name:ident($v:ident, $node:ident: $ty:ty)
-            $body:block
-            $($fmut:tt)?
-        ))*]
-        $($mut:tt)?
-    ) => {
-        #[doc = concat!("Visit syntax trees ", stringify!($adjective), ".")]
-        pub trait $visit<'ast> {
-            /// Visit a definition of a binding.
-            ///
-            /// Bindings are, for example, left-hand side of let expressions,
-            /// and key/value patterns in for loops.
-            fn visit_binding(&mut self, _: &'ast $($mut)? Ident) {}
-
-            /// Visit the entry into a scope.
-            fn visit_enter(&mut self) {}
-
-            /// Visit the exit from a scope.
-            fn visit_exit(&mut self) {}
-
-            $(fn $name(&mut self, $node: &'ast $($fmut)? $ty) {
-                $mutability::$name(self, $node);
-            })*
-        }
-
-        #[doc = concat!("Visitor functions that are ", stringify!($mutability), ".")]
-        pub mod $mutability {
-            use super::*;
-            $(
-                #[doc = concat!("Visit a node of type [`", stringify!($ty), "`].")]
-                pub fn $name<'ast, V>($v: &mut V, $node: &'ast $($fmut)? $ty)
-                where
-                    V: $visit<'ast> + ?Sized
-                $body
-            )*
-        }
-    };
-}
-
-impl_visitors! {
-    visit_tree(v, markup: Markup) {
-        for node in markup {
-            v.visit_node(node);
-        }
-    }
-
-    visit_node(v, node: MarkupNode) {
-        match node {
-            MarkupNode::Space => {}
-            MarkupNode::Linebreak(_) => {}
-            MarkupNode::Parbreak(_) => {}
-            MarkupNode::Strong(_) => {}
-            MarkupNode::Emph(_) => {}
-            MarkupNode::Text(_) => {}
-            MarkupNode::Raw(_) => {}
-            MarkupNode::Heading(n) => v.visit_heading(n),
-            MarkupNode::List(n) => v.visit_list(n),
-            MarkupNode::Enum(n) => v.visit_enum(n),
-            MarkupNode::Expr(n) => v.visit_expr(n),
-        }
-    }
-
-    visit_heading(v, heading: HeadingNode) {
-        v.visit_tree(r!(heading.body));
-    }
-
-    visit_list(v, list: ListNode) {
-        v.visit_tree(r!(list.body));
-    }
-
-    visit_enum(v, enum_: EnumNode) {
-        v.visit_tree(r!(enum_.body));
-    }
-
-    visit_expr(v, expr: Expr) {
-        match expr {
-            Expr::Ident(_) => {}
-            Expr::Lit(_) => {},
-            Expr::Array(e) => v.visit_array(e),
-            Expr::Dict(e) => v.visit_dict(e),
-            Expr::Template(e) => v.visit_template(e),
-            Expr::Group(e) => v.visit_group(e),
-            Expr::Block(e) => v.visit_block(e),
-            Expr::Unary(e) => v.visit_unary(e),
-            Expr::Binary(e) => v.visit_binary(e),
-            Expr::Call(e) => v.visit_call(e),
-            Expr::Closure(e) => v.visit_closure(e),
-            Expr::With(e) => v.visit_with(e),
-            Expr::Let(e) => v.visit_let(e),
-            Expr::If(e) => v.visit_if(e),
-            Expr::While(e) => v.visit_while(e),
-            Expr::For(e) => v.visit_for(e),
-            Expr::Import(e) => v.visit_import(e),
-            Expr::Include(e) => v.visit_include(e),
-        }
-    }
-
-    visit_array(v, array: ArrayExpr) {
-        for expr in r!(array.items) {
-            v.visit_expr(expr);
-        }
-    }
-
-    visit_dict(v, dict: DictExpr) {
-        for named in r!(dict.items) {
-            v.visit_expr(r!(named.expr));
-        }
-    }
-
-    visit_template(v, template: TemplateExpr) {
-        v.visit_enter();
-        v.visit_tree(r!(template.body));
-        v.visit_exit();
-    }
-
-    visit_group(v, group: GroupExpr) {
-        v.visit_expr(r!(group.expr));
-    }
-
-    visit_block(v, block: BlockExpr) {
-        v.visit_enter();
-        for expr in r!(block.exprs) {
-            v.visit_expr(expr);
-        }
-        v.visit_exit();
-    }
-
-    visit_binary(v, binary: BinaryExpr) {
-        v.visit_expr(r!(binary.lhs));
-        v.visit_expr(r!(binary.rhs));
-    }
-
-    visit_unary(v, unary: UnaryExpr) {
-        v.visit_expr(r!(unary.expr));
-    }
-
-    visit_call(v, call: CallExpr) {
-        v.visit_expr(r!(call.callee));
-        v.visit_args(r!(call.args));
-    }
-
-    visit_args(v, args: CallArgs) {
-        for arg in r!(args.items) {
-            v.visit_arg(arg);
-        }
-    }
-
-    visit_arg(v, arg: CallArg) {
-        match arg {
-            CallArg::Pos(expr) => v.visit_expr(expr),
-            CallArg::Named(named) => v.visit_expr(r!(named.expr)),
-            CallArg::Spread(expr) => v.visit_expr(expr),
-        }
-    }
-
-    visit_closure(v, closure: ClosureExpr) {
-        for param in r!(closure.params) {
-            v.visit_param(param);
-        }
-        v.visit_expr(r!(rc: closure.body));
-    }
-
-    visit_param(v, param: ClosureParam) {
-        match param {
-            ClosureParam::Pos(binding) => v.visit_binding(binding),
-            ClosureParam::Named(named) => {
-                v.visit_binding(r!(named.name));
-                v.visit_expr(r!(named.expr));
-            }
-            ClosureParam::Sink(binding) => v.visit_binding(binding),
-        }
-    }
-
-    visit_with(v, with_expr: WithExpr) {
-        v.visit_expr(r!(with_expr.callee));
-        v.visit_args(r!(with_expr.args));
-    }
-
-    visit_let(v, let_expr: LetExpr) {
-        if let Some(init) = r!(let_expr.init) {
-            v.visit_expr(init);
-        }
-        v.visit_binding(r!(let_expr.binding));
-    }
-
-    visit_if(v, if_expr: IfExpr) {
-        v.visit_expr(r!(if_expr.condition));
-        v.visit_expr(r!(if_expr.if_body));
-        if let Some(body) = r!(if_expr.else_body) {
-            v.visit_expr(body);
-        }
-    }
-
-    visit_while(v, while_expr: WhileExpr) {
-        v.visit_expr(r!(while_expr.condition));
-        v.visit_expr(r!(while_expr.body));
-    }
-
-    visit_for(v, for_expr: ForExpr) {
-        v.visit_expr(r!(for_expr.iter));
-        match r!(for_expr.pattern) {
-            ForPattern::Value(value) => v.visit_binding(value),
-            ForPattern::KeyValue(key, value) => {
-                v.visit_binding(key);
-                v.visit_binding(value);
-            }
-        }
-        v.visit_expr(r!(for_expr.body));
-    }
-
-    visit_import(v, import_expr: ImportExpr) {
-        v.visit_expr(r!(import_expr.path));
-        if let Imports::Idents(idents) = r!(import_expr.imports) {
-            for ident in idents {
-                v.visit_binding(ident);
-            }
-        }
-    }
-
-    visit_include(v, include_expr: IncludeExpr) {
-        v.visit_expr(r!(include_expr.path));
-    }
-}