From 09d17b4d2168fa09c02749ad20de3693a87ae091 Mon Sep 17 00:00:00 2001 From: Laurenz Date: Tue, 31 Jan 2023 19:29:14 +0100 Subject: [PATCH] Remove `Category` to `Tag` --- src/ide/highlight.rs | 186 +++++++++++++++++++++---------------------- 1 file changed, 93 insertions(+), 93 deletions(-) diff --git a/src/ide/highlight.rs b/src/ide/highlight.rs index 20aa6998a..53b56d7a1 100644 --- a/src/ide/highlight.rs +++ b/src/ide/highlight.rs @@ -1,8 +1,8 @@ use crate::syntax::{ast, LinkedNode, SyntaxKind, SyntaxNode}; -/// Syntax highlighting categories. +/// Syntax highlighting tag. #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub enum Category { +pub enum Tag { /// A line or block comment. Comment, /// Punctuation in code. @@ -47,9 +47,9 @@ pub enum Category { Error, } -impl Category { +impl Tag { /// Return the recommended TextMate grammar scope for the given highlighting - /// category. + /// tag. pub fn tm_scope(&self) -> &'static str { match self { Self::Comment => "comment.typst", @@ -76,7 +76,7 @@ impl Category { } } - /// The recommended CSS class for the highlighting category. + /// The recommended CSS class for the highlighting tag. pub fn css_class(self) -> &'static str { match self { Self::Comment => "typ-comment", @@ -104,119 +104,119 @@ impl Category { } } -/// Determine the highlight category of a linked syntax node. +/// Determine the highlight tag of a linked syntax node. /// /// Returns `None` if the node should not be highlighted. -pub fn highlight(node: &LinkedNode) -> Option { +pub fn highlight(node: &LinkedNode) -> Option { match node.kind() { SyntaxKind::Markup if node.parent_kind() == Some(SyntaxKind::TermItem) && node.next_sibling_kind() == Some(SyntaxKind::Colon) => { - Some(Category::ListTerm) + Some(Tag::ListTerm) } SyntaxKind::Markup => None, SyntaxKind::Text => None, SyntaxKind::Space => None, - SyntaxKind::Linebreak => Some(Category::Escape), + SyntaxKind::Linebreak => Some(Tag::Escape), SyntaxKind::Parbreak => None, - SyntaxKind::Escape => Some(Category::Escape), - SyntaxKind::Shorthand => Some(Category::Escape), + SyntaxKind::Escape => Some(Tag::Escape), + SyntaxKind::Shorthand => Some(Tag::Escape), SyntaxKind::SmartQuote => None, - SyntaxKind::Strong => Some(Category::Strong), - SyntaxKind::Emph => Some(Category::Emph), - SyntaxKind::Raw => Some(Category::Raw), - SyntaxKind::Link => Some(Category::Link), - SyntaxKind::Label => Some(Category::Label), - SyntaxKind::Ref => Some(Category::Ref), - SyntaxKind::Heading => Some(Category::Heading), + SyntaxKind::Strong => Some(Tag::Strong), + SyntaxKind::Emph => Some(Tag::Emph), + SyntaxKind::Raw => Some(Tag::Raw), + SyntaxKind::Link => Some(Tag::Link), + SyntaxKind::Label => Some(Tag::Label), + SyntaxKind::Ref => Some(Tag::Ref), + SyntaxKind::Heading => Some(Tag::Heading), SyntaxKind::HeadingMarker => None, SyntaxKind::ListItem => None, - SyntaxKind::ListMarker => Some(Category::ListMarker), + SyntaxKind::ListMarker => Some(Tag::ListMarker), SyntaxKind::EnumItem => None, - SyntaxKind::EnumMarker => Some(Category::ListMarker), + SyntaxKind::EnumMarker => Some(Tag::ListMarker), SyntaxKind::TermItem => None, - SyntaxKind::TermMarker => Some(Category::ListMarker), + SyntaxKind::TermMarker => Some(Tag::ListMarker), SyntaxKind::Formula => None, SyntaxKind::Math => None, SyntaxKind::MathIdent => highlight_ident(node), - SyntaxKind::MathAlignPoint => Some(Category::MathOperator), + SyntaxKind::MathAlignPoint => Some(Tag::MathOperator), SyntaxKind::MathDelimited => None, SyntaxKind::MathAttach => None, SyntaxKind::MathFrac => None, SyntaxKind::Hashtag => highlight_hashtag(node), - SyntaxKind::LeftBrace => Some(Category::Punctuation), - SyntaxKind::RightBrace => Some(Category::Punctuation), - SyntaxKind::LeftBracket => Some(Category::Punctuation), - SyntaxKind::RightBracket => Some(Category::Punctuation), - SyntaxKind::LeftParen => Some(Category::Punctuation), - SyntaxKind::RightParen => Some(Category::Punctuation), - SyntaxKind::Comma => Some(Category::Punctuation), - SyntaxKind::Semicolon => Some(Category::Punctuation), - SyntaxKind::Colon => Some(Category::Punctuation), + SyntaxKind::LeftBrace => Some(Tag::Punctuation), + SyntaxKind::RightBrace => Some(Tag::Punctuation), + SyntaxKind::LeftBracket => Some(Tag::Punctuation), + SyntaxKind::RightBracket => Some(Tag::Punctuation), + SyntaxKind::LeftParen => Some(Tag::Punctuation), + SyntaxKind::RightParen => Some(Tag::Punctuation), + SyntaxKind::Comma => Some(Tag::Punctuation), + SyntaxKind::Semicolon => Some(Tag::Punctuation), + SyntaxKind::Colon => Some(Tag::Punctuation), SyntaxKind::Star => match node.parent_kind() { Some(SyntaxKind::Strong) => None, - _ => Some(Category::Operator), + _ => Some(Tag::Operator), }, SyntaxKind::Underscore => match node.parent_kind() { - Some(SyntaxKind::MathAttach) => Some(Category::MathOperator), + Some(SyntaxKind::MathAttach) => Some(Tag::MathOperator), _ => None, }, - SyntaxKind::Dollar => Some(Category::MathDelimiter), - SyntaxKind::Plus => Some(Category::Operator), - SyntaxKind::Minus => Some(Category::Operator), + SyntaxKind::Dollar => Some(Tag::MathDelimiter), + SyntaxKind::Plus => Some(Tag::Operator), + SyntaxKind::Minus => Some(Tag::Operator), SyntaxKind::Slash => Some(match node.parent_kind() { - Some(SyntaxKind::MathFrac) => Category::MathOperator, - _ => Category::Operator, + Some(SyntaxKind::MathFrac) => Tag::MathOperator, + _ => Tag::Operator, }), - SyntaxKind::Hat => Some(Category::MathOperator), - SyntaxKind::Dot => Some(Category::Punctuation), + SyntaxKind::Hat => Some(Tag::MathOperator), + SyntaxKind::Dot => Some(Tag::Punctuation), SyntaxKind::Eq => match node.parent_kind() { Some(SyntaxKind::Heading) => None, - _ => Some(Category::Operator), + _ => Some(Tag::Operator), }, - SyntaxKind::EqEq => Some(Category::Operator), - SyntaxKind::ExclEq => Some(Category::Operator), - SyntaxKind::Lt => Some(Category::Operator), - SyntaxKind::LtEq => Some(Category::Operator), - SyntaxKind::Gt => Some(Category::Operator), - SyntaxKind::GtEq => Some(Category::Operator), - SyntaxKind::PlusEq => Some(Category::Operator), - SyntaxKind::HyphEq => Some(Category::Operator), - SyntaxKind::StarEq => Some(Category::Operator), - SyntaxKind::SlashEq => Some(Category::Operator), - SyntaxKind::Dots => Some(Category::Operator), - SyntaxKind::Arrow => Some(Category::Operator), + SyntaxKind::EqEq => Some(Tag::Operator), + SyntaxKind::ExclEq => Some(Tag::Operator), + SyntaxKind::Lt => Some(Tag::Operator), + SyntaxKind::LtEq => Some(Tag::Operator), + SyntaxKind::Gt => Some(Tag::Operator), + SyntaxKind::GtEq => Some(Tag::Operator), + SyntaxKind::PlusEq => Some(Tag::Operator), + SyntaxKind::HyphEq => Some(Tag::Operator), + SyntaxKind::StarEq => Some(Tag::Operator), + SyntaxKind::SlashEq => Some(Tag::Operator), + SyntaxKind::Dots => Some(Tag::Operator), + SyntaxKind::Arrow => Some(Tag::Operator), - SyntaxKind::Not => Some(Category::Keyword), - SyntaxKind::And => Some(Category::Keyword), - SyntaxKind::Or => Some(Category::Keyword), - SyntaxKind::None => Some(Category::Keyword), - SyntaxKind::Auto => Some(Category::Keyword), - SyntaxKind::Let => Some(Category::Keyword), - SyntaxKind::Set => Some(Category::Keyword), - SyntaxKind::Show => Some(Category::Keyword), - SyntaxKind::If => Some(Category::Keyword), - SyntaxKind::Else => Some(Category::Keyword), - SyntaxKind::For => Some(Category::Keyword), - SyntaxKind::In => Some(Category::Keyword), - SyntaxKind::While => Some(Category::Keyword), - SyntaxKind::Break => Some(Category::Keyword), - SyntaxKind::Continue => Some(Category::Keyword), - SyntaxKind::Return => Some(Category::Keyword), - SyntaxKind::Import => Some(Category::Keyword), - SyntaxKind::Include => Some(Category::Keyword), - SyntaxKind::As => Some(Category::Keyword), + SyntaxKind::Not => Some(Tag::Keyword), + SyntaxKind::And => Some(Tag::Keyword), + SyntaxKind::Or => Some(Tag::Keyword), + SyntaxKind::None => Some(Tag::Keyword), + SyntaxKind::Auto => Some(Tag::Keyword), + SyntaxKind::Let => Some(Tag::Keyword), + SyntaxKind::Set => Some(Tag::Keyword), + SyntaxKind::Show => Some(Tag::Keyword), + SyntaxKind::If => Some(Tag::Keyword), + SyntaxKind::Else => Some(Tag::Keyword), + SyntaxKind::For => Some(Tag::Keyword), + SyntaxKind::In => Some(Tag::Keyword), + SyntaxKind::While => Some(Tag::Keyword), + SyntaxKind::Break => Some(Tag::Keyword), + SyntaxKind::Continue => Some(Tag::Keyword), + SyntaxKind::Return => Some(Tag::Keyword), + SyntaxKind::Import => Some(Tag::Keyword), + SyntaxKind::Include => Some(Tag::Keyword), + SyntaxKind::As => Some(Tag::Keyword), SyntaxKind::Code => None, SyntaxKind::Ident => highlight_ident(node), - SyntaxKind::Bool => Some(Category::Keyword), - SyntaxKind::Int => Some(Category::Number), - SyntaxKind::Float => Some(Category::Number), - SyntaxKind::Numeric => Some(Category::Number), - SyntaxKind::Str => Some(Category::String), + SyntaxKind::Bool => Some(Tag::Keyword), + SyntaxKind::Int => Some(Tag::Number), + SyntaxKind::Float => Some(Tag::Number), + SyntaxKind::Numeric => Some(Tag::Number), + SyntaxKind::Str => Some(Tag::String), SyntaxKind::CodeBlock => None, SyntaxKind::ContentBlock => None, SyntaxKind::Parenthesized => None, @@ -246,15 +246,15 @@ pub fn highlight(node: &LinkedNode) -> Option { SyntaxKind::LoopContinue => None, SyntaxKind::FuncReturn => None, - SyntaxKind::LineComment => Some(Category::Comment), - SyntaxKind::BlockComment => Some(Category::Comment), - SyntaxKind::Error => Some(Category::Error), + SyntaxKind::LineComment => Some(Tag::Comment), + SyntaxKind::BlockComment => Some(Tag::Comment), + SyntaxKind::Error => Some(Tag::Error), SyntaxKind::Eof => None, } } /// Highlight an identifier based on context. -fn highlight_ident(node: &LinkedNode) -> Option { +fn highlight_ident(node: &LinkedNode) -> Option { // Are we directly before an argument list? let next_leaf = node.next_leaf(); if let Some(next) = &next_leaf { @@ -264,13 +264,13 @@ fn highlight_ident(node: &LinkedNode) -> Option { || (next.kind() == SyntaxKind::LeftBracket && next.parent_kind() == Some(SyntaxKind::ContentBlock)) { - return Some(Category::Function); + return Some(Tag::Function); } } // Are we in math? if node.kind() == SyntaxKind::MathIdent { - return Some(Category::Interpolated); + return Some(Tag::Interpolated); } // Find the first non-field access ancestor. @@ -283,12 +283,12 @@ fn highlight_ident(node: &LinkedNode) -> Option { if next_leaf.map(|leaf| leaf.kind()) == Some(SyntaxKind::Colon) && ancestor.parent_kind() == Some(SyntaxKind::ShowRule) { - return Some(Category::Function); + return Some(Tag::Function); } // Are we (or an ancestor field access) directly after a hashtag. if ancestor.prev_leaf().map(|leaf| leaf.kind()) == Some(SyntaxKind::Hashtag) { - return Some(Category::Interpolated); + return Some(Tag::Interpolated); } // Are we behind a dot, that is behind another identifier? @@ -304,7 +304,7 @@ fn highlight_ident(node: &LinkedNode) -> Option { } /// Highlight a hashtag based on context. -fn highlight_hashtag(node: &LinkedNode) -> Option { +fn highlight_hashtag(node: &LinkedNode) -> Option { let next = node.next_sibling()?; let expr = next.cast::()?; if !expr.hashtag() { @@ -320,7 +320,7 @@ fn is_ident(node: &LinkedNode) -> bool { /// Highlight a node to an HTML `code` element. /// -/// This uses these [CSS classes for categories](Category::css_class). +/// This uses these [CSS classes for categories](Tag::css_class). pub fn highlight_html(root: &SyntaxNode) -> String { let mut buf = String::from(""); let node = LinkedNode::new(root); @@ -332,11 +332,11 @@ pub fn highlight_html(root: &SyntaxNode) -> String { /// Highlight one source node, emitting HTML. fn highlight_html_impl(html: &mut String, node: &LinkedNode) { let mut span = false; - if let Some(category) = highlight(node) { - if category != Category::Error { + if let Some(tag) = highlight(node) { + if tag != Tag::Error { span = true; html.push_str(""); } } @@ -373,17 +373,17 @@ mod tests { #[test] fn test_highlighting() { - use Category::*; + use Tag::*; #[track_caller] - fn test(text: &str, goal: &[(Range, Category)]) { + fn test(text: &str, goal: &[(Range, Tag)]) { let mut vec = vec![]; let source = Source::detached(text); highlight_tree(&mut vec, &LinkedNode::new(source.root())); assert_eq!(vec, goal); } - fn highlight_tree(tags: &mut Vec<(Range, Category)>, node: &LinkedNode) { + fn highlight_tree(tags: &mut Vec<(Range, Tag)>, node: &LinkedNode) { if let Some(tag) = highlight(node) { tags.push((node.range(), tag)); }