diff options
Diffstat (limited to 'src/syntax/kind.rs')
| -rw-r--r-- | src/syntax/kind.rs | 448 |
1 files changed, 0 insertions, 448 deletions
diff --git a/src/syntax/kind.rs b/src/syntax/kind.rs deleted file mode 100644 index 26e949ca..00000000 --- a/src/syntax/kind.rs +++ /dev/null @@ -1,448 +0,0 @@ -/// A syntactical building block of a Typst file. -/// -/// Can be created by the lexer or by the parser. -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -#[repr(u8)] -pub enum SyntaxKind { - /// Markup. - Markup, - /// Plain text without markup. - Text, - /// Whitespace. Contains at most one newline in markup, as more indicate a - /// paragraph break. - Space, - /// A forced line break: `\`. - Linebreak, - /// A paragraph break, indicated by one or multiple blank lines. - Parbreak, - /// An escape sequence: `\#`, `\u{1F5FA}`. - Escape, - /// A shorthand for a unicode codepoint. For example, `~` for non-breaking - /// space or `-?` for a soft hyphen. - Shorthand, - /// A smart quote: `'` or `"`. - SmartQuote, - /// Strong content: `*Strong*`. - Strong, - /// Emphasized content: `_Emphasized_`. - Emph, - /// Raw text with optional syntax highlighting: `` `...` ``. - Raw, - /// A hyperlink: `https://typst.org`. - Link, - /// A label: `<intro>`. - Label, - /// A reference: `@target`, `@target[..]`. - Ref, - /// Introduces a reference: `@target`. - RefMarker, - /// A section heading: `= Introduction`. - Heading, - /// Introduces a section heading: `=`, `==`, ... - HeadingMarker, - /// An item in a bullet list: `- ...`. - ListItem, - /// Introduces a list item: `-`. - ListMarker, - /// An item in an enumeration (numbered list): `+ ...` or `1. ...`. - EnumItem, - /// Introduces an enumeration item: `+`, `1.`. - EnumMarker, - /// An item in a term list: `/ Term: Details`. - TermItem, - /// Introduces a term item: `/`. - TermMarker, - /// A mathematical equation: `$x$`, `$ x^2 $`. - Equation, - - /// The contents of a mathematical equation: `x^2 + 1`. - Math, - /// An identifier in math: `pi`. - MathIdent, - /// An alignment point in math: `&`. - MathAlignPoint, - /// Matched delimiters in math: `[x + y]`. - MathDelimited, - /// A base with optional attachments in math: `a_1^2`. - MathAttach, - /// A fraction in math: `x/2`. - MathFrac, - /// A root in math: `√x`, `∛x` or `∜x`. - MathRoot, - - /// A hashtag that switches into code mode: `#`. - Hashtag, - /// A left curly brace, starting a code block: `{`. - LeftBrace, - /// A right curly brace, terminating a code block: `}`. - RightBrace, - /// A left square bracket, starting a content block: `[`. - LeftBracket, - /// A right square bracket, terminating a content block: `]`. - RightBracket, - /// A left round parenthesis, starting a grouped expression, collection, - /// argument or parameter list: `(`. - LeftParen, - /// A right round parenthesis, terminating a grouped expression, collection, - /// argument or parameter list: `)`. - RightParen, - /// A comma separator in a sequence: `,`. - Comma, - /// A semicolon terminating an expression: `;`. - Semicolon, - /// A colon between name/key and value in a dictionary, argument or - /// parameter list, or between the term and body of a term list term: `:`. - Colon, - /// The strong text toggle, multiplication operator, and wildcard import - /// symbol: `*`. - Star, - /// Toggles emphasized text and indicates a subscript in math: `_`. - Underscore, - /// Starts and ends a mathematical equation: `$`. - Dollar, - /// The unary plus and binary addition operator: `+`. - Plus, - /// The unary negation and binary subtraction operator: `-`. - Minus, - /// The division operator and fraction operator in math: `/`. - Slash, - /// The superscript operator in math: `^`. - Hat, - /// The field access and method call operator: `.`. - Dot, - /// The assignment operator: `=`. - Eq, - /// The equality operator: `==`. - EqEq, - /// The inequality operator: `!=`. - ExclEq, - /// The less-than operator: `<`. - Lt, - /// The less-than or equal operator: `<=`. - LtEq, - /// The greater-than operator: `>`. - Gt, - /// The greater-than or equal operator: `>=`. - GtEq, - /// The add-assign operator: `+=`. - PlusEq, - /// The subtract-assign operator: `-=`. - HyphEq, - /// The multiply-assign operator: `*=`. - StarEq, - /// The divide-assign operator: `/=`. - SlashEq, - /// The spread operator: `..`. - Dots, - /// An arrow between a closure's parameters and body: `=>`. - Arrow, - /// A root: `√`, `∛` or `∜`. - Root, - - /// The `not` operator. - Not, - /// The `and` operator. - And, - /// The `or` operator. - Or, - /// The `none` literal. - None, - /// The `auto` literal. - Auto, - /// The `let` keyword. - Let, - /// The `set` keyword. - Set, - /// The `show` keyword. - Show, - /// 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 `as` keyword. - As, - - /// Code. - Code, - /// An identifier: `it`. - Ident, - /// A boolean: `true`, `false`. - Bool, - /// An integer: `120`. - Int, - /// A floating-point number: `1.2`, `10e-4`. - Float, - /// A numeric value with a unit: `12pt`, `3cm`, `2em`, `90deg`, `50%`. - Numeric, - /// A quoted string: `"..."`. - Str, - /// A code block: `{ let x = 1; x + 2 }`. - CodeBlock, - /// A content block: `[*Hi* there!]`. - ContentBlock, - /// A grouped expression: `(1 + 2)`. - Parenthesized, - /// An array: `(1, "hi", 12cm)`. - Array, - /// A dictionary: `(thickness: 3pt, pattern: dashed)`. - Dict, - /// A named pair: `thickness: 3pt`. - Named, - /// A keyed pair: `"spacy key": true`. - Keyed, - /// A unary operation: `-x`. - Unary, - /// A binary operation: `a + b`. - Binary, - /// A field access: `properties.age`. - FieldAccess, - /// An invocation of a function or method: `f(x, y)`. - FuncCall, - /// A function call's argument list: `(12pt, y)`. - Args, - /// Spread arguments or an argument sink: `..x`. - Spread, - /// A closure: `(x, y) => z`. - Closure, - /// A closure's parameters: `(x, y)`. - Params, - /// A let binding: `let x = 1`. - LetBinding, - /// A set rule: `set text(...)`. - SetRule, - /// A show rule: `show heading: it => emph(it.body)`. - ShowRule, - /// An if-else conditional: `if x { y } else { z }`. - Conditional, - /// A while loop: `while x { y }`. - WhileLoop, - /// A for loop: `for x in y { z }`. - ForLoop, - /// A module import: `import "utils.typ": a, b, c`. - ModuleImport, - /// Items to import from a module: `a, b, c`. - ImportItems, - /// A module include: `include "chapter1.typ"`. - ModuleInclude, - /// A break from a loop: `break`. - LoopBreak, - /// A continue in a loop: `continue`. - LoopContinue, - /// A return from a function: `return`, `return x + 1`. - FuncReturn, - /// A destructuring pattern: `(x, _, ..y)`. - Destructuring, - /// A destructuring assignment expression: `(x, y) = (1, 2)`. - DestructAssignment, - - /// A line comment: `// ...`. - LineComment, - /// A block comment: `/* ... */`. - BlockComment, - /// An invalid sequence of characters. - Error, - /// The end of the file. - Eof, -} - -impl SyntaxKind { - /// Is this a bracket, brace, or parenthesis? - pub fn is_grouping(self) -> bool { - matches!( - self, - Self::LeftBracket - | Self::LeftBrace - | Self::LeftParen - | Self::RightBracket - | Self::RightBrace - | Self::RightParen - ) - } - - /// Does this node terminate a preceding expression? - pub fn is_terminator(self) -> bool { - matches!( - self, - Self::Eof - | Self::Semicolon - | Self::RightBrace - | Self::RightParen - | Self::RightBracket - ) - } - - /// Is this a code or content block. - pub fn is_block(self) -> bool { - matches!(self, Self::CodeBlock | Self::ContentBlock) - } - - /// Does this node need termination through a semicolon or linebreak? - pub fn is_stmt(self) -> bool { - matches!( - self, - Self::LetBinding - | Self::SetRule - | Self::ShowRule - | Self::ModuleImport - | Self::ModuleInclude - ) - } - - /// Whether this kind of node is automatically skipped by the parser in - /// code and math mode. - pub fn is_trivia(self) -> bool { - matches!( - self, - Self::Space | Self::Parbreak | Self::LineComment | Self::BlockComment - ) - } - - /// Whether this is an error. - pub fn is_error(self) -> bool { - self == Self::Error - } - - /// A human-readable name for the kind. - pub fn name(self) -> &'static str { - match self { - Self::Markup => "markup", - Self::Text => "text", - Self::Space => "space", - Self::Linebreak => "line break", - Self::Parbreak => "paragraph break", - Self::Escape => "escape sequence", - Self::Shorthand => "shorthand", - Self::SmartQuote => "smart quote", - Self::Strong => "strong content", - Self::Emph => "emphasized content", - Self::Raw => "raw block", - Self::Link => "link", - Self::Label => "label", - Self::Ref => "reference", - Self::RefMarker => "reference marker", - Self::Heading => "heading", - Self::HeadingMarker => "heading marker", - Self::ListItem => "list item", - Self::ListMarker => "list marker", - Self::EnumItem => "enum item", - Self::EnumMarker => "enum marker", - Self::TermItem => "term list item", - Self::TermMarker => "term marker", - Self::Equation => "equation", - Self::Math => "math", - Self::MathIdent => "math identifier", - Self::MathAlignPoint => "math alignment point", - Self::MathDelimited => "delimited math", - Self::MathAttach => "math attachments", - Self::MathFrac => "math fraction", - Self::MathRoot => "math root", - Self::Hashtag => "hashtag", - Self::LeftBrace => "opening brace", - Self::RightBrace => "closing brace", - Self::LeftBracket => "opening bracket", - Self::RightBracket => "closing bracket", - Self::LeftParen => "opening paren", - Self::RightParen => "closing paren", - Self::Comma => "comma", - Self::Semicolon => "semicolon", - Self::Colon => "colon", - Self::Star => "star", - Self::Underscore => "underscore", - Self::Dollar => "dollar sign", - Self::Plus => "plus", - Self::Minus => "minus", - Self::Slash => "slash", - Self::Hat => "hat", - Self::Dot => "dot", - Self::Eq => "equals sign", - 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::Root => "root", - Self::Not => "operator `not`", - Self::And => "operator `and`", - Self::Or => "operator `or`", - Self::None => "`none`", - Self::Auto => "`auto`", - Self::Let => "keyword `let`", - Self::Set => "keyword `set`", - Self::Show => "keyword `show`", - 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::As => "keyword `as`", - Self::Code => "code", - Self::Ident => "identifier", - Self::Bool => "boolean", - Self::Int => "integer", - Self::Float => "float", - Self::Numeric => "numeric value", - Self::Str => "string", - Self::CodeBlock => "code block", - Self::ContentBlock => "content block", - Self::Parenthesized => "group", - Self::Array => "array", - Self::Dict => "dictionary", - Self::Named => "named pair", - Self::Keyed => "keyed pair", - Self::Unary => "unary expression", - Self::Binary => "binary expression", - Self::FieldAccess => "field access", - Self::FuncCall => "function call", - Self::Args => "call arguments", - Self::Spread => "spread", - Self::Closure => "closure", - Self::Params => "closure parameters", - Self::LetBinding => "`let` expression", - Self::SetRule => "`set` expression", - Self::ShowRule => "`show` expression", - Self::Conditional => "`if` expression", - Self::WhileLoop => "while-loop expression", - Self::ForLoop => "for-loop expression", - Self::ModuleImport => "`import` expression", - Self::ImportItems => "import items", - Self::ModuleInclude => "`include` expression", - Self::LoopBreak => "`break` expression", - Self::LoopContinue => "`continue` expression", - Self::FuncReturn => "`return` expression", - Self::Destructuring => "destructuring pattern", - Self::DestructAssignment => "destructuring assignment expression", - Self::LineComment => "line comment", - Self::BlockComment => "block comment", - Self::Error => "syntax error", - Self::Eof => "end of file", - } - } -} |