summaryrefslogtreecommitdiff
path: root/src/syntax/ast.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/syntax/ast.rs')
-rw-r--r--src/syntax/ast.rs1994
1 files changed, 0 insertions, 1994 deletions
diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
deleted file mode 100644
index 7d5e2989..00000000
--- a/src/syntax/ast.rs
+++ /dev/null
@@ -1,1994 +0,0 @@
-//! A typed layer over the untyped syntax tree.
-//!
-//! The AST is rooted in the [`Markup`] node.
-
-use std::num::NonZeroUsize;
-use std::ops::Deref;
-
-use ecow::EcoString;
-use unscanny::Scanner;
-
-use super::{
- is_id_continue, is_id_start, is_newline, split_newlines, Span, SyntaxKind, SyntaxNode,
-};
-use crate::geom::{AbsUnit, AngleUnit};
-use crate::util::NonZeroExt;
-
-/// A typed AST node.
-pub trait AstNode: Sized {
- /// Convert a node into its typed variant.
- fn from_untyped(node: &SyntaxNode) -> Option<Self>;
-
- /// A reference to the underlying syntax node.
- fn as_untyped(&self) -> &SyntaxNode;
-
- /// The source code location.
- fn span(&self) -> Span {
- self.as_untyped().span()
- }
-}
-
-macro_rules! node {
- ($(#[$attr:meta])* $name:ident) => {
- #[derive(Debug, Default, Clone, Hash)]
- #[repr(transparent)]
- $(#[$attr])*
- pub struct $name(SyntaxNode);
-
- impl AstNode for $name {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- if matches!(node.kind(), SyntaxKind::$name) {
- Some(Self(node.clone()))
- } else {
- Option::None
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- &self.0
- }
- }
- };
-}
-
-node! {
- /// The syntactical root capable of representing a full parsed document.
- Markup
-}
-
-impl Markup {
- /// The expressions.
- pub fn exprs(&self) -> impl DoubleEndedIterator<Item = Expr> + '_ {
- let mut was_stmt = false;
- self.0
- .children()
- .filter(move |node| {
- // Ignore newline directly after statements without semicolons.
- let kind = node.kind();
- let keep = !was_stmt || node.kind() != SyntaxKind::Space;
- was_stmt = kind.is_stmt();
- keep
- })
- .filter_map(Expr::cast_with_space)
- }
-}
-
-/// An expression in markup, math or code.
-#[derive(Debug, Clone, Hash)]
-pub enum Expr {
- /// Plain text without markup.
- Text(Text),
- /// Whitespace in markup or math. Has at most one newline in markup, as more
- /// indicate a paragraph break.
- Space(Space),
- /// A forced line break: `\`.
- Linebreak(Linebreak),
- /// A paragraph break, indicated by one or multiple blank lines.
- Parbreak(Parbreak),
- /// An escape sequence: `\#`, `\u{1F5FA}`.
- Escape(Escape),
- /// A shorthand for a unicode codepoint. For example, `~` for non-breaking
- /// space or `-?` for a soft hyphen.
- Shorthand(Shorthand),
- /// A smart quote: `'` or `"`.
- SmartQuote(SmartQuote),
- /// Strong content: `*Strong*`.
- Strong(Strong),
- /// Emphasized content: `_Emphasized_`.
- Emph(Emph),
- /// Raw text with optional syntax highlighting: `` `...` ``.
- Raw(Raw),
- /// A hyperlink: `https://typst.org`.
- Link(Link),
- /// A label: `<intro>`.
- Label(Label),
- /// A reference: `@target`, `@target[..]`.
- Ref(Ref),
- /// A section heading: `= Introduction`.
- Heading(Heading),
- /// An item in a bullet list: `- ...`.
- List(ListItem),
- /// An item in an enumeration (numbered list): `+ ...` or `1. ...`.
- Enum(EnumItem),
- /// An item in a term list: `/ Term: Details`.
- Term(TermItem),
- /// A mathematical equation: `$x$`, `$ x^2 $`.
- Equation(Equation),
- /// The contents of a mathematical equation: `x^2 + 1`.
- Math(Math),
- /// An identifier in math: `pi`.
- MathIdent(MathIdent),
- /// An alignment point in math: `&`.
- MathAlignPoint(MathAlignPoint),
- /// Matched delimiters in math: `[x + y]`.
- MathDelimited(MathDelimited),
- /// A base with optional attachments in math: `a_1^2`.
- MathAttach(MathAttach),
- /// A fraction in math: `x/2`.
- MathFrac(MathFrac),
- /// A root in math: `√x`, `∛x` or `∜x`.
- MathRoot(MathRoot),
- /// An identifier: `left`.
- Ident(Ident),
- /// The `none` literal.
- None(None),
- /// The `auto` literal.
- Auto(Auto),
- /// A boolean: `true`, `false`.
- Bool(Bool),
- /// An integer: `120`.
- Int(Int),
- /// A floating-point number: `1.2`, `10e-4`.
- Float(Float),
- /// A numeric value with a unit: `12pt`, `3cm`, `2em`, `90deg`, `50%`.
- Numeric(Numeric),
- /// A quoted string: `"..."`.
- Str(Str),
- /// A code block: `{ let x = 1; x + 2 }`.
- Code(CodeBlock),
- /// A content block: `[*Hi* there!]`.
- Content(ContentBlock),
- /// A grouped expression: `(1 + 2)`.
- Parenthesized(Parenthesized),
- /// An array: `(1, "hi", 12cm)`.
- Array(Array),
- /// A dictionary: `(thickness: 3pt, pattern: dashed)`.
- Dict(Dict),
- /// A unary operation: `-x`.
- Unary(Unary),
- /// A binary operation: `a + b`.
- Binary(Binary),
- /// A field access: `properties.age`.
- FieldAccess(FieldAccess),
- /// An invocation of a function or method: `f(x, y)`.
- FuncCall(FuncCall),
- /// A closure: `(x, y) => z`.
- Closure(Closure),
- /// A let binding: `let x = 1`.
- Let(LetBinding),
- //// A destructuring assignment: `(x, y) = (1, 2)`.
- DestructAssign(DestructAssignment),
- /// A set rule: `set text(...)`.
- Set(SetRule),
- /// A show rule: `show heading: it => emph(it.body)`.
- Show(ShowRule),
- /// An if-else conditional: `if x { y } else { z }`.
- Conditional(Conditional),
- /// A while loop: `while x { y }`.
- While(WhileLoop),
- /// A for loop: `for x in y { z }`.
- For(ForLoop),
- /// A module import: `import "utils.typ": a, b, c`.
- Import(ModuleImport),
- /// A module include: `include "chapter1.typ"`.
- Include(ModuleInclude),
- /// A break from a loop: `break`.
- Break(LoopBreak),
- /// A continue in a loop: `continue`.
- Continue(LoopContinue),
- /// A return from a function: `return`, `return x + 1`.
- Return(FuncReturn),
-}
-
-impl Expr {
- fn cast_with_space(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Space => node.cast().map(Self::Space),
- _ => Self::from_untyped(node),
- }
- }
-}
-
-impl AstNode for Expr {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Linebreak => node.cast().map(Self::Linebreak),
- SyntaxKind::Parbreak => node.cast().map(Self::Parbreak),
- SyntaxKind::Text => node.cast().map(Self::Text),
- SyntaxKind::Escape => node.cast().map(Self::Escape),
- SyntaxKind::Shorthand => node.cast().map(Self::Shorthand),
- SyntaxKind::SmartQuote => node.cast().map(Self::SmartQuote),
- SyntaxKind::Strong => node.cast().map(Self::Strong),
- SyntaxKind::Emph => node.cast().map(Self::Emph),
- SyntaxKind::Raw => node.cast().map(Self::Raw),
- SyntaxKind::Link => node.cast().map(Self::Link),
- SyntaxKind::Label => node.cast().map(Self::Label),
- SyntaxKind::Ref => node.cast().map(Self::Ref),
- SyntaxKind::Heading => node.cast().map(Self::Heading),
- SyntaxKind::ListItem => node.cast().map(Self::List),
- SyntaxKind::EnumItem => node.cast().map(Self::Enum),
- SyntaxKind::TermItem => node.cast().map(Self::Term),
- SyntaxKind::Equation => node.cast().map(Self::Equation),
- SyntaxKind::Math => node.cast().map(Self::Math),
- SyntaxKind::MathIdent => node.cast().map(Self::MathIdent),
- SyntaxKind::MathAlignPoint => node.cast().map(Self::MathAlignPoint),
- SyntaxKind::MathDelimited => node.cast().map(Self::MathDelimited),
- SyntaxKind::MathAttach => node.cast().map(Self::MathAttach),
- SyntaxKind::MathFrac => node.cast().map(Self::MathFrac),
- SyntaxKind::MathRoot => node.cast().map(Self::MathRoot),
- SyntaxKind::Ident => node.cast().map(Self::Ident),
- SyntaxKind::None => node.cast().map(Self::None),
- SyntaxKind::Auto => node.cast().map(Self::Auto),
- SyntaxKind::Bool => node.cast().map(Self::Bool),
- SyntaxKind::Int => node.cast().map(Self::Int),
- SyntaxKind::Float => node.cast().map(Self::Float),
- SyntaxKind::Numeric => node.cast().map(Self::Numeric),
- SyntaxKind::Str => node.cast().map(Self::Str),
- SyntaxKind::CodeBlock => node.cast().map(Self::Code),
- SyntaxKind::ContentBlock => node.cast().map(Self::Content),
- SyntaxKind::Parenthesized => node.cast().map(Self::Parenthesized),
- SyntaxKind::Array => node.cast().map(Self::Array),
- SyntaxKind::Dict => node.cast().map(Self::Dict),
- SyntaxKind::Unary => node.cast().map(Self::Unary),
- SyntaxKind::Binary => node.cast().map(Self::Binary),
- SyntaxKind::FieldAccess => node.cast().map(Self::FieldAccess),
- SyntaxKind::FuncCall => node.cast().map(Self::FuncCall),
- SyntaxKind::Closure => node.cast().map(Self::Closure),
- SyntaxKind::LetBinding => node.cast().map(Self::Let),
- SyntaxKind::DestructAssignment => node.cast().map(Self::DestructAssign),
- SyntaxKind::SetRule => node.cast().map(Self::Set),
- SyntaxKind::ShowRule => node.cast().map(Self::Show),
- SyntaxKind::Conditional => node.cast().map(Self::Conditional),
- SyntaxKind::WhileLoop => node.cast().map(Self::While),
- SyntaxKind::ForLoop => node.cast().map(Self::For),
- SyntaxKind::ModuleImport => node.cast().map(Self::Import),
- SyntaxKind::ModuleInclude => node.cast().map(Self::Include),
- SyntaxKind::LoopBreak => node.cast().map(Self::Break),
- SyntaxKind::LoopContinue => node.cast().map(Self::Continue),
- SyntaxKind::FuncReturn => node.cast().map(Self::Return),
- _ => Option::None,
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Text(v) => v.as_untyped(),
- Self::Space(v) => v.as_untyped(),
- Self::Linebreak(v) => v.as_untyped(),
- Self::Parbreak(v) => v.as_untyped(),
- Self::Escape(v) => v.as_untyped(),
- Self::Shorthand(v) => v.as_untyped(),
- Self::SmartQuote(v) => v.as_untyped(),
- Self::Strong(v) => v.as_untyped(),
- Self::Emph(v) => v.as_untyped(),
- Self::Raw(v) => v.as_untyped(),
- Self::Link(v) => v.as_untyped(),
- Self::Label(v) => v.as_untyped(),
- Self::Ref(v) => v.as_untyped(),
- Self::Heading(v) => v.as_untyped(),
- Self::List(v) => v.as_untyped(),
- Self::Enum(v) => v.as_untyped(),
- Self::Term(v) => v.as_untyped(),
- Self::Equation(v) => v.as_untyped(),
- Self::Math(v) => v.as_untyped(),
- Self::MathIdent(v) => v.as_untyped(),
- Self::MathAlignPoint(v) => v.as_untyped(),
- Self::MathDelimited(v) => v.as_untyped(),
- Self::MathAttach(v) => v.as_untyped(),
- Self::MathFrac(v) => v.as_untyped(),
- Self::MathRoot(v) => v.as_untyped(),
- Self::Ident(v) => v.as_untyped(),
- Self::None(v) => v.as_untyped(),
- Self::Auto(v) => v.as_untyped(),
- Self::Bool(v) => v.as_untyped(),
- Self::Int(v) => v.as_untyped(),
- Self::Float(v) => v.as_untyped(),
- Self::Numeric(v) => v.as_untyped(),
- Self::Str(v) => v.as_untyped(),
- Self::Code(v) => v.as_untyped(),
- Self::Content(v) => v.as_untyped(),
- Self::Array(v) => v.as_untyped(),
- Self::Dict(v) => v.as_untyped(),
- Self::Parenthesized(v) => v.as_untyped(),
- Self::Unary(v) => v.as_untyped(),
- Self::Binary(v) => v.as_untyped(),
- Self::FieldAccess(v) => v.as_untyped(),
- Self::FuncCall(v) => v.as_untyped(),
- Self::Closure(v) => v.as_untyped(),
- Self::Let(v) => v.as_untyped(),
- Self::DestructAssign(v) => v.as_untyped(),
- Self::Set(v) => v.as_untyped(),
- Self::Show(v) => v.as_untyped(),
- Self::Conditional(v) => v.as_untyped(),
- Self::While(v) => v.as_untyped(),
- Self::For(v) => v.as_untyped(),
- Self::Import(v) => v.as_untyped(),
- Self::Include(v) => v.as_untyped(),
- Self::Break(v) => v.as_untyped(),
- Self::Continue(v) => v.as_untyped(),
- Self::Return(v) => v.as_untyped(),
- }
- }
-}
-
-impl Expr {
- /// Can this expression be embedded into markup with a hashtag?
- pub fn hashtag(&self) -> bool {
- matches!(
- self,
- Self::Ident(_)
- | Self::None(_)
- | Self::Auto(_)
- | Self::Bool(_)
- | Self::Int(_)
- | Self::Float(_)
- | Self::Numeric(_)
- | Self::Str(_)
- | Self::Code(_)
- | Self::Content(_)
- | Self::Array(_)
- | Self::Dict(_)
- | Self::Parenthesized(_)
- | Self::FieldAccess(_)
- | Self::FuncCall(_)
- | Self::Let(_)
- | Self::Set(_)
- | Self::Show(_)
- | Self::Conditional(_)
- | Self::While(_)
- | Self::For(_)
- | Self::Import(_)
- | Self::Include(_)
- | Self::Break(_)
- | Self::Continue(_)
- | Self::Return(_)
- )
- }
-
- /// Is this a literal?
- pub fn is_literal(&self) -> bool {
- matches!(
- self,
- Self::None(_)
- | Self::Auto(_)
- | Self::Bool(_)
- | Self::Int(_)
- | Self::Float(_)
- | Self::Numeric(_)
- | Self::Str(_)
- )
- }
-}
-
-impl Default for Expr {
- fn default() -> Self {
- Expr::Space(Space::default())
- }
-}
-
-node! {
- /// Plain text without markup.
- Text
-}
-
-impl Text {
- /// Get the text.
- pub fn get(&self) -> &EcoString {
- self.0.text()
- }
-}
-
-node! {
- /// Whitespace in markup or math. Has at most one newline in markup, as more
- /// indicate a paragraph break.
- Space
-}
-
-node! {
- /// A forced line break: `\`.
- Linebreak
-}
-
-node! {
- /// A paragraph break, indicated by one or multiple blank lines.
- Parbreak
-}
-
-node! {
- /// An escape sequence: `\#`, `\u{1F5FA}`.
- Escape
-}
-
-impl Escape {
- /// Get the escaped character.
- pub fn get(&self) -> char {
- let mut s = Scanner::new(self.0.text());
- s.expect('\\');
- if s.eat_if("u{") {
- let hex = s.eat_while(char::is_ascii_hexdigit);
- u32::from_str_radix(hex, 16)
- .ok()
- .and_then(std::char::from_u32)
- .unwrap_or_default()
- } else {
- s.eat().unwrap_or_default()
- }
- }
-}
-
-node! {
- /// A shorthand for a unicode codepoint. For example, `~` for a non-breaking
- /// space or `-?` for a soft hyphen.
- Shorthand
-}
-
-impl Shorthand {
- /// A list of all shorthands.
- pub const LIST: &[(&'static str, char)] = &[
- // Both.
- ("...", '…'),
- // Text only.
- ("~", '\u{00A0}'),
- ("--", '\u{2013}'),
- ("---", '\u{2014}'),
- ("-?", '\u{00AD}'),
- // Math only.
- ("-", '\u{2212}'),
- ("'", '′'),
- ("*", '∗'),
- ("!=", '≠'),
- (":=", '≔'),
- ("::=", '⩴'),
- ("=:", '≕'),
- ("<<", '≪'),
- ("<<<", '⋘'),
- (">>", '≫'),
- (">>>", '⋙'),
- ("<=", '≤'),
- (">=", '≥'),
- ("->", '→'),
- ("-->", '⟶'),
- ("|->", '↦'),
- (">->", '↣'),
- ("->>", '↠'),
- ("<-", '←'),
- ("<--", '⟵'),
- ("<-<", '↢'),
- ("<<-", '↞'),
- ("<->", '↔'),
- ("<-->", '⟷'),
- ("~>", '⇝'),
- ("~~>", '⟿'),
- ("<~", '⇜'),
- ("<~~", '⬳'),
- ("=>", '⇒'),
- ("|=>", '⤇'),
- ("==>", '⟹'),
- ("<==", '⟸'),
- ("<=>", '⇔'),
- ("<==>", '⟺'),
- ("[|", '⟦'),
- ("|]", '⟧'),
- ("||", '‖'),
- ];
-
- /// Get the shorthanded character.
- pub fn get(&self) -> char {
- let text = self.0.text();
- Self::LIST
- .iter()
- .find(|&&(s, _)| s == text)
- .map_or_else(char::default, |&(_, c)| c)
- }
-}
-
-node! {
- /// A smart quote: `'` or `"`.
- SmartQuote
-}
-
-impl SmartQuote {
- /// Whether this is a double quote.
- pub fn double(&self) -> bool {
- self.0.text() == "\""
- }
-}
-
-node! {
- /// Strong content: `*Strong*`.
- Strong
-}
-
-impl Strong {
- /// The contents of the strong node.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// Emphasized content: `_Emphasized_`.
- Emph
-}
-
-impl Emph {
- /// The contents of the emphasis node.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// Raw text with optional syntax highlighting: `` `...` ``.
- Raw
-}
-
-impl Raw {
- /// The trimmed raw text.
- pub fn text(&self) -> EcoString {
- let mut text = self.0.text().as_str();
- let blocky = text.starts_with("```");
- text = text.trim_matches('`');
-
- // Trim tag, one space at the start, and one space at the end if the
- // last non-whitespace char is a backtick.
- if blocky {
- let mut s = Scanner::new(text);
- if s.eat_if(is_id_start) {
- s.eat_while(is_id_continue);
- }
- text = s.after();
- text = text.strip_prefix(' ').unwrap_or(text);
- if text.trim_end().ends_with('`') {
- text = text.strip_suffix(' ').unwrap_or(text);
- }
- }
-
- // Split into lines.
- let mut lines = split_newlines(text);
-
- if blocky {
- let dedent = lines
- .iter()
- .skip(1)
- .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())
- .min()
- .unwrap_or(0);
-
- // Dedent based on column, but not for the first line.
- for line in lines.iter_mut().skip(1) {
- let offset = line.chars().take(dedent).map(char::len_utf8).sum();
- *line = &line[offset..];
- }
-
- let is_whitespace = |line: &&str| line.chars().all(char::is_whitespace);
-
- // Trims a sequence of whitespace followed by a newline at the start.
- if lines.first().map_or(false, is_whitespace) {
- lines.remove(0);
- }
-
- // Trims a newline followed by a sequence of whitespace at the end.
- if lines.last().map_or(false, is_whitespace) {
- lines.pop();
- }
- }
-
- lines.join("\n").into()
- }
-
- /// An optional identifier specifying the language to syntax-highlight in.
- pub fn lang(&self) -> Option<&str> {
- let text = self.0.text();
-
- // Only blocky literals are supposed to contain a language.
- if !text.starts_with("```") {
- return Option::None;
- }
-
- let inner = text.trim_start_matches('`');
- let mut s = Scanner::new(inner);
- s.eat_if(is_id_start).then(|| {
- s.eat_while(is_id_continue);
- s.before()
- })
- }
-
- /// Whether the raw text should be displayed in a separate block.
- pub fn block(&self) -> bool {
- let text = self.0.text();
- text.starts_with("```") && text.chars().any(is_newline)
- }
-}
-
-node! {
- /// A hyperlink: `https://typst.org`.
- Link
-}
-
-impl Link {
- /// Get the URL.
- pub fn get(&self) -> &EcoString {
- self.0.text()
- }
-}
-
-node! {
- /// A label: `<intro>`.
- Label
-}
-
-impl Label {
- /// Get the label's text.
- pub fn get(&self) -> &str {
- self.0.text().trim_start_matches('<').trim_end_matches('>')
- }
-}
-
-node! {
- /// A reference: `@target`, `@target[..]`.
- Ref
-}
-
-impl Ref {
- /// Get the target.
- pub fn target(&self) -> &str {
- self.0
- .children()
- .find(|node| node.kind() == SyntaxKind::RefMarker)
- .map(|node| node.text().trim_start_matches('@'))
- .unwrap_or_default()
- }
-
- /// Get the supplement.
- pub fn supplement(&self) -> Option<ContentBlock> {
- self.0.cast_last_match()
- }
-}
-
-node! {
- /// A section heading: `= Introduction`.
- Heading
-}
-
-impl Heading {
- /// The contents of the heading.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The section depth (number of equals signs).
- pub fn level(&self) -> NonZeroUsize {
- self.0
- .children()
- .find(|node| node.kind() == SyntaxKind::HeadingMarker)
- .and_then(|node| node.len().try_into().ok())
- .unwrap_or(NonZeroUsize::ONE)
- }
-}
-
-node! {
- /// An item in a bullet list: `- ...`.
- ListItem
-}
-
-impl ListItem {
- /// The contents of the list item.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An item in an enumeration (numbered list): `+ ...` or `1. ...`.
- EnumItem
-}
-
-impl EnumItem {
- /// The explicit numbering, if any: `23.`.
- pub fn number(&self) -> Option<usize> {
- self.0.children().find_map(|node| match node.kind() {
- SyntaxKind::EnumMarker => node.text().trim_end_matches('.').parse().ok(),
- _ => Option::None,
- })
- }
-
- /// The contents of the list item.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An item in a term list: `/ Term: Details`.
- TermItem
-}
-
-impl TermItem {
- /// The term described by the item.
- pub fn term(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The description of the term.
- pub fn description(&self) -> Markup {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A mathemathical equation: `$x$`, `$ x^2 $`.
- Equation
-}
-
-impl Equation {
- /// The contained math.
- pub fn body(&self) -> Math {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// Whether the equation should be displayed as a separate block.
- pub fn block(&self) -> bool {
- let is_space = |node: Option<&SyntaxNode>| {
- node.map(SyntaxNode::kind) == Some(SyntaxKind::Space)
- };
- is_space(self.0.children().nth(1)) && is_space(self.0.children().nth_back(1))
- }
-}
-
-node! {
- /// The contents of a mathematical equation: `x^2 + 1`.
- Math
-}
-
-impl Math {
- /// The expressions the mathematical content consists of.
- pub fn exprs(&self) -> impl DoubleEndedIterator<Item = Expr> + '_ {
- self.0.children().filter_map(Expr::cast_with_space)
- }
-}
-
-node! {
- /// An identifier in math: `pi`.
- MathIdent
-}
-
-impl MathIdent {
- /// Get the identifier.
- pub fn get(&self) -> &EcoString {
- self.0.text()
- }
-
- /// Take out the contained identifier.
- pub fn take(self) -> EcoString {
- self.0.into_text()
- }
-
- /// Get the identifier as a string slice.
- pub fn as_str(&self) -> &str {
- self.get()
- }
-}
-
-impl Deref for MathIdent {
- type Target = str;
-
- fn deref(&self) -> &Self::Target {
- self.as_str()
- }
-}
-
-node! {
- /// An alignment point in math: `&`.
- MathAlignPoint
-}
-
-node! {
- /// Matched delimiters in math: `[x + y]`.
- MathDelimited
-}
-
-impl MathDelimited {
- /// The opening delimiter.
- pub fn open(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The contents, including the delimiters.
- pub fn body(&self) -> Math {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The closing delimiter.
- pub fn close(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A base with optional attachments in math: `a_1^2`.
- MathAttach
-}
-
-impl MathAttach {
- /// The base, to which things are attached.
- pub fn base(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The bottom attachment.
- pub fn bottom(&self) -> Option<Expr> {
- self.0
- .children()
- .skip_while(|node| !matches!(node.kind(), SyntaxKind::Underscore))
- .find_map(SyntaxNode::cast)
- }
-
- /// The top attachment.
- pub fn top(&self) -> Option<Expr> {
- self.0
- .children()
- .skip_while(|node| !matches!(node.kind(), SyntaxKind::Hat))
- .find_map(SyntaxNode::cast)
- }
-}
-
-node! {
- /// A fraction in math: `x/2`
- MathFrac
-}
-
-impl MathFrac {
- /// The numerator.
- pub fn num(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The denominator.
- pub fn denom(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A root in math: `√x`, `∛x` or `∜x`.
- MathRoot
-}
-
-impl MathRoot {
- /// The index of the root.
- pub fn index(&self) -> Option<usize> {
- match self.0.children().next().map(|node| node.text().as_str()) {
- Some("∜") => Some(4),
- Some("∛") => Some(3),
- Some("√") => Option::None,
- _ => Option::None,
- }
- }
-
- /// The radicand.
- pub fn radicand(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An identifier: `it`.
- Ident
-}
-
-impl Ident {
- /// Get the identifier.
- pub fn get(&self) -> &EcoString {
- self.0.text()
- }
-
- /// Take out the contained identifier.
- pub fn take(self) -> EcoString {
- self.0.into_text()
- }
-
- /// Get the identifier as a string slice.
- pub fn as_str(&self) -> &str {
- self.get()
- }
-}
-
-impl Deref for Ident {
- type Target = str;
-
- fn deref(&self) -> &Self::Target {
- self.as_str()
- }
-}
-
-node! {
- /// The `none` literal.
- None
-}
-
-node! {
- /// The `auto` literal.
- Auto
-}
-
-node! {
- /// A boolean: `true`, `false`.
- Bool
-}
-
-impl Bool {
- /// Get the boolean value.
- pub fn get(&self) -> bool {
- self.0.text() == "true"
- }
-}
-
-node! {
- /// An integer: `120`.
- Int
-}
-
-impl Int {
- /// Get the integer value.
- pub fn get(&self) -> i64 {
- let text = self.0.text();
- if let Some(rest) = text.strip_prefix("0x") {
- i64::from_str_radix(rest, 16)
- } else if let Some(rest) = text.strip_prefix("0o") {
- i64::from_str_radix(rest, 8)
- } else if let Some(rest) = text.strip_prefix("0b") {
- i64::from_str_radix(rest, 2)
- } else {
- text.parse()
- }
- .unwrap_or_default()
- }
-}
-
-node! {
- /// A floating-point number: `1.2`, `10e-4`.
- Float
-}
-
-impl Float {
- /// Get the floating-point value.
- pub fn get(&self) -> f64 {
- self.0.text().parse().unwrap_or_default()
- }
-}
-
-node! {
- /// A numeric value with a unit: `12pt`, `3cm`, `2em`, `90deg`, `50%`.
- Numeric
-}
-
-impl Numeric {
- /// Get the numeric value and unit.
- pub fn get(&self) -> (f64, Unit) {
- let text = self.0.text();
- let count = text
- .chars()
- .rev()
- .take_while(|c| matches!(c, 'a'..='z' | '%'))
- .count();
-
- let split = text.len() - count;
- let value = text[..split].parse().unwrap_or_default();
- let unit = match &text[split..] {
- "pt" => Unit::Length(AbsUnit::Pt),
- "mm" => Unit::Length(AbsUnit::Mm),
- "cm" => Unit::Length(AbsUnit::Cm),
- "in" => Unit::Length(AbsUnit::In),
- "deg" => Unit::Angle(AngleUnit::Deg),
- "rad" => Unit::Angle(AngleUnit::Rad),
- "em" => Unit::Em,
- "fr" => Unit::Fr,
- "%" => Unit::Percent,
- _ => Unit::Percent,
- };
-
- (value, unit)
- }
-}
-
-/// Unit of a numeric value.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Unit {
- /// An absolute length unit.
- Length(AbsUnit),
- /// An angular unit.
- Angle(AngleUnit),
- /// Font-relative: `1em` is the same as the font size.
- Em,
- /// Fractions: `fr`.
- Fr,
- /// Percentage: `%`.
- Percent,
-}
-
-node! {
- /// A quoted string: `"..."`.
- Str
-}
-
-impl Str {
- /// Get the string value with resolved escape sequences.
- pub fn get(&self) -> EcoString {
- let text = self.0.text();
- let unquoted = &text[1..text.len() - 1];
- if !unquoted.contains('\\') {
- return unquoted.into();
- }
-
- let mut out = EcoString::with_capacity(unquoted.len());
- let mut s = Scanner::new(unquoted);
-
- while let Some(c) = s.eat() {
- if c != '\\' {
- out.push(c);
- continue;
- }
-
- let start = s.locate(-1);
- match s.eat() {
- Some('\\') => out.push('\\'),
- Some('"') => out.push('"'),
- Some('n') => out.push('\n'),
- Some('r') => out.push('\r'),
- Some('t') => out.push('\t'),
- Some('u') if s.eat_if('{') => {
- let sequence = s.eat_while(char::is_ascii_hexdigit);
- s.eat_if('}');
-
- match u32::from_str_radix(sequence, 16)
- .ok()
- .and_then(std::char::from_u32)
- {
- Some(c) => out.push(c),
- Option::None => out.push_str(s.from(start)),
- }
- }
- _ => out.push_str(s.from(start)),
- }
- }
-
- out
- }
-}
-
-node! {
- /// A code block: `{ let x = 1; x + 2 }`.
- CodeBlock
-}
-
-impl CodeBlock {
- /// The contained code.
- pub fn body(&self) -> Code {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// Code.
- Code
-}
-
-impl Code {
- /// The list of expressions contained in the code.
- pub fn exprs(&self) -> impl DoubleEndedIterator<Item = Expr> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-}
-
-node! {
- /// A content block: `[*Hi* there!]`.
- ContentBlock
-}
-
-impl ContentBlock {
- /// The contained markup.
- pub fn body(&self) -> Markup {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A grouped expression: `(1 + 2)`.
- Parenthesized
-}
-
-impl Parenthesized {
- /// The wrapped expression.
- pub fn expr(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An array: `(1, "hi", 12cm)`.
- Array
-}
-
-impl Array {
- /// The array's items.
- pub fn items(&self) -> impl DoubleEndedIterator<Item = ArrayItem> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-}
-
-/// An item in an array.
-#[derive(Debug, Clone, Hash)]
-pub enum ArrayItem {
- /// A bare expression: `12`.
- Pos(Expr),
- /// A spread expression: `..things`.
- Spread(Expr),
-}
-
-impl AstNode for ArrayItem {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Spread => node.cast_first_match().map(Self::Spread),
- _ => node.cast().map(Self::Pos),
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Pos(v) => v.as_untyped(),
- Self::Spread(v) => v.as_untyped(),
- }
- }
-}
-
-node! {
- /// A dictionary: `(thickness: 3pt, pattern: dashed)`.
- Dict
-}
-
-impl Dict {
- /// The dictionary's items.
- pub fn items(&self) -> impl DoubleEndedIterator<Item = DictItem> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-}
-
-/// An item in an dictionary expression.
-#[derive(Debug, Clone, Hash)]
-pub enum DictItem {
- /// A named pair: `thickness: 3pt`.
- Named(Named),
- /// A keyed pair: `"spacy key": true`.
- Keyed(Keyed),
- /// A spread expression: `..things`.
- Spread(Expr),
-}
-
-impl AstNode for DictItem {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Named => node.cast().map(Self::Named),
- SyntaxKind::Keyed => node.cast().map(Self::Keyed),
- SyntaxKind::Spread => node.cast_first_match().map(Self::Spread),
- _ => Option::None,
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Named(v) => v.as_untyped(),
- Self::Keyed(v) => v.as_untyped(),
- Self::Spread(v) => v.as_untyped(),
- }
- }
-}
-
-node! {
- /// A named pair: `thickness: 3pt`.
- Named
-}
-
-impl Named {
- /// The name: `thickness`.
- pub fn name(&self) -> Ident {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The right-hand side of the pair: `3pt`.
- pub fn expr(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-
- /// The right-hand side of the pair as an identifier.
- pub fn expr_ident(&self) -> Option<Ident> {
- self.0.cast_last_match()
- }
-}
-
-node! {
- /// A keyed pair: `"spacy key": true`.
- Keyed
-}
-
-impl Keyed {
- /// The key: `"spacy key"`.
- pub fn key(&self) -> Str {
- self.0
- .children()
- .find_map(|node| node.cast::<Str>())
- .unwrap_or_default()
- }
-
- /// The right-hand side of the pair: `true`.
- pub fn expr(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A unary operation: `-x`.
- Unary
-}
-
-impl Unary {
- /// The operator: `-`.
- pub fn op(&self) -> UnOp {
- self.0
- .children()
- .find_map(|node| UnOp::from_kind(node.kind()))
- .unwrap_or(UnOp::Pos)
- }
-
- /// The expression to operate on: `x`.
- pub fn expr(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-/// A unary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-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_kind(token: SyntaxKind) -> Option<Self> {
- Some(match token {
- SyntaxKind::Plus => Self::Pos,
- SyntaxKind::Minus => Self::Neg,
- SyntaxKind::Not => Self::Not,
- _ => return Option::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`.
- Binary
-}
-
-impl Binary {
- /// The binary operator: `+`.
- pub fn op(&self) -> BinOp {
- let mut not = false;
- self.0
- .children()
- .find_map(|node| match node.kind() {
- SyntaxKind::Not => {
- not = true;
- Option::None
- }
- SyntaxKind::In if not => Some(BinOp::NotIn),
- _ => BinOp::from_kind(node.kind()),
- })
- .unwrap_or(BinOp::Add)
- }
-
- /// The left-hand side of the operation: `a`.
- pub fn lhs(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The right-hand side of the operation: `b`.
- pub fn rhs(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-/// A binary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-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 containment operator: `in`.
- In,
- /// The inversed containment operator: `not in`.
- NotIn,
- /// 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_kind(token: SyntaxKind) -> Option<Self> {
- Some(match token {
- SyntaxKind::Plus => Self::Add,
- SyntaxKind::Minus => Self::Sub,
- SyntaxKind::Star => Self::Mul,
- SyntaxKind::Slash => Self::Div,
- SyntaxKind::And => Self::And,
- SyntaxKind::Or => Self::Or,
- SyntaxKind::EqEq => Self::Eq,
- SyntaxKind::ExclEq => Self::Neq,
- SyntaxKind::Lt => Self::Lt,
- SyntaxKind::LtEq => Self::Leq,
- SyntaxKind::Gt => Self::Gt,
- SyntaxKind::GtEq => Self::Geq,
- SyntaxKind::Eq => Self::Assign,
- SyntaxKind::In => Self::In,
- SyntaxKind::PlusEq => Self::AddAssign,
- SyntaxKind::HyphEq => Self::SubAssign,
- SyntaxKind::StarEq => Self::MulAssign,
- SyntaxKind::SlashEq => Self::DivAssign,
- _ => return Option::None,
- })
- }
-
- /// The precedence of this operator.
- pub fn precedence(self) -> usize {
- match self {
- Self::Mul => 6,
- Self::Div => 6,
- Self::Add => 5,
- Self::Sub => 5,
- Self::Eq => 4,
- Self::Neq => 4,
- Self::Lt => 4,
- Self::Leq => 4,
- Self::Gt => 4,
- Self::Geq => 4,
- Self::In => 4,
- Self::NotIn => 4,
- Self::And => 3,
- Self::Or => 2,
- Self::Assign => 1,
- Self::AddAssign => 1,
- Self::SubAssign => 1,
- Self::MulAssign => 1,
- Self::DivAssign => 1,
- }
- }
-
- /// The associativity of this operator.
- pub fn assoc(self) -> Assoc {
- match self {
- Self::Add => Assoc::Left,
- Self::Sub => Assoc::Left,
- Self::Mul => Assoc::Left,
- Self::Div => Assoc::Left,
- Self::And => Assoc::Left,
- Self::Or => Assoc::Left,
- Self::Eq => Assoc::Left,
- Self::Neq => Assoc::Left,
- Self::Lt => Assoc::Left,
- Self::Leq => Assoc::Left,
- Self::Gt => Assoc::Left,
- Self::Geq => Assoc::Left,
- Self::In => Assoc::Left,
- Self::NotIn => Assoc::Left,
- Self::Assign => Assoc::Right,
- Self::AddAssign => Assoc::Right,
- Self::SubAssign => Assoc::Right,
- Self::MulAssign => Assoc::Right,
- Self::DivAssign => Assoc::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::In => "in",
- Self::NotIn => "not in",
- Self::Assign => "=",
- Self::AddAssign => "+=",
- Self::SubAssign => "-=",
- Self::MulAssign => "*=",
- Self::DivAssign => "/=",
- }
- }
-}
-
-/// The associativity of a binary operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Assoc {
- /// 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! {
- /// A field access: `properties.age`.
- FieldAccess
-}
-
-impl FieldAccess {
- /// The expression to access the field on.
- pub fn target(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The name of the field.
- pub fn field(&self) -> Ident {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An invocation of a function or method: `f(x, y)`.
- FuncCall
-}
-
-impl FuncCall {
- /// The function to call.
- pub fn callee(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The arguments to the function.
- pub fn args(&self) -> Args {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A function call's argument list: `(12pt, y)`.
- Args
-}
-
-impl Args {
- /// The positional and named arguments.
- pub fn items(&self) -> impl DoubleEndedIterator<Item = Arg> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-}
-
-/// An argument to a function call.
-#[derive(Debug, Clone, Hash)]
-pub enum Arg {
- /// A positional argument: `12`.
- Pos(Expr),
- /// A named argument: `draw: false`.
- Named(Named),
- /// A spread argument: `..things`.
- Spread(Expr),
-}
-
-impl AstNode for Arg {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Named => node.cast().map(Self::Named),
- SyntaxKind::Spread => node.cast_first_match().map(Self::Spread),
- _ => node.cast().map(Self::Pos),
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Pos(v) => v.as_untyped(),
- Self::Named(v) => v.as_untyped(),
- Self::Spread(v) => v.as_untyped(),
- }
- }
-}
-
-node! {
- /// A closure: `(x, y) => z`.
- Closure
-}
-
-impl Closure {
- /// 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.children().next()?.cast()
- }
-
- /// The parameter bindings.
- pub fn params(&self) -> Params {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The body of the closure.
- pub fn body(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A closure's parameters: `(x, y)`.
- Params
-}
-
-impl Params {
- /// The parameter bindings.
- pub fn children(&self) -> impl DoubleEndedIterator<Item = Param> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-}
-
-node! {
- /// A spread: `..x` or `..x.at(0)`.
- Spread
-}
-
-impl Spread {
- /// Try to get an identifier.
- pub fn name(&self) -> Option<Ident> {
- self.0.cast_first_match()
- }
-
- /// Try to get an expression.
- pub fn expr(&self) -> Option<Expr> {
- self.0.cast_first_match()
- }
-}
-
-node! {
- /// An underscore: `_`
- Underscore
-}
-
-/// A parameter to a closure.
-#[derive(Debug, Clone, Hash)]
-pub enum Param {
- /// A positional parameter: `x`.
- Pos(Pattern),
- /// A named parameter with a default value: `draw: false`.
- Named(Named),
- /// An argument sink: `..args`.
- Sink(Spread),
-}
-
-impl AstNode for Param {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Named => node.cast().map(Self::Named),
- SyntaxKind::Spread => node.cast().map(Self::Sink),
- _ => node.cast().map(Self::Pos),
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Pos(v) => v.as_untyped(),
- Self::Named(v) => v.as_untyped(),
- Self::Sink(v) => v.as_untyped(),
- }
- }
-}
-
-node! {
- /// A destructuring pattern: `x` or `(x, _, ..y)`.
- Destructuring
-}
-
-impl Destructuring {
- /// The bindings of the destructuring.
- pub fn bindings(&self) -> impl Iterator<Item = DestructuringKind> + '_ {
- self.0.children().filter_map(SyntaxNode::cast)
- }
-
- // Returns a list of all identifiers in the pattern.
- pub fn idents(&self) -> impl Iterator<Item = Ident> + '_ {
- self.bindings().filter_map(|binding| match binding {
- DestructuringKind::Normal(Expr::Ident(ident)) => Some(ident),
- DestructuringKind::Sink(spread) => spread.name(),
- DestructuringKind::Named(named) => named.expr_ident(),
- _ => Option::None,
- })
- }
-}
-
-/// The kind of an element in a destructuring pattern.
-#[derive(Debug, Clone, Hash)]
-pub enum DestructuringKind {
- /// An expression: `x`.
- Normal(Expr),
- /// An argument sink: `..y`.
- Sink(Spread),
- /// Named arguments: `x: 1`.
- Named(Named),
- /// A placeholder: `_`.
- Placeholder(Underscore),
-}
-
-impl AstNode for DestructuringKind {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Named => node.cast().map(Self::Named),
- SyntaxKind::Spread => node.cast().map(Self::Sink),
- SyntaxKind::Underscore => node.cast().map(Self::Placeholder),
- _ => node.cast().map(Self::Normal),
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Normal(v) => v.as_untyped(),
- Self::Named(v) => v.as_untyped(),
- Self::Sink(v) => v.as_untyped(),
- Self::Placeholder(v) => v.as_untyped(),
- }
- }
-}
-
-/// The kind of a pattern.
-#[derive(Debug, Clone, Hash)]
-pub enum Pattern {
- /// A single expression: `x`.
- Normal(Expr),
- /// A placeholder: `_`.
- Placeholder(Underscore),
- /// A destructuring pattern: `(x, _, ..y)`.
- Destructuring(Destructuring),
-}
-
-impl AstNode for Pattern {
- fn from_untyped(node: &SyntaxNode) -> Option<Self> {
- match node.kind() {
- SyntaxKind::Destructuring => node.cast().map(Self::Destructuring),
- SyntaxKind::Underscore => node.cast().map(Self::Placeholder),
- _ => node.cast().map(Self::Normal),
- }
- }
-
- fn as_untyped(&self) -> &SyntaxNode {
- match self {
- Self::Normal(v) => v.as_untyped(),
- Self::Destructuring(v) => v.as_untyped(),
- Self::Placeholder(v) => v.as_untyped(),
- }
- }
-}
-
-impl Pattern {
- // Returns a list of all identifiers in the pattern.
- pub fn idents(&self) -> Vec<Ident> {
- match self {
- Pattern::Normal(Expr::Ident(ident)) => vec![ident.clone()],
- Pattern::Destructuring(destruct) => destruct.idents().collect(),
- _ => vec![],
- }
- }
-}
-
-impl Default for Pattern {
- fn default() -> Self {
- Self::Normal(Expr::default())
- }
-}
-
-node! {
- /// A let binding: `let x = 1`.
- LetBinding
-}
-
-#[derive(Debug)]
-pub enum LetBindingKind {
- /// A normal binding: `let x = 1`.
- Normal(Pattern),
- /// A closure binding: `let f(x) = 1`.
- Closure(Ident),
-}
-
-impl LetBindingKind {
- // Returns a list of all identifiers in the pattern.
- pub fn idents(&self) -> Vec<Ident> {
- match self {
- LetBindingKind::Normal(pattern) => pattern.idents(),
- LetBindingKind::Closure(ident) => {
- vec![ident.clone()]
- }
- }
- }
-}
-
-impl LetBinding {
- /// The kind of the let binding.
- pub fn kind(&self) -> LetBindingKind {
- match self.0.cast_first_match::<Pattern>() {
- Some(Pattern::Normal(Expr::Closure(closure))) => {
- LetBindingKind::Closure(closure.name().unwrap_or_default())
- }
- pattern => LetBindingKind::Normal(pattern.unwrap_or_default()),
- }
- }
-
- /// The expression the binding is initialized with.
- pub fn init(&self) -> Option<Expr> {
- match self.kind() {
- LetBindingKind::Normal(Pattern::Normal(_)) => {
- self.0.children().filter_map(SyntaxNode::cast).nth(1)
- }
- LetBindingKind::Normal(_) => self.0.cast_first_match(),
- LetBindingKind::Closure(_) => self.0.cast_first_match(),
- }
- }
-}
-
-node! {
- /// An assignment expression `(x, y) = (1, 2)`.
- DestructAssignment
-}
-
-impl DestructAssignment {
- /// The pattern of the assignment.
- pub fn pattern(&self) -> Pattern {
- self.0.cast_first_match::<Pattern>().unwrap_or_default()
- }
-
- /// The expression that is assigned.
- pub fn value(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A set rule: `set text(...)`.
- SetRule
-}
-
-impl SetRule {
- /// The function to set style properties for.
- pub fn target(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The style properties to set.
- pub fn args(&self) -> Args {
- self.0.cast_last_match().unwrap_or_default()
- }
-
- /// A condition under which the set rule applies.
- pub fn condition(&self) -> Option<Expr> {
- self.0
- .children()
- .skip_while(|child| child.kind() != SyntaxKind::If)
- .find_map(SyntaxNode::cast)
- }
-}
-
-node! {
- /// A show rule: `show heading: it => emph(it.body)`.
- ShowRule
-}
-
-impl ShowRule {
- /// Defines which nodes the show rule applies to.
- pub fn selector(&self) -> Option<Expr> {
- self.0
- .children()
- .rev()
- .skip_while(|child| child.kind() != SyntaxKind::Colon)
- .find_map(SyntaxNode::cast)
- }
-
- /// The transformation recipe.
- pub fn transform(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// An if-else conditional: `if x { y } else { z }`.
- Conditional
-}
-
-impl Conditional {
- /// The condition which selects the body to evaluate.
- pub fn condition(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The expression to evaluate if the condition is true.
- pub fn if_body(&self) -> Expr {
- self.0
- .children()
- .filter_map(SyntaxNode::cast)
- .nth(1)
- .unwrap_or_default()
- }
-
- /// The expression to evaluate if the condition is false.
- pub fn else_body(&self) -> Option<Expr> {
- self.0.children().filter_map(SyntaxNode::cast).nth(2)
- }
-}
-
-node! {
- /// A while loop: `while x { y }`.
- WhileLoop
-}
-
-impl WhileLoop {
- /// The condition which selects whether to evaluate the body.
- pub fn condition(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The expression to evaluate while the condition is true.
- pub fn body(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A for loop: `for x in y { z }`.
- ForLoop
-}
-
-impl ForLoop {
- /// The pattern to assign to.
- pub fn pattern(&self) -> Pattern {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The expression to iterate over.
- pub fn iter(&self) -> Expr {
- self.0
- .children()
- .skip_while(|&c| c.kind() != SyntaxKind::In)
- .find_map(SyntaxNode::cast)
- .unwrap_or_default()
- }
-
- /// The expression to evaluate for each iteration.
- pub fn body(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A module import: `import "utils.typ": a, b, c`.
- ModuleImport
-}
-
-impl ModuleImport {
- /// The module or path from which the items should be imported.
- pub fn source(&self) -> Expr {
- self.0.cast_first_match().unwrap_or_default()
- }
-
- /// The items to be imported.
- pub fn imports(&self) -> Option<Imports> {
- self.0.children().find_map(|node| match node.kind() {
- SyntaxKind::Star => Some(Imports::Wildcard),
- SyntaxKind::ImportItems => {
- let items = node.children().filter_map(SyntaxNode::cast).collect();
- Some(Imports::Items(items))
- }
- _ => Option::None,
- })
- }
-}
-
-/// The items that ought to be imported from a file.
-#[derive(Debug, Clone, Hash)]
-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! {
- /// A module include: `include "chapter1.typ"`.
- ModuleInclude
-}
-
-impl ModuleInclude {
- /// The module or path from which the content should be included.
- pub fn source(&self) -> Expr {
- self.0.cast_last_match().unwrap_or_default()
- }
-}
-
-node! {
- /// A break from a loop: `break`.
- LoopBreak
-}
-
-node! {
- /// A continue in a loop: `continue`.
- LoopContinue
-}
-
-node! {
- /// A return from a function: `return`, `return x + 1`.
- FuncReturn
-}
-
-impl FuncReturn {
- /// The expression to return.
- pub fn body(&self) -> Option<Expr> {
- self.0.cast_last_match()
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-15 21:35:35 +0000